20141214
- Bugfix (introduced: 20141212): typo in Clang function pointer
- format check, making it a noop. Viktor Dukhovni. File:
- util/sys_defs.h.
+ Bugfix (introduced: 20141212): typo in Clang function pointer
+ format check, making it a noop. Viktor Dukhovni. File:
+ util/sys_defs.h.
+
+ Maintainability: argument typechecking for the variadic
+ attribute-value read/write functions. For full typechecking
+ compile with -DVARARGS_ATTR_DEBUG. Files: anvil/anvil.c,
+ bounce/bounce.c, cleanup/cleanup.c, dnsblog/dnsblog.c,
+ flush/flush.c, global/abounce.c, global/anvil_clnt.c,
+ global/bounce.c, global/defer.c, global/deliver_pass.c,
+ global/deliver_request.c, global/dict_proxy.c, global/dsb_scan.c,
+ global/dsn_print.c, global/flush_clnt.c,
+ global/mail_command_client.c, global/mail_stream.c,
+ global/msg_stats_print.c, global/msg_stats_scan.c,
+ global/post_mail.c, global/rcpt_buf.c, global/rcpt_print.c,
+ global/resolve_clnt.c, global/rewrite_clnt.c, global/scache_clnt.c,
+ global/trace.c, global/verify_clnt.c, local/forward.c,
+ milter/milter.c, milter/milter8.c, milter/milter_macros.c,
+ oqmgr/qmgr_deliver.c, pickup/pickup.c, postdrop/postdrop.c,
+ postscreen/postscreen_dnsbl.c, postscreen/postscreen_send.c,
+ postscreen/postscreen_starttls.c, proxymap/proxymap.c,
+ qmgr/qmgr_deliver.c, qmqpd/qmqpd.c, scache/scache.c,
+ smtpd/smtpd.c, smtpd/smtpd_check.c, tls/tls_mgr.c,
+ tls/tls_proxy_clnt.c, tls/tls_proxy_print.c, tls/tls_proxy_scan.c,
+ tlsmgr/tlsmgr.c, tlsproxy/tlsproxy.c, trivial-rewrite/resolve.c,
+ trivial-rewrite/rewrite.c, trivial-rewrite/trivial-rewrite.c,
+ util/attr.h.
# Non-production: needs thorough testing, or major changes are still
# needed before the code stabilizes.
-#CCARGS="$CCARGS -DNONPROD"
+CCARGS="$CCARGS -DNONPROD"
# Workaround: prepend Postfix include files before other include files.
CCARGS="-I. -I../../include $CCARGS"
if ((anvil_remote =
(ANVIL_REMOTE *) htable_find(anvil_remote_map, ident)) == 0) {
attr_print_plain(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, ANVIL_ATTR_STATUS, ANVIL_STAT_OK,
- ATTR_TYPE_INT, ANVIL_ATTR_COUNT, 0,
- ATTR_TYPE_INT, ANVIL_ATTR_RATE, 0,
- ATTR_TYPE_INT, ANVIL_ATTR_MAIL, 0,
- ATTR_TYPE_INT, ANVIL_ATTR_RCPT, 0,
- ATTR_TYPE_INT, ANVIL_ATTR_NTLS, 0,
+ SEND_ATTR_INT(ANVIL_ATTR_STATUS, ANVIL_STAT_OK),
+ SEND_ATTR_INT(ANVIL_ATTR_COUNT, 0),
+ SEND_ATTR_INT(ANVIL_ATTR_RATE, 0),
+ SEND_ATTR_INT(ANVIL_ATTR_MAIL, 0),
+ SEND_ATTR_INT(ANVIL_ATTR_RCPT, 0),
+ SEND_ATTR_INT(ANVIL_ATTR_NTLS, 0),
ATTR_TYPE_END);
} else {
&& anvil_remote->start + var_anvil_time_unit < event_time())
ANVIL_REMOTE_RSET_RATE(anvil_remote, 0);
attr_print_plain(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, ANVIL_ATTR_STATUS, ANVIL_STAT_OK,
- ATTR_TYPE_INT, ANVIL_ATTR_COUNT, anvil_remote->count,
- ATTR_TYPE_INT, ANVIL_ATTR_RATE, anvil_remote->rate,
- ATTR_TYPE_INT, ANVIL_ATTR_MAIL, anvil_remote->mail,
- ATTR_TYPE_INT, ANVIL_ATTR_RCPT, anvil_remote->rcpt,
- ATTR_TYPE_INT, ANVIL_ATTR_NTLS, anvil_remote->ntls,
+ SEND_ATTR_INT(ANVIL_ATTR_STATUS, ANVIL_STAT_OK),
+ SEND_ATTR_INT(ANVIL_ATTR_COUNT, anvil_remote->count),
+ SEND_ATTR_INT(ANVIL_ATTR_RATE, anvil_remote->rate),
+ SEND_ATTR_INT(ANVIL_ATTR_MAIL, anvil_remote->mail),
+ SEND_ATTR_INT(ANVIL_ATTR_RCPT, anvil_remote->rcpt),
+ SEND_ATTR_INT(ANVIL_ATTR_NTLS, anvil_remote->ntls),
ATTR_TYPE_END);
}
}
* Respond to the local server.
*/
attr_print_plain(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, ANVIL_ATTR_STATUS, ANVIL_STAT_OK,
- ATTR_TYPE_INT, ANVIL_ATTR_COUNT, anvil_remote->count,
- ATTR_TYPE_INT, ANVIL_ATTR_RATE, anvil_remote->rate,
+ SEND_ATTR_INT(ANVIL_ATTR_STATUS, ANVIL_STAT_OK),
+ SEND_ATTR_INT(ANVIL_ATTR_COUNT, anvil_remote->count),
+ SEND_ATTR_INT(ANVIL_ATTR_RATE, anvil_remote->rate),
ATTR_TYPE_END);
/*
*/
ANVIL_REMOTE_INCR_MAIL(anvil_remote);
attr_print_plain(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, ANVIL_ATTR_STATUS, ANVIL_STAT_OK,
- ATTR_TYPE_INT, ANVIL_ATTR_RATE, anvil_remote->mail,
+ SEND_ATTR_INT(ANVIL_ATTR_STATUS, ANVIL_STAT_OK),
+ SEND_ATTR_INT(ANVIL_ATTR_RATE, anvil_remote->mail),
ATTR_TYPE_END);
/*
*/
ANVIL_REMOTE_INCR_RCPT(anvil_remote);
attr_print_plain(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, ANVIL_ATTR_STATUS, ANVIL_STAT_OK,
- ATTR_TYPE_INT, ANVIL_ATTR_RATE, anvil_remote->rcpt,
+ SEND_ATTR_INT(ANVIL_ATTR_STATUS, ANVIL_STAT_OK),
+ SEND_ATTR_INT(ANVIL_ATTR_RATE, anvil_remote->rcpt),
ATTR_TYPE_END);
/*
*/
ANVIL_REMOTE_INCR_NTLS(anvil_remote);
attr_print_plain(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, ANVIL_ATTR_STATUS, ANVIL_STAT_OK,
- ATTR_TYPE_INT, ANVIL_ATTR_RATE, anvil_remote->ntls,
+ SEND_ATTR_INT(ANVIL_ATTR_STATUS, ANVIL_STAT_OK),
+ SEND_ATTR_INT(ANVIL_ATTR_RATE, anvil_remote->ntls),
ATTR_TYPE_END);
/*
* Respond to local server.
*/
attr_print_plain(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, ANVIL_ATTR_STATUS, ANVIL_STAT_OK,
- ATTR_TYPE_INT, ANVIL_ATTR_RATE, rate,
+ SEND_ATTR_INT(ANVIL_ATTR_STATUS, ANVIL_STAT_OK),
+ SEND_ATTR_INT(ANVIL_ATTR_RATE, rate),
ATTR_TYPE_END);
}
* Respond to the local server.
*/
attr_print_plain(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, ANVIL_ATTR_STATUS, ANVIL_STAT_OK,
+ SEND_ATTR_INT(ANVIL_ATTR_STATUS, ANVIL_STAT_OK),
ATTR_TYPE_END);
}
msg_info("--- start request ---");
if (attr_scan_plain(client_stream,
ATTR_FLAG_MISSING | ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, ANVIL_ATTR_REQ, request,
- ATTR_TYPE_STR, ANVIL_ATTR_IDENT, ident,
+ RECV_ATTR_STR(ANVIL_ATTR_REQ, request),
+ RECV_ATTR_STR(ANVIL_ATTR_IDENT, ident),
ATTR_TYPE_END) == 2) {
for (rp = request_table; /* see below */ ; rp++) {
if (rp->name == 0) {
msg_warn("unrecognized request: \"%s\", ignored", STR(request));
attr_print_plain(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, ANVIL_ATTR_STATUS, ANVIL_STAT_FAIL,
+ SEND_ATTR_INT(ANVIL_ATTR_STATUS, ANVIL_STAT_FAIL),
ATTR_TYPE_END);
break;
}
* Read and validate the client request.
*/
if (mail_command_server(client,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, &flags,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, queue_id,
- ATTR_TYPE_FUNC, rcpb_scan, (void *) rcpt_buf,
- ATTR_TYPE_FUNC, dsb_scan, (void *) dsn_buf,
+ RECV_ATTR_INT(MAIL_ATTR_FLAGS, &flags),
+ RECV_ATTR_STR(MAIL_ATTR_QUEUEID, queue_id),
+ RECV_ATTR_FUNC(rcpb_scan, (void *) rcpt_buf),
+ RECV_ATTR_FUNC(dsb_scan, (void *) dsn_buf),
ATTR_TYPE_END) != 4) {
msg_warn("malformed request");
return (-1);
* Read and validate the client request.
*/
if (mail_command_server(client,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, &flags,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUE, queue_name,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, queue_id,
- ATTR_TYPE_STR, MAIL_ATTR_ENCODING, encoding,
- ATTR_TYPE_INT, MAIL_ATTR_SMTPUTF8, &smtputf8,
- ATTR_TYPE_STR, MAIL_ATTR_SENDER, sender,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_ENVID, dsn_envid,
- ATTR_TYPE_INT, MAIL_ATTR_DSN_RET, &dsn_ret,
+ RECV_ATTR_INT(MAIL_ATTR_FLAGS, &flags),
+ RECV_ATTR_STR(MAIL_ATTR_QUEUE, queue_name),
+ RECV_ATTR_STR(MAIL_ATTR_QUEUEID, queue_id),
+ RECV_ATTR_STR(MAIL_ATTR_ENCODING, encoding),
+ RECV_ATTR_INT(MAIL_ATTR_SMTPUTF8, &smtputf8),
+ RECV_ATTR_STR(MAIL_ATTR_SENDER, sender),
+ RECV_ATTR_STR(MAIL_ATTR_DSN_ENVID, dsn_envid),
+ RECV_ATTR_INT(MAIL_ATTR_DSN_RET, &dsn_ret),
ATTR_TYPE_END) != 8) {
msg_warn("malformed request");
return (-1);
* Read and validate the client request.
*/
if (mail_command_server(client,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, &flags,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUE, queue_name,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, queue_id,
- ATTR_TYPE_STR, MAIL_ATTR_ENCODING, encoding,
- ATTR_TYPE_INT, MAIL_ATTR_SMTPUTF8, &smtputf8,
- ATTR_TYPE_STR, MAIL_ATTR_SENDER, sender,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_ENVID, dsn_envid,
- ATTR_TYPE_INT, MAIL_ATTR_DSN_RET, &dsn_ret,
- ATTR_TYPE_STR, MAIL_ATTR_VERPDL, verp_delims,
+ RECV_ATTR_INT(MAIL_ATTR_FLAGS, &flags),
+ RECV_ATTR_STR(MAIL_ATTR_QUEUE, queue_name),
+ RECV_ATTR_STR(MAIL_ATTR_QUEUEID, queue_id),
+ RECV_ATTR_STR(MAIL_ATTR_ENCODING, encoding),
+ RECV_ATTR_INT(MAIL_ATTR_SMTPUTF8, &smtputf8),
+ RECV_ATTR_STR(MAIL_ATTR_SENDER, sender),
+ RECV_ATTR_STR(MAIL_ATTR_DSN_ENVID, dsn_envid),
+ RECV_ATTR_INT(MAIL_ATTR_DSN_RET, &dsn_ret),
+ RECV_ATTR_STR(MAIL_ATTR_VERPDL, verp_delims),
ATTR_TYPE_END) != 9) {
msg_warn("malformed request");
return (-1);
* Read and validate the client request.
*/
if (mail_command_server(client,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, &flags,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUE, queue_name,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, queue_id,
- ATTR_TYPE_STR, MAIL_ATTR_ENCODING, encoding,
- ATTR_TYPE_INT, MAIL_ATTR_SMTPUTF8, &smtputf8,
- ATTR_TYPE_STR, MAIL_ATTR_SENDER, sender,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_ENVID, dsn_envid,
- ATTR_TYPE_INT, MAIL_ATTR_DSN_RET, &dsn_ret,
- ATTR_TYPE_FUNC, rcpb_scan, (void *) rcpt_buf,
- ATTR_TYPE_FUNC, dsb_scan, (void *) dsn_buf,
+ RECV_ATTR_INT(MAIL_ATTR_FLAGS, &flags),
+ RECV_ATTR_STR(MAIL_ATTR_QUEUE, queue_name),
+ RECV_ATTR_STR(MAIL_ATTR_QUEUEID, queue_id),
+ RECV_ATTR_STR(MAIL_ATTR_ENCODING, encoding),
+ RECV_ATTR_INT(MAIL_ATTR_SMTPUTF8, &smtputf8),
+ RECV_ATTR_STR(MAIL_ATTR_SENDER, sender),
+ RECV_ATTR_STR(MAIL_ATTR_DSN_ENVID, dsn_envid),
+ RECV_ATTR_INT(MAIL_ATTR_DSN_RET, &dsn_ret),
+ RECV_ATTR_FUNC(rcpb_scan, (void *) rcpt_buf),
+ RECV_ATTR_FUNC(dsb_scan, (void *) dsn_buf),
ATTR_TYPE_END) != 10) {
msg_warn("malformed request");
return (-1);
* request-specific protocol routines take care of the remainder.
*/
if (attr_scan(client, ATTR_FLAG_STRICT | ATTR_FLAG_MORE,
- ATTR_TYPE_INT, MAIL_ATTR_NREQ, &command, 0) != 1) {
+ RECV_ATTR_INT(MAIL_ATTR_NREQ, &command), 0) != 1) {
msg_warn("malformed request");
status = -1;
} else if (command == BOUNCE_CMD_VERP) {
* client.
*/
attr_print(client, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, status,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, status),
ATTR_TYPE_END);
vstream_fflush(client);
* about the whole operation.
*/
attr_print(src, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, state->queue_id,
+ SEND_ATTR_STR(MAIL_ATTR_QUEUEID, state->queue_id),
ATTR_TYPE_END);
if (attr_scan(src, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, &flags,
+ RECV_ATTR_INT(MAIL_ATTR_FLAGS, &flags),
ATTR_TYPE_END) != 1) {
state->errs |= CLEANUP_STAT_BAD;
flags = 0;
*/
status = cleanup_flush(state); /* in case state is modified */
attr_print(src, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, status,
- ATTR_TYPE_STR, MAIL_ATTR_WHY,
- (state->flags & CLEANUP_FLAG_SMTP_REPLY)
- && state->smtp_reply ? state->smtp_reply :
- state->reason ? state->reason : "",
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, status),
+ SEND_ATTR_STR(MAIL_ATTR_WHY,
+ (state->flags & CLEANUP_FLAG_SMTP_REPLY)
+ && state->smtp_reply ? state->smtp_reply :
+ state->reason ? state->reason : ""),
ATTR_TYPE_END);
cleanup_free(state);
*/
if (attr_scan(client_stream,
ATTR_FLAG_MORE | ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_RBL_DOMAIN, rbl_domain,
- ATTR_TYPE_STR, MAIL_ATTR_ACT_CLIENT_ADDR, addr,
- ATTR_TYPE_INT, MAIL_ATTR_LABEL, &request_id,
+ RECV_ATTR_STR(MAIL_ATTR_RBL_DOMAIN, rbl_domain),
+ RECV_ATTR_STR(MAIL_ATTR_ACT_CLIENT_ADDR, addr),
+ RECV_ATTR_INT(MAIL_ATTR_LABEL, &request_id),
ATTR_TYPE_END) == 3) {
(void) dnsblog_query(result, STR(rbl_domain), STR(addr));
if (var_dnsblog_delay > 0)
sleep(var_dnsblog_delay);
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_RBL_DOMAIN, STR(rbl_domain),
- ATTR_TYPE_STR, MAIL_ATTR_ACT_CLIENT_ADDR, STR(addr),
- ATTR_TYPE_INT, MAIL_ATTR_LABEL, request_id,
- ATTR_TYPE_STR, MAIL_ATTR_RBL_ADDR, STR(result),
+ SEND_ATTR_STR(MAIL_ATTR_RBL_DOMAIN, STR(rbl_domain)),
+ SEND_ATTR_STR(MAIL_ATTR_ACT_CLIENT_ADDR, STR(addr)),
+ SEND_ATTR_INT(MAIL_ATTR_LABEL, request_id),
+ SEND_ATTR_STR(MAIL_ATTR_RBL_ADDR, STR(result)),
ATTR_TYPE_END);
vstream_fflush(client_stream);
}
else {
if (attr_scan(client_stream,
ATTR_FLAG_MORE | ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, request,
+ RECV_ATTR_STR(MAIL_ATTR_REQ, request),
ATTR_TYPE_END) != 1) {
return (-1);
}
site = vstring_alloc(10);
queue_id = vstring_alloc(10);
if (attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_SITE, site,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, queue_id,
+ RECV_ATTR_STR(MAIL_ATTR_SITE, site),
+ RECV_ATTR_STR(MAIL_ATTR_QUEUEID, queue_id),
ATTR_TYPE_END) == 2
&& mail_queue_id_ok(STR(queue_id)))
status = flush_add_service(lowercase(STR(site)), STR(queue_id));
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, status,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, status),
ATTR_TYPE_END);
} else if (STREQ(STR(request), FLUSH_REQ_SEND_SITE)) {
site = vstring_alloc(10);
if (attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_SITE, site,
+ RECV_ATTR_STR(MAIL_ATTR_SITE, site),
ATTR_TYPE_END) == 1)
status = flush_send_service(lowercase(STR(site)),
UNTHROTTLE_BEFORE);
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, status,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, status),
ATTR_TYPE_END);
} else if (STREQ(STR(request), FLUSH_REQ_SEND_FILE)) {
queue_id = vstring_alloc(10);
if (attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, queue_id,
+ RECV_ATTR_STR(MAIL_ATTR_QUEUEID, queue_id),
ATTR_TYPE_END) == 1)
status = flush_send_file_service(STR(queue_id));
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, status,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, status),
ATTR_TYPE_END);
} else if (STREQ(STR(request), FLUSH_REQ_REFRESH)
|| STREQ(STR(request), wakeup)) {
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, FLUSH_STAT_OK,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, FLUSH_STAT_OK),
ATTR_TYPE_END);
vstream_fflush(client_stream);
(void) flush_refresh_service(var_fflush_refresh);
} else if (STREQ(STR(request), FLUSH_REQ_PURGE)) {
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, FLUSH_STAT_OK,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, FLUSH_STAT_OK),
ATTR_TYPE_END);
vstream_fflush(client_stream);
(void) flush_refresh_service(0);
}
} else
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, status,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, status),
ATTR_TYPE_END);
vstring_free(request);
if (site)
ABOUNCE_EVENT_DISABLE(vstream_fileno(ap->fp), abounce_event, context);
abounce_done(ap, (event != EVENT_TIME
&& attr_scan(ap->fp, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &status,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &status),
ATTR_TYPE_END) == 1) ? status : -1);
}
ap->fp = mail_connect_wait(class, service);
if (attr_print(ap->fp, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_NREQ, command,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, flags,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUE, queue,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, id,
- ATTR_TYPE_STR, MAIL_ATTR_ENCODING, encoding,
- ATTR_TYPE_INT, MAIL_ATTR_SMTPUTF8, smtputf8,
- ATTR_TYPE_STR, MAIL_ATTR_SENDER, sender,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_ENVID, dsn_envid,
- ATTR_TYPE_INT, MAIL_ATTR_DSN_RET, dsn_ret,
- ATTR_TYPE_STR, MAIL_ATTR_VERPDL, verp,
+ SEND_ATTR_INT(MAIL_ATTR_NREQ, command),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, flags),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUE, queue),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUEID, id),
+ SEND_ATTR_STR(MAIL_ATTR_ENCODING, encoding),
+ SEND_ATTR_INT(MAIL_ATTR_SMTPUTF8, smtputf8),
+ SEND_ATTR_STR(MAIL_ATTR_SENDER, sender),
+ SEND_ATTR_STR(MAIL_ATTR_DSN_ENVID, dsn_envid),
+ SEND_ATTR_INT(MAIL_ATTR_DSN_RET, dsn_ret),
+ SEND_ATTR_STR(MAIL_ATTR_VERPDL, verp),
ATTR_TYPE_END) == 0
&& vstream_fflush(ap->fp) == 0) {
ABOUNCE_EVENT_ENABLE(vstream_fileno(ap->fp), abounce_event,
ap->fp = mail_connect_wait(class, service);
if (attr_print(ap->fp, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_NREQ, command,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, flags,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUE, queue,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, id,
- ATTR_TYPE_STR, MAIL_ATTR_ENCODING, encoding,
- ATTR_TYPE_INT, MAIL_ATTR_SMTPUTF8, smtputf8,
- ATTR_TYPE_STR, MAIL_ATTR_SENDER, sender,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_ENVID, dsn_envid,
- ATTR_TYPE_INT, MAIL_ATTR_DSN_RET, dsn_ret,
+ SEND_ATTR_INT(MAIL_ATTR_NREQ, command),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, flags),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUE, queue),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUEID, id),
+ SEND_ATTR_STR(MAIL_ATTR_ENCODING, encoding),
+ SEND_ATTR_INT(MAIL_ATTR_SMTPUTF8, smtputf8),
+ SEND_ATTR_STR(MAIL_ATTR_SENDER, sender),
+ SEND_ATTR_STR(MAIL_ATTR_DSN_ENVID, dsn_envid),
+ SEND_ATTR_INT(MAIL_ATTR_DSN_RET, dsn_ret),
ATTR_TYPE_END) == 0
&& vstream_fflush(ap->fp) == 0) {
ABOUNCE_EVENT_ENABLE(vstream_fileno(ap->fp), abounce_event,
if (attr_clnt_request((ATTR_CLNT *) anvil_clnt,
ATTR_FLAG_NONE, /* Query attributes. */
- ATTR_TYPE_STR, ANVIL_ATTR_REQ, ANVIL_REQ_LOOKUP,
- ATTR_TYPE_STR, ANVIL_ATTR_IDENT, ident,
+ SEND_ATTR_STR(ANVIL_ATTR_REQ, ANVIL_REQ_LOOKUP),
+ SEND_ATTR_STR(ANVIL_ATTR_IDENT, ident),
ATTR_TYPE_END,
ATTR_FLAG_MISSING, /* Reply attributes. */
- ATTR_TYPE_INT, ANVIL_ATTR_STATUS, &status,
- ATTR_TYPE_INT, ANVIL_ATTR_COUNT, count,
- ATTR_TYPE_INT, ANVIL_ATTR_RATE, rate,
- ATTR_TYPE_INT, ANVIL_ATTR_MAIL, msgs,
- ATTR_TYPE_INT, ANVIL_ATTR_RCPT, rcpts,
- ATTR_TYPE_INT, ANVIL_ATTR_NTLS, newtls,
+ RECV_ATTR_INT(ANVIL_ATTR_STATUS, &status),
+ RECV_ATTR_INT(ANVIL_ATTR_COUNT, count),
+ RECV_ATTR_INT(ANVIL_ATTR_RATE, rate),
+ RECV_ATTR_INT(ANVIL_ATTR_MAIL, msgs),
+ RECV_ATTR_INT(ANVIL_ATTR_RCPT, rcpts),
+ RECV_ATTR_INT(ANVIL_ATTR_NTLS, newtls),
ATTR_TYPE_END) != 6)
status = ANVIL_STAT_FAIL;
else if (status != ANVIL_STAT_OK)
if (attr_clnt_request((ATTR_CLNT *) anvil_clnt,
ATTR_FLAG_NONE, /* Query attributes. */
- ATTR_TYPE_STR, ANVIL_ATTR_REQ, ANVIL_REQ_CONN,
- ATTR_TYPE_STR, ANVIL_ATTR_IDENT, ident,
+ SEND_ATTR_STR(ANVIL_ATTR_REQ, ANVIL_REQ_CONN),
+ SEND_ATTR_STR(ANVIL_ATTR_IDENT, ident),
ATTR_TYPE_END,
ATTR_FLAG_MISSING, /* Reply attributes. */
- ATTR_TYPE_INT, ANVIL_ATTR_STATUS, &status,
- ATTR_TYPE_INT, ANVIL_ATTR_COUNT, count,
- ATTR_TYPE_INT, ANVIL_ATTR_RATE, rate,
+ RECV_ATTR_INT(ANVIL_ATTR_STATUS, &status),
+ RECV_ATTR_INT(ANVIL_ATTR_COUNT, count),
+ RECV_ATTR_INT(ANVIL_ATTR_RATE, rate),
ATTR_TYPE_END) != 3)
status = ANVIL_STAT_FAIL;
else if (status != ANVIL_STAT_OK)
if (attr_clnt_request((ATTR_CLNT *) anvil_clnt,
ATTR_FLAG_NONE, /* Query attributes. */
- ATTR_TYPE_STR, ANVIL_ATTR_REQ, ANVIL_REQ_MAIL,
- ATTR_TYPE_STR, ANVIL_ATTR_IDENT, ident,
+ SEND_ATTR_STR(ANVIL_ATTR_REQ, ANVIL_REQ_MAIL),
+ SEND_ATTR_STR(ANVIL_ATTR_IDENT, ident),
ATTR_TYPE_END,
ATTR_FLAG_MISSING, /* Reply attributes. */
- ATTR_TYPE_INT, ANVIL_ATTR_STATUS, &status,
- ATTR_TYPE_INT, ANVIL_ATTR_RATE, msgs,
+ RECV_ATTR_INT(ANVIL_ATTR_STATUS, &status),
+ RECV_ATTR_INT(ANVIL_ATTR_RATE, msgs),
ATTR_TYPE_END) != 2)
status = ANVIL_STAT_FAIL;
else if (status != ANVIL_STAT_OK)
if (attr_clnt_request((ATTR_CLNT *) anvil_clnt,
ATTR_FLAG_NONE, /* Query attributes. */
- ATTR_TYPE_STR, ANVIL_ATTR_REQ, ANVIL_REQ_RCPT,
- ATTR_TYPE_STR, ANVIL_ATTR_IDENT, ident,
+ SEND_ATTR_STR(ANVIL_ATTR_REQ, ANVIL_REQ_RCPT),
+ SEND_ATTR_STR(ANVIL_ATTR_IDENT, ident),
ATTR_TYPE_END,
ATTR_FLAG_MISSING, /* Reply attributes. */
- ATTR_TYPE_INT, ANVIL_ATTR_STATUS, &status,
- ATTR_TYPE_INT, ANVIL_ATTR_RATE, rcpts,
+ RECV_ATTR_INT(ANVIL_ATTR_STATUS, &status),
+ RECV_ATTR_INT(ANVIL_ATTR_RATE, rcpts),
ATTR_TYPE_END) != 2)
status = ANVIL_STAT_FAIL;
else if (status != ANVIL_STAT_OK)
if (attr_clnt_request((ATTR_CLNT *) anvil_clnt,
ATTR_FLAG_NONE, /* Query attributes. */
- ATTR_TYPE_STR, ANVIL_ATTR_REQ, ANVIL_REQ_NTLS,
- ATTR_TYPE_STR, ANVIL_ATTR_IDENT, ident,
+ SEND_ATTR_STR(ANVIL_ATTR_REQ, ANVIL_REQ_NTLS),
+ SEND_ATTR_STR(ANVIL_ATTR_IDENT, ident),
ATTR_TYPE_END,
ATTR_FLAG_MISSING, /* Reply attributes. */
- ATTR_TYPE_INT, ANVIL_ATTR_STATUS, &status,
- ATTR_TYPE_INT, ANVIL_ATTR_RATE, newtls,
+ RECV_ATTR_INT(ANVIL_ATTR_STATUS, &status),
+ RECV_ATTR_INT(ANVIL_ATTR_RATE, newtls),
ATTR_TYPE_END) != 2)
status = ANVIL_STAT_FAIL;
else if (status != ANVIL_STAT_OK)
if (attr_clnt_request((ATTR_CLNT *) anvil_clnt,
ATTR_FLAG_NONE, /* Query attributes. */
- ATTR_TYPE_STR, ANVIL_ATTR_REQ, ANVIL_REQ_NTLS_STAT,
- ATTR_TYPE_STR, ANVIL_ATTR_IDENT, ident,
+ SEND_ATTR_STR(ANVIL_ATTR_REQ, ANVIL_REQ_NTLS_STAT),
+ SEND_ATTR_STR(ANVIL_ATTR_IDENT, ident),
ATTR_TYPE_END,
ATTR_FLAG_MISSING, /* Reply attributes. */
- ATTR_TYPE_INT, ANVIL_ATTR_STATUS, &status,
- ATTR_TYPE_INT, ANVIL_ATTR_RATE, newtls,
+ RECV_ATTR_INT(ANVIL_ATTR_STATUS, &status),
+ RECV_ATTR_INT(ANVIL_ATTR_RATE, newtls),
ATTR_TYPE_END) != 2)
status = ANVIL_STAT_FAIL;
else if (status != ANVIL_STAT_OK)
if (attr_clnt_request((ATTR_CLNT *) anvil_clnt,
ATTR_FLAG_NONE, /* Query attributes. */
- ATTR_TYPE_STR, ANVIL_ATTR_REQ, ANVIL_REQ_DISC,
- ATTR_TYPE_STR, ANVIL_ATTR_IDENT, ident,
+ SEND_ATTR_STR(ANVIL_ATTR_REQ, ANVIL_REQ_DISC),
+ SEND_ATTR_STR(ANVIL_ATTR_IDENT, ident),
ATTR_TYPE_END,
ATTR_FLAG_MISSING, /* Reply attributes. */
- ATTR_TYPE_INT, ANVIL_ATTR_STATUS, &status,
+ RECV_ATTR_INT(ANVIL_ATTR_STATUS, &status),
ATTR_TYPE_END) != 1)
status = ANVIL_STAT_FAIL;
else if (status != ANVIL_STAT_OK)
if (mail_command_client(MAIL_CLASS_PRIVATE, var_soft_bounce ?
var_defer_service : var_bounce_service,
- ATTR_TYPE_INT, MAIL_ATTR_NREQ, BOUNCE_CMD_APPEND,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, flags,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, id,
- ATTR_TYPE_FUNC, rcpt_print, (void *) rcpt,
- ATTR_TYPE_FUNC, dsn_print, (void *) &my_dsn,
+ SEND_ATTR_INT(MAIL_ATTR_NREQ, BOUNCE_CMD_APPEND),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, flags),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUEID, id),
+ SEND_ATTR_FUNC(rcpt_print, (void *) rcpt),
+ SEND_ATTR_FUNC(dsn_print, (void *) &my_dsn),
ATTR_TYPE_END) == 0
&& ((flags & DEL_REQ_FLAG_RECORD) == 0
|| trace_append(flags, id, stats, rcpt, relay,
if (var_soft_bounce)
return (-1);
if (mail_command_client(MAIL_CLASS_PRIVATE, var_bounce_service,
- ATTR_TYPE_INT, MAIL_ATTR_NREQ, BOUNCE_CMD_FLUSH,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, flags,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUE, queue,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, id,
- ATTR_TYPE_STR, MAIL_ATTR_ENCODING, encoding,
- ATTR_TYPE_INT, MAIL_ATTR_SMTPUTF8, smtputf8,
- ATTR_TYPE_STR, MAIL_ATTR_SENDER, sender,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_ENVID, dsn_envid,
- ATTR_TYPE_INT, MAIL_ATTR_DSN_RET, dsn_ret,
+ SEND_ATTR_INT(MAIL_ATTR_NREQ, BOUNCE_CMD_FLUSH),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, flags),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUE, queue),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUEID, id),
+ SEND_ATTR_STR(MAIL_ATTR_ENCODING, encoding),
+ SEND_ATTR_INT(MAIL_ATTR_SMTPUTF8, smtputf8),
+ SEND_ATTR_STR(MAIL_ATTR_SENDER, sender),
+ SEND_ATTR_STR(MAIL_ATTR_DSN_ENVID, dsn_envid),
+ SEND_ATTR_INT(MAIL_ATTR_DSN_RET, dsn_ret),
ATTR_TYPE_END) == 0) {
return (0);
} else if ((flags & BOUNCE_FLAG_CLEAN) == 0) {
if (var_soft_bounce)
return (-1);
if (mail_command_client(MAIL_CLASS_PRIVATE, var_bounce_service,
- ATTR_TYPE_INT, MAIL_ATTR_NREQ, BOUNCE_CMD_VERP,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, flags,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUE, queue,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, id,
- ATTR_TYPE_STR, MAIL_ATTR_ENCODING, encoding,
- ATTR_TYPE_INT, MAIL_ATTR_SMTPUTF8, smtputf8,
- ATTR_TYPE_STR, MAIL_ATTR_SENDER, sender,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_ENVID, dsn_envid,
- ATTR_TYPE_INT, MAIL_ATTR_DSN_RET, dsn_ret,
- ATTR_TYPE_STR, MAIL_ATTR_VERPDL, verp_delims,
+ SEND_ATTR_INT(MAIL_ATTR_NREQ, BOUNCE_CMD_VERP),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, flags),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUE, queue),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUEID, id),
+ SEND_ATTR_STR(MAIL_ATTR_ENCODING, encoding),
+ SEND_ATTR_INT(MAIL_ATTR_SMTPUTF8, smtputf8),
+ SEND_ATTR_STR(MAIL_ATTR_SENDER, sender),
+ SEND_ATTR_STR(MAIL_ATTR_DSN_ENVID, dsn_envid),
+ SEND_ATTR_INT(MAIL_ATTR_DSN_RET, dsn_ret),
+ SEND_ATTR_STR(MAIL_ATTR_VERPDL, verp_delims),
ATTR_TYPE_END) == 0) {
return (0);
} else if ((flags & BOUNCE_FLAG_CLEAN) == 0) {
my_dsn.action = "failed";
if (mail_command_client(MAIL_CLASS_PRIVATE, var_bounce_service,
- ATTR_TYPE_INT, MAIL_ATTR_NREQ, BOUNCE_CMD_ONE,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, flags,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUE, queue,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, id,
- ATTR_TYPE_STR, MAIL_ATTR_ENCODING, encoding,
- ATTR_TYPE_INT, MAIL_ATTR_SMTPUTF8, smtputf8,
- ATTR_TYPE_STR, MAIL_ATTR_SENDER, sender,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_ENVID, dsn_envid,
- ATTR_TYPE_INT, MAIL_ATTR_DSN_RET, dsn_ret,
- ATTR_TYPE_FUNC, rcpt_print, (void *) rcpt,
- ATTR_TYPE_FUNC, dsn_print, (void *) &my_dsn,
+ SEND_ATTR_INT(MAIL_ATTR_NREQ, BOUNCE_CMD_ONE),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, flags),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUE, queue),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUEID, id),
+ SEND_ATTR_STR(MAIL_ATTR_ENCODING, encoding),
+ SEND_ATTR_INT(MAIL_ATTR_SMTPUTF8, smtputf8),
+ SEND_ATTR_STR(MAIL_ATTR_SENDER, sender),
+ SEND_ATTR_STR(MAIL_ATTR_DSN_ENVID, dsn_envid),
+ SEND_ATTR_INT(MAIL_ATTR_DSN_RET, dsn_ret),
+ SEND_ATTR_FUNC(rcpt_print, (void *) rcpt),
+ SEND_ATTR_FUNC(dsn_print, (void *) &my_dsn),
ATTR_TYPE_END) == 0
&& ((flags & DEL_REQ_FLAG_RECORD) == 0
|| trace_append(flags, id, stats, rcpt, relay,
/* const char *dsn_envid;
/* int dsn_ret;
/*
-/* int defer_warn(flags, queue, id, encoding, smtputf8, sender,
+/* int defer_warn(flags, queue, id, encoding, smtputf8, sender,
dsn_envid, dsn_ret)
/* int flags;
/* const char *queue;
my_dsn.action = "delayed";
if (mail_command_client(MAIL_CLASS_PRIVATE, var_defer_service,
- ATTR_TYPE_INT, MAIL_ATTR_NREQ, BOUNCE_CMD_APPEND,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, flags,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, id,
- ATTR_TYPE_FUNC, rcpt_print, (void *) rcpt,
- ATTR_TYPE_FUNC, dsn_print, (void *) &my_dsn,
+ SEND_ATTR_INT(MAIL_ATTR_NREQ, BOUNCE_CMD_APPEND),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, flags),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUEID, id),
+ SEND_ATTR_FUNC(rcpt_print, (void *) rcpt),
+ SEND_ATTR_FUNC(dsn_print, (void *) &my_dsn),
ATTR_TYPE_END) != 0)
msg_warn("%s: %s service failure", id, var_defer_service);
log_adhoc(id, stats, rcpt, relay, &my_dsn, "deferred");
flags |= BOUNCE_FLAG_DELRCPT;
if (mail_command_client(MAIL_CLASS_PRIVATE, var_defer_service,
- ATTR_TYPE_INT, MAIL_ATTR_NREQ, BOUNCE_CMD_FLUSH,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, flags,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUE, queue,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, id,
- ATTR_TYPE_STR, MAIL_ATTR_ENCODING, encoding,
- ATTR_TYPE_INT, MAIL_ATTR_SMTPUTF8, smtputf8,
- ATTR_TYPE_STR, MAIL_ATTR_SENDER, sender,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_ENVID, dsn_envid,
- ATTR_TYPE_INT, MAIL_ATTR_DSN_RET, dsn_ret,
+ SEND_ATTR_INT(MAIL_ATTR_NREQ, BOUNCE_CMD_FLUSH),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, flags),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUE, queue),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUEID, id),
+ SEND_ATTR_STR(MAIL_ATTR_ENCODING, encoding),
+ SEND_ATTR_INT(MAIL_ATTR_SMTPUTF8, smtputf8),
+ SEND_ATTR_STR(MAIL_ATTR_SENDER, sender),
+ SEND_ATTR_STR(MAIL_ATTR_DSN_ENVID, dsn_envid),
+ SEND_ATTR_INT(MAIL_ATTR_DSN_RET, dsn_ret),
ATTR_TYPE_END) == 0) {
return (0);
} else {
* do not flush the log */
int defer_warn(int flags, const char *queue, const char *id,
- const char *encoding, int smtputf8,
+ const char *encoding, int smtputf8,
const char *sender, const char *envid, int dsn_ret)
{
if (mail_command_client(MAIL_CLASS_PRIVATE, var_defer_service,
- ATTR_TYPE_INT, MAIL_ATTR_NREQ, BOUNCE_CMD_WARN,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, flags,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUE, queue,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, id,
- ATTR_TYPE_STR, MAIL_ATTR_ENCODING, encoding,
- ATTR_TYPE_INT, MAIL_ATTR_SMTPUTF8, smtputf8,
- ATTR_TYPE_STR, MAIL_ATTR_SENDER, sender,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_ENVID, envid,
- ATTR_TYPE_INT, MAIL_ATTR_DSN_RET, dsn_ret,
+ SEND_ATTR_INT(MAIL_ATTR_NREQ, BOUNCE_CMD_WARN),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, flags),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUE, queue),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUEID, id),
+ SEND_ATTR_STR(MAIL_ATTR_ENCODING, encoding),
+ SEND_ATTR_INT(MAIL_ATTR_SMTPUTF8, smtputf8),
+ SEND_ATTR_STR(MAIL_ATTR_SENDER, sender),
+ SEND_ATTR_STR(MAIL_ATTR_DSN_ENVID, envid),
+ SEND_ATTR_INT(MAIL_ATTR_DSN_RET, dsn_ret),
ATTR_TYPE_END) == 0) {
return (0);
} else {
int stat;
if (attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &stat,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &stat),
ATTR_TYPE_END) != 1) {
msg_warn("%s: malformed response", VSTREAM_PATH(stream));
stat = -1;
int stat;
attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, request->flags,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUE, request->queue_name,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, request->queue_id,
- ATTR_TYPE_LONG, MAIL_ATTR_OFFSET, request->data_offset,
- ATTR_TYPE_LONG, MAIL_ATTR_SIZE, request->data_size,
- ATTR_TYPE_STR, MAIL_ATTR_NEXTHOP, nexthop,
- ATTR_TYPE_STR, MAIL_ATTR_ENCODING, request->encoding,
- ATTR_TYPE_INT, MAIL_ATTR_SMTPUTF8, request->smtputf8,
- ATTR_TYPE_STR, MAIL_ATTR_SENDER, request->sender,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_ENVID, request->dsn_envid,
- ATTR_TYPE_INT, MAIL_ATTR_DSN_RET, request->dsn_ret,
- ATTR_TYPE_FUNC, msg_stats_print, (void *) &request->msg_stats,
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, request->flags),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUE, request->queue_name),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUEID, request->queue_id),
+ SEND_ATTR_LONG(MAIL_ATTR_OFFSET, request->data_offset),
+ SEND_ATTR_LONG(MAIL_ATTR_SIZE, request->data_size),
+ SEND_ATTR_STR(MAIL_ATTR_NEXTHOP, nexthop),
+ SEND_ATTR_STR(MAIL_ATTR_ENCODING, request->encoding),
+ SEND_ATTR_INT(MAIL_ATTR_SMTPUTF8, request->smtputf8),
+ SEND_ATTR_STR(MAIL_ATTR_SENDER, request->sender),
+ SEND_ATTR_STR(MAIL_ATTR_DSN_ENVID, request->dsn_envid),
+ SEND_ATTR_INT(MAIL_ATTR_DSN_RET, request->dsn_ret),
+ SEND_ATTR_FUNC(msg_stats_print, (void *) &request->msg_stats),
/* XXX Should be encapsulated with ATTR_TYPE_FUNC. */
- ATTR_TYPE_STR, MAIL_ATTR_LOG_CLIENT_NAME, request->client_name,
- ATTR_TYPE_STR, MAIL_ATTR_LOG_CLIENT_ADDR, request->client_addr,
- ATTR_TYPE_STR, MAIL_ATTR_LOG_CLIENT_PORT, request->client_port,
- ATTR_TYPE_STR, MAIL_ATTR_LOG_PROTO_NAME, request->client_proto,
- ATTR_TYPE_STR, MAIL_ATTR_LOG_HELO_NAME, request->client_helo,
+ SEND_ATTR_STR(MAIL_ATTR_LOG_CLIENT_NAME, request->client_name),
+ SEND_ATTR_STR(MAIL_ATTR_LOG_CLIENT_ADDR, request->client_addr),
+ SEND_ATTR_STR(MAIL_ATTR_LOG_CLIENT_PORT, request->client_port),
+ SEND_ATTR_STR(MAIL_ATTR_LOG_PROTO_NAME, request->client_proto),
+ SEND_ATTR_STR(MAIL_ATTR_LOG_HELO_NAME, request->client_helo),
/* XXX Should be encapsulated with ATTR_TYPE_FUNC. */
- ATTR_TYPE_STR, MAIL_ATTR_SASL_METHOD, request->sasl_method,
- ATTR_TYPE_STR, MAIL_ATTR_SASL_USERNAME, request->sasl_username,
- ATTR_TYPE_STR, MAIL_ATTR_SASL_SENDER, request->sasl_sender,
+ SEND_ATTR_STR(MAIL_ATTR_SASL_METHOD, request->sasl_method),
+ SEND_ATTR_STR(MAIL_ATTR_SASL_USERNAME, request->sasl_username),
+ SEND_ATTR_STR(MAIL_ATTR_SASL_SENDER, request->sasl_sender),
/* XXX Ditto if we want to pass TLS certificate info. */
- ATTR_TYPE_STR, MAIL_ATTR_LOG_IDENT, request->log_ident,
- ATTR_TYPE_STR, MAIL_ATTR_RWR_CONTEXT, request->rewrite_context,
- ATTR_TYPE_INT, MAIL_ATTR_RCPT_COUNT, 1,
+ SEND_ATTR_STR(MAIL_ATTR_LOG_IDENT, request->log_ident),
+ SEND_ATTR_STR(MAIL_ATTR_RWR_CONTEXT, request->rewrite_context),
+ SEND_ATTR_INT(MAIL_ATTR_RCPT_COUNT, 1),
ATTR_TYPE_END);
attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_FUNC, rcpt_print, (void *) rcpt,
+ SEND_ATTR_FUNC(rcpt_print, (void *) rcpt),
ATTR_TYPE_END);
if (vstream_fflush(stream)) {
int stat;
if (attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_FUNC, dsb_scan, (void *) dsb,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &stat,
+ RECV_ATTR_FUNC(dsb_scan, (void *) dsb),
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &stat),
ATTR_TYPE_END) != 2) {
msg_warn("%s: malformed response", VSTREAM_PATH(stream));
return (DELIVER_PASS_UNKNOWN);
if (msg_verbose)
msg_info("deliver_request_initial: send initial status");
attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, 0,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, 0),
ATTR_TYPE_END);
if ((err = vstream_fflush(stream)) != 0)
if (msg_verbose)
msg_info("deliver_request_final: send: \"%s\" %d",
hop_status->reason, status);
attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_FUNC, dsn_print, (void *) hop_status,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, status,
+ SEND_ATTR_FUNC(dsn_print, (void *) hop_status),
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, status),
ATTR_TYPE_END);
if ((err = vstream_fflush(stream)) != 0)
if (msg_verbose)
* the conversation when they send bad information.
*/
if (attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, &request->flags,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUE, queue_name,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, queue_id,
- ATTR_TYPE_LONG, MAIL_ATTR_OFFSET, &request->data_offset,
- ATTR_TYPE_LONG, MAIL_ATTR_SIZE, &request->data_size,
- ATTR_TYPE_STR, MAIL_ATTR_NEXTHOP, nexthop,
- ATTR_TYPE_STR, MAIL_ATTR_ENCODING, encoding,
- ATTR_TYPE_INT, MAIL_ATTR_SMTPUTF8, &smtputf8,
- ATTR_TYPE_STR, MAIL_ATTR_SENDER, address,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_ENVID, dsn_envid,
- ATTR_TYPE_INT, MAIL_ATTR_DSN_RET, &dsn_ret,
- ATTR_TYPE_FUNC, msg_stats_scan, (void *) &request->msg_stats,
+ RECV_ATTR_INT(MAIL_ATTR_FLAGS, &request->flags),
+ RECV_ATTR_STR(MAIL_ATTR_QUEUE, queue_name),
+ RECV_ATTR_STR(MAIL_ATTR_QUEUEID, queue_id),
+ RECV_ATTR_LONG(MAIL_ATTR_OFFSET, &request->data_offset),
+ RECV_ATTR_LONG(MAIL_ATTR_SIZE, &request->data_size),
+ RECV_ATTR_STR(MAIL_ATTR_NEXTHOP, nexthop),
+ RECV_ATTR_STR(MAIL_ATTR_ENCODING, encoding),
+ RECV_ATTR_INT(MAIL_ATTR_SMTPUTF8, &smtputf8),
+ RECV_ATTR_STR(MAIL_ATTR_SENDER, address),
+ RECV_ATTR_STR(MAIL_ATTR_DSN_ENVID, dsn_envid),
+ RECV_ATTR_INT(MAIL_ATTR_DSN_RET, &dsn_ret),
+ RECV_ATTR_FUNC(msg_stats_scan, (void *) &request->msg_stats),
/* XXX Should be encapsulated with ATTR_TYPE_FUNC. */
- ATTR_TYPE_STR, MAIL_ATTR_LOG_CLIENT_NAME, client_name,
- ATTR_TYPE_STR, MAIL_ATTR_LOG_CLIENT_ADDR, client_addr,
- ATTR_TYPE_STR, MAIL_ATTR_LOG_CLIENT_PORT, client_port,
- ATTR_TYPE_STR, MAIL_ATTR_LOG_PROTO_NAME, client_proto,
- ATTR_TYPE_STR, MAIL_ATTR_LOG_HELO_NAME, client_helo,
+ RECV_ATTR_STR(MAIL_ATTR_LOG_CLIENT_NAME, client_name),
+ RECV_ATTR_STR(MAIL_ATTR_LOG_CLIENT_ADDR, client_addr),
+ RECV_ATTR_STR(MAIL_ATTR_LOG_CLIENT_PORT, client_port),
+ RECV_ATTR_STR(MAIL_ATTR_LOG_PROTO_NAME, client_proto),
+ RECV_ATTR_STR(MAIL_ATTR_LOG_HELO_NAME, client_helo),
/* XXX Should be encapsulated with ATTR_TYPE_FUNC. */
- ATTR_TYPE_STR, MAIL_ATTR_SASL_METHOD, sasl_method,
- ATTR_TYPE_STR, MAIL_ATTR_SASL_USERNAME, sasl_username,
- ATTR_TYPE_STR, MAIL_ATTR_SASL_SENDER, sasl_sender,
+ RECV_ATTR_STR(MAIL_ATTR_SASL_METHOD, sasl_method),
+ RECV_ATTR_STR(MAIL_ATTR_SASL_USERNAME, sasl_username),
+ RECV_ATTR_STR(MAIL_ATTR_SASL_SENDER, sasl_sender),
/* XXX Ditto if we want to pass TLS certificate info. */
- ATTR_TYPE_STR, MAIL_ATTR_LOG_IDENT, log_ident,
- ATTR_TYPE_STR, MAIL_ATTR_RWR_CONTEXT, rewrite_context,
- ATTR_TYPE_INT, MAIL_ATTR_RCPT_COUNT, &rcpt_count,
+ RECV_ATTR_STR(MAIL_ATTR_LOG_IDENT, log_ident),
+ RECV_ATTR_STR(MAIL_ATTR_RWR_CONTEXT, rewrite_context),
+ RECV_ATTR_INT(MAIL_ATTR_RCPT_COUNT, &rcpt_count),
ATTR_TYPE_END) != 23) {
msg_warn("%s: error receiving common attributes", myname);
return (-1);
*/
while (rcpt_count-- > 0) {
if (attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_FUNC, rcpb_scan, (void *) rcpt_buf,
+ RECV_ATTR_FUNC(rcpb_scan, (void *) rcpt_buf),
ATTR_TYPE_END) != 1) {
msg_warn("%s: error receiving recipient attributes", myname);
return (-1);
errno = 0;
count += 1;
if (attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, PROXY_REQ_SEQUENCE,
- ATTR_TYPE_STR, MAIL_ATTR_TABLE, dict->name,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, request_flags,
- ATTR_TYPE_INT, MAIL_ATTR_FUNC, function,
+ SEND_ATTR_STR(MAIL_ATTR_REQ, PROXY_REQ_SEQUENCE),
+ SEND_ATTR_STR(MAIL_ATTR_TABLE, dict->name),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, request_flags),
+ SEND_ATTR_INT(MAIL_ATTR_FUNC, function),
ATTR_TYPE_END) != 0
|| vstream_fflush(stream)
|| attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &status,
- ATTR_TYPE_STR, MAIL_ATTR_KEY, dict_proxy->reskey,
- ATTR_TYPE_STR, MAIL_ATTR_VALUE, dict_proxy->result,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &status),
+ RECV_ATTR_STR(MAIL_ATTR_KEY, dict_proxy->reskey),
+ RECV_ATTR_STR(MAIL_ATTR_VALUE, dict_proxy->result),
ATTR_TYPE_END) != 3) {
if (msg_verbose || count > 1 || (errno && errno != EPIPE && errno != ENOENT))
msg_warn("%s: service %s: %m", myname, VSTREAM_PATH(stream));
errno = 0;
count += 1;
if (attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, PROXY_REQ_LOOKUP,
- ATTR_TYPE_STR, MAIL_ATTR_TABLE, dict->name,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, request_flags,
- ATTR_TYPE_STR, MAIL_ATTR_KEY, key,
+ SEND_ATTR_STR(MAIL_ATTR_REQ, PROXY_REQ_LOOKUP),
+ SEND_ATTR_STR(MAIL_ATTR_TABLE, dict->name),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, request_flags),
+ SEND_ATTR_STR(MAIL_ATTR_KEY, key),
ATTR_TYPE_END) != 0
|| vstream_fflush(stream)
|| attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &status,
- ATTR_TYPE_STR, MAIL_ATTR_VALUE, dict_proxy->result,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &status),
+ RECV_ATTR_STR(MAIL_ATTR_VALUE, dict_proxy->result),
ATTR_TYPE_END) != 2) {
if (msg_verbose || count > 1 || (errno && errno != EPIPE && errno != ENOENT))
msg_warn("%s: service %s: %m", myname, VSTREAM_PATH(stream));
errno = 0;
count += 1;
if (attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, PROXY_REQ_UPDATE,
- ATTR_TYPE_STR, MAIL_ATTR_TABLE, dict->name,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, request_flags,
- ATTR_TYPE_STR, MAIL_ATTR_KEY, key,
- ATTR_TYPE_STR, MAIL_ATTR_VALUE, value,
+ SEND_ATTR_STR(MAIL_ATTR_REQ, PROXY_REQ_UPDATE),
+ SEND_ATTR_STR(MAIL_ATTR_TABLE, dict->name),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, request_flags),
+ SEND_ATTR_STR(MAIL_ATTR_KEY, key),
+ SEND_ATTR_STR(MAIL_ATTR_VALUE, value),
ATTR_TYPE_END) != 0
|| vstream_fflush(stream)
|| attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &status,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &status),
ATTR_TYPE_END) != 1) {
if (msg_verbose || count > 1 || (errno && errno != EPIPE && errno != ENOENT))
msg_warn("%s: service %s: %m", myname, VSTREAM_PATH(stream));
errno = 0;
count += 1;
if (attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, PROXY_REQ_DELETE,
- ATTR_TYPE_STR, MAIL_ATTR_TABLE, dict->name,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, request_flags,
- ATTR_TYPE_STR, MAIL_ATTR_KEY, key,
+ SEND_ATTR_STR(MAIL_ATTR_REQ, PROXY_REQ_DELETE),
+ SEND_ATTR_STR(MAIL_ATTR_TABLE, dict->name),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, request_flags),
+ SEND_ATTR_STR(MAIL_ATTR_KEY, key),
ATTR_TYPE_END) != 0
|| vstream_fflush(stream)
|| attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &status,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &status),
ATTR_TYPE_END) != 1) {
if (msg_verbose || count > 1 || (errno && errno != EPIPE && errno !=
ENOENT))
stream = clnt_stream_access(dict_proxy->clnt);
errno = 0;
if (attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, PROXY_REQ_OPEN,
- ATTR_TYPE_STR, MAIL_ATTR_TABLE, dict_proxy->dict.name,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, dict_proxy->inst_flags,
+ SEND_ATTR_STR(MAIL_ATTR_REQ, PROXY_REQ_OPEN),
+ SEND_ATTR_STR(MAIL_ATTR_TABLE, dict_proxy->dict.name),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, dict_proxy->inst_flags),
ATTR_TYPE_END) != 0
|| vstream_fflush(stream)
|| attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &status,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, &server_flags,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &status),
+ RECV_ATTR_INT(MAIL_ATTR_FLAGS, &server_flags),
ATTR_TYPE_END) != 2) {
if (msg_verbose || (errno != EPIPE && errno != ENOENT))
msg_warn("%s: service %s: %m", VSTREAM_PATH(stream), myname);
/* specified attribute scan routine. dsb_scan() is meant
/* to be passed as a call-back to attr_scan(), thusly:
/*
-/* ... ATTR_TYPE_FUNC, dsb_scan, (void *) &dsbuf, ...
+/* ... RECV_ATTR_FUNC(dsb_scan, (void *) &dsbuf), ...
/* DIAGNOSTICS
/* Fatal: out of memory.
/* LICENSE
* be sanitized after all the ad-hoc DSN read/write code is replaced.
*/
ret = scan_fn(fp, flags | ATTR_FLAG_MORE,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_STATUS, dsb->status,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_DTYPE, dsb->dtype,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_DTEXT, dsb->dtext,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_MTYPE, dsb->mtype,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_MNAME, dsb->mname,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_ACTION, dsb->action,
- ATTR_TYPE_STR, MAIL_ATTR_WHY, dsb->reason,
+ RECV_ATTR_STR(MAIL_ATTR_DSN_STATUS, dsb->status),
+ RECV_ATTR_STR(MAIL_ATTR_DSN_DTYPE, dsb->dtype),
+ RECV_ATTR_STR(MAIL_ATTR_DSN_DTEXT, dsb->dtext),
+ RECV_ATTR_STR(MAIL_ATTR_DSN_MTYPE, dsb->mtype),
+ RECV_ATTR_STR(MAIL_ATTR_DSN_MNAME, dsb->mname),
+ RECV_ATTR_STR(MAIL_ATTR_DSN_ACTION, dsb->action),
+ RECV_ATTR_STR(MAIL_ATTR_WHY, dsb->reason),
ATTR_TYPE_END);
return (ret == 7 ? 1 : -1);
}
/* the specified attribute print routine. dsn_print() is meant
/* to be passed as a call-back to attr_print(), thusly:
/*
-/* ... ATTR_TYPE_FUNC, dsn_print, (void *) dsn, ...
+/* ... SEND_ATTR_FUNC(dsn_print, (void *) dsn), ...
/* DIAGNOSTICS
/* Fatal: out of memory.
/* LICENSE
* be sanitized after all the ad-hoc DSN read/write code is replaced.
*/
ret = print_fn(fp, flags | ATTR_FLAG_MORE,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_STATUS, dsn->status,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_DTYPE, dsn->dtype,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_DTEXT, dsn->dtext,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_MTYPE, dsn->mtype,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_MNAME, dsn->mname,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_ACTION, dsn->action,
- ATTR_TYPE_STR, MAIL_ATTR_WHY, dsn->reason,
+ SEND_ATTR_STR(MAIL_ATTR_DSN_STATUS, dsn->status),
+ SEND_ATTR_STR(MAIL_ATTR_DSN_DTYPE, dsn->dtype),
+ SEND_ATTR_STR(MAIL_ATTR_DSN_DTEXT, dsn->dtext),
+ SEND_ATTR_STR(MAIL_ATTR_DSN_MTYPE, dsn->mtype),
+ SEND_ATTR_STR(MAIL_ATTR_DSN_MNAME, dsn->mname),
+ SEND_ATTR_STR(MAIL_ATTR_DSN_ACTION, dsn->action),
+ SEND_ATTR_STR(MAIL_ATTR_WHY, dsn->reason),
ATTR_TYPE_END);
return (ret);
}
status = FLUSH_STAT_DENY;
else
status = mail_command_client(MAIL_CLASS_PUBLIC, var_flush_service,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, FLUSH_REQ_PURGE,
+ SEND_ATTR_STR(MAIL_ATTR_REQ, FLUSH_REQ_PURGE),
ATTR_TYPE_END);
if (msg_verbose)
status = FLUSH_STAT_DENY;
else
status = mail_command_client(MAIL_CLASS_PUBLIC, var_flush_service,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, FLUSH_REQ_REFRESH,
+ SEND_ATTR_STR(MAIL_ATTR_REQ, FLUSH_REQ_REFRESH),
ATTR_TYPE_END);
if (msg_verbose)
VAR_RELAY_DOMAINS "=$mydestination to flush "
"mail for domain \"%s\"", site);
status = mail_command_client(MAIL_CLASS_PUBLIC, var_flush_service,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, FLUSH_REQ_SEND_SITE,
- ATTR_TYPE_STR, MAIL_ATTR_SITE, site,
+ SEND_ATTR_STR(MAIL_ATTR_REQ, FLUSH_REQ_SEND_SITE),
+ SEND_ATTR_STR(MAIL_ATTR_SITE, site),
ATTR_TYPE_END);
} else if (flush_domains->error == 0)
status = FLUSH_STAT_DENY;
* Require that the service is turned on.
*/
status = mail_command_client(MAIL_CLASS_PUBLIC, var_flush_service,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, FLUSH_REQ_SEND_FILE,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, queue_id,
+ SEND_ATTR_STR(MAIL_ATTR_REQ, FLUSH_REQ_SEND_FILE),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUEID, queue_id),
ATTR_TYPE_END);
if (msg_verbose)
VAR_RELAY_DOMAINS "=$mydestination to update "
"fast-flush logfile for domain \"%s\"", site);
status = mail_command_client(MAIL_CLASS_PUBLIC, var_flush_service,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, FLUSH_REQ_ADD,
- ATTR_TYPE_STR, MAIL_ATTR_SITE, site,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, queue_id,
+ SEND_ATTR_STR(MAIL_ATTR_REQ, FLUSH_REQ_ADD),
+ SEND_ATTR_STR(MAIL_ATTR_SITE, site),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUEID, queue_id),
ATTR_TYPE_END);
} else if (flush_domains->error == 0)
status = FLUSH_STAT_DENY;
va_end(ap);
if (status != 0
|| attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &status, 0) != 1)
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &status), 0) != 1)
status = -1;
(void) vstream_fclose(stream);
return (status);
* Receive the peer's completion status.
*/
if ((why && attr_scan(info->stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &status,
- ATTR_TYPE_STR, MAIL_ATTR_WHY, why,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &status),
+ RECV_ATTR_STR(MAIL_ATTR_WHY, why),
ATTR_TYPE_END) != 2)
|| (!why && attr_scan(info->stream, ATTR_FLAG_MISSING,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &status,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &status),
ATTR_TYPE_END) != 1))
status = CLEANUP_STAT_WRITE;
stream = mail_connect_wait(class, name);
if (attr_scan(stream, ATTR_FLAG_MISSING,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, id_buf, 0) != 1) {
+ RECV_ATTR_STR(MAIL_ATTR_QUEUEID, id_buf), 0) != 1) {
vstream_fclose(stream);
return (0);
} else {
VSTREAM_CTL_END);
if (attr_scan(stream, ATTR_FLAG_MISSING,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, id_buf, 0) != 1) {
+ RECV_ATTR_STR(MAIL_ATTR_QUEUEID, id_buf), 0) != 1) {
if ((status = vstream_pclose(stream)) != 0)
msg_warn("command \"%s\" exited with status %d", command, status);
return (0);
/* msg_stats_print() is meant to be passed as a call-back to
/* attr_print(), thusly:
/*
-/* ... ATTR_TYPE_FUNC, msg_stats_print, (void *) stats, ...
+/* ... SEND_ATTR_FUNC(msg_stats_print, (void *) stats), ...
/* DIAGNOSTICS
/* Fatal: out of memory.
/* LICENSE
* initialize the unused fields by hand.
*/
ret = print_fn(fp, flags | ATTR_FLAG_MORE,
- ATTR_TYPE_DATA, MAIL_ATTR_TIME, sizeof(MSG_STATS), ptr,
+ SEND_ATTR_DATA(MAIL_ATTR_TIME, sizeof(MSG_STATS), ptr),
ATTR_TYPE_END);
return (ret);
}
/* using the specified attribute scan routine. msg_stats_scan()
/* is meant to be passed as a call-back to attr_scan(), thusly:
/*
-/* ... ATTR_SCAN_FUNC, msg_stats_scan, (void *) &stats, ...
+/* ... RECV_ATTR_FUNC(msg_stats_scan, (void *) &stats), ...
/* DIAGNOSTICS
/* Fatal: out of memory.
/* LICENSE
* gracefully reject attempts to extend it.
*/
ret = scan_fn(fp, flags | ATTR_FLAG_MORE,
- ATTR_TYPE_DATA, MAIL_ATTR_TIME, buf,
+ RECV_ATTR_DATA(MAIL_ATTR_TIME, buf),
ATTR_TYPE_END);
if (ret == 1) {
if (LEN(buf) == sizeof(*stats)) {
* Negotiate with the cleanup service. Give up if we can't agree.
*/
if (attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, id,
+ RECV_ATTR_STR(MAIL_ATTR_QUEUEID, id),
ATTR_TYPE_END) != 1
|| attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, cleanup_flags,
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, cleanup_flags),
ATTR_TYPE_END) != 0)
msg_fatal("unable to contact the %s service", var_cleanup_service);
rec_fputs(cleanup, REC_TYPE_END, "");
if (vstream_fflush(cleanup)
|| attr_scan(cleanup, ATTR_FLAG_MISSING,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &status,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &status),
ATTR_TYPE_END) != 1)
status = CLEANUP_STAT_WRITE;
}
* can be fixed after all the ad-hoc read/write code is replaced.
*/
ret = scan_fn(fp, flags | ATTR_FLAG_MORE,
- ATTR_TYPE_STR, MAIL_ATTR_ORCPT, rcpt->orig_addr,
- ATTR_TYPE_STR, MAIL_ATTR_RECIP, rcpt->address,
- ATTR_TYPE_LONG, MAIL_ATTR_OFFSET, &rcpt->offset,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_ORCPT, rcpt->dsn_orcpt,
- ATTR_TYPE_INT, MAIL_ATTR_DSN_NOTIFY, &rcpt->dsn_notify,
+ RECV_ATTR_STR(MAIL_ATTR_ORCPT, rcpt->orig_addr),
+ RECV_ATTR_STR(MAIL_ATTR_RECIP, rcpt->address),
+ RECV_ATTR_LONG(MAIL_ATTR_OFFSET, &rcpt->offset),
+ RECV_ATTR_STR(MAIL_ATTR_DSN_ORCPT, rcpt->dsn_orcpt),
+ RECV_ATTR_INT(MAIL_ATTR_DSN_NOTIFY, &rcpt->dsn_notify),
ATTR_TYPE_END);
return (ret == 5 ? 1 : -1);
}
/* routine. rcpt_print() is meant to be passed as a call-back
/* to attr_print(), thusly:
/*
-/* ... ATTR_TYPE_FUNC, rcpt_print, (void *) recipient, ...
+/* ... SEND_ATTR_FUNC(rcpt_print, (void *) recipient), ...
/* DIAGNOSTICS
/* Fatal: out of memory.
/* LICENSE
*/
ret =
print_fn(fp, flags | ATTR_FLAG_MORE,
- ATTR_TYPE_STR, MAIL_ATTR_ORCPT, rcpt->orig_addr,
- ATTR_TYPE_STR, MAIL_ATTR_RECIP, rcpt->address,
- ATTR_TYPE_LONG, MAIL_ATTR_OFFSET, rcpt->offset,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_ORCPT, rcpt->dsn_orcpt,
- ATTR_TYPE_INT, MAIL_ATTR_DSN_NOTIFY, rcpt->dsn_notify,
+ SEND_ATTR_STR(MAIL_ATTR_ORCPT, rcpt->orig_addr),
+ SEND_ATTR_STR(MAIL_ATTR_RECIP, rcpt->address),
+ SEND_ATTR_LONG(MAIL_ATTR_OFFSET, rcpt->offset),
+ SEND_ATTR_STR(MAIL_ATTR_DSN_ORCPT, rcpt->dsn_orcpt),
+ SEND_ATTR_INT(MAIL_ATTR_DSN_NOTIFY, rcpt->dsn_notify),
ATTR_TYPE_END);
return (ret);
}
errno = 0;
count += 1;
if (attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, class,
- ATTR_TYPE_STR, MAIL_ATTR_SENDER, sender,
- ATTR_TYPE_STR, MAIL_ATTR_ADDR, addr,
+ SEND_ATTR_STR(MAIL_ATTR_REQ, class),
+ SEND_ATTR_STR(MAIL_ATTR_SENDER, sender),
+ SEND_ATTR_STR(MAIL_ATTR_ADDR, addr),
ATTR_TYPE_END) != 0
|| vstream_fflush(stream)
|| attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, &server_flags,
- ATTR_TYPE_STR, MAIL_ATTR_TRANSPORT, reply->transport,
- ATTR_TYPE_STR, MAIL_ATTR_NEXTHOP, reply->nexthop,
- ATTR_TYPE_STR, MAIL_ATTR_RECIP, reply->recipient,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, &reply->flags,
+ RECV_ATTR_INT(MAIL_ATTR_FLAGS, &server_flags),
+ RECV_ATTR_STR(MAIL_ATTR_TRANSPORT, reply->transport),
+ RECV_ATTR_STR(MAIL_ATTR_NEXTHOP, reply->nexthop),
+ RECV_ATTR_STR(MAIL_ATTR_RECIP, reply->recipient),
+ RECV_ATTR_INT(MAIL_ATTR_FLAGS, &reply->flags),
ATTR_TYPE_END) != 5) {
if (msg_verbose || count > 1 || (errno && errno != EPIPE && errno != ENOENT))
msg_warn("problem talking to service %s: %m",
errno = 0;
count += 1;
if (attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, REWRITE_ADDR,
- ATTR_TYPE_STR, MAIL_ATTR_RULE, rule,
- ATTR_TYPE_STR, MAIL_ATTR_ADDR, addr,
+ SEND_ATTR_STR(MAIL_ATTR_REQ, REWRITE_ADDR),
+ SEND_ATTR_STR(MAIL_ATTR_RULE, rule),
+ SEND_ATTR_STR(MAIL_ATTR_ADDR, addr),
ATTR_TYPE_END) != 0
|| vstream_fflush(stream)
|| attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, &server_flags,
- ATTR_TYPE_STR, MAIL_ATTR_ADDR, result,
+ RECV_ATTR_INT(MAIL_ATTR_FLAGS, &server_flags),
+ RECV_ATTR_STR(MAIL_ATTR_ADDR, result),
ATTR_TYPE_END) != 2) {
if (msg_verbose || count > 1 || (errno && errno != EPIPE && errno != ENOENT))
msg_warn("problem talking to service %s: %m",
errno = 0;
count += 1;
if (attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, SCACHE_REQ_SAVE_ENDP,
- ATTR_TYPE_INT, MAIL_ATTR_TTL, endp_ttl,
- ATTR_TYPE_STR, MAIL_ATTR_LABEL, endp_label,
- ATTR_TYPE_STR, MAIL_ATTR_PROP, endp_prop,
+ SEND_ATTR_STR(MAIL_ATTR_REQ, SCACHE_REQ_SAVE_ENDP),
+ SEND_ATTR_INT(MAIL_ATTR_TTL, endp_ttl),
+ SEND_ATTR_STR(MAIL_ATTR_LABEL, endp_label),
+ SEND_ATTR_STR(MAIL_ATTR_PROP, endp_prop),
ATTR_TYPE_END) != 0
|| vstream_fflush(stream)
#ifdef CANT_WRITE_BEFORE_SENDING_FD
|| attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_DUMMY, sp->dummy,
+ RECV_ATTR_STR(MAIL_ATTR_DUMMY, sp->dummy),
ATTR_TYPE_END) != 1
#endif
|| LOCAL_SEND_FD(vstream_fileno(stream), fd) < 0
|| attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &status,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &status),
ATTR_TYPE_END) != 1) {
if (msg_verbose || count > 1 || (errno && errno != EPIPE && errno != ENOENT))
msg_warn("problem talking to service %s: %m",
if ((stream = auto_clnt_access(sp->auto_clnt)) != 0) {
errno = 0;
if (attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, SCACHE_REQ_FIND_ENDP,
- ATTR_TYPE_STR, MAIL_ATTR_LABEL, endp_label,
+ SEND_ATTR_STR(MAIL_ATTR_REQ, SCACHE_REQ_FIND_ENDP),
+ SEND_ATTR_STR(MAIL_ATTR_LABEL, endp_label),
ATTR_TYPE_END) != 0
|| vstream_fflush(stream)
|| attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &status,
- ATTR_TYPE_STR, MAIL_ATTR_PROP, endp_prop,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &status),
+ RECV_ATTR_STR(MAIL_ATTR_PROP, endp_prop),
ATTR_TYPE_END) != 2) {
if (msg_verbose || (errno != EPIPE && errno != ENOENT))
msg_warn("problem talking to service %s: %m",
} else if (
#ifdef CANT_WRITE_BEFORE_SENDING_FD
attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_DUMMY, "",
+ SEND_ATTR_STR(MAIL_ATTR_DUMMY, ""),
ATTR_TYPE_END) != 0
|| vstream_fflush(stream) != 0
|| read_wait(vstream_fileno(stream),
} else {
#ifdef MUST_READ_AFTER_SENDING_FD
(void) attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_DUMMY, "",
+ SEND_ATTR_STR(MAIL_ATTR_DUMMY, ""),
ATTR_TYPE_END);
(void) vstream_fflush(stream);
#endif
if ((stream = auto_clnt_access(sp->auto_clnt)) != 0) {
errno = 0;
if (attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, SCACHE_REQ_SAVE_DEST,
- ATTR_TYPE_INT, MAIL_ATTR_TTL, dest_ttl,
- ATTR_TYPE_STR, MAIL_ATTR_LABEL, dest_label,
- ATTR_TYPE_STR, MAIL_ATTR_PROP, dest_prop,
- ATTR_TYPE_STR, MAIL_ATTR_LABEL, endp_label,
+ SEND_ATTR_STR(MAIL_ATTR_REQ, SCACHE_REQ_SAVE_DEST),
+ SEND_ATTR_INT(MAIL_ATTR_TTL, dest_ttl),
+ SEND_ATTR_STR(MAIL_ATTR_LABEL, dest_label),
+ SEND_ATTR_STR(MAIL_ATTR_PROP, dest_prop),
+ SEND_ATTR_STR(MAIL_ATTR_LABEL, endp_label),
ATTR_TYPE_END) != 0
|| vstream_fflush(stream)
|| attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &status,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &status),
ATTR_TYPE_END) != 1) {
if (msg_verbose || (errno != EPIPE && errno != ENOENT))
msg_warn("problem talking to service %s: %m",
if ((stream = auto_clnt_access(sp->auto_clnt)) != 0) {
errno = 0;
if (attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, SCACHE_REQ_FIND_DEST,
- ATTR_TYPE_STR, MAIL_ATTR_LABEL, dest_label,
+ SEND_ATTR_STR(MAIL_ATTR_REQ, SCACHE_REQ_FIND_DEST),
+ SEND_ATTR_STR(MAIL_ATTR_LABEL, dest_label),
ATTR_TYPE_END) != 0
|| vstream_fflush(stream)
|| attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &status,
- ATTR_TYPE_STR, MAIL_ATTR_PROP, dest_prop,
- ATTR_TYPE_STR, MAIL_ATTR_PROP, endp_prop,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &status),
+ RECV_ATTR_STR(MAIL_ATTR_PROP, dest_prop),
+ RECV_ATTR_STR(MAIL_ATTR_PROP, endp_prop),
ATTR_TYPE_END) != 3) {
if (msg_verbose || (errno != EPIPE && errno != ENOENT))
msg_warn("problem talking to service %s: %m",
} else if (
#ifdef CANT_WRITE_BEFORE_SENDING_FD
attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_DUMMY, "",
+ SEND_ATTR_STR(MAIL_ATTR_DUMMY, ""),
ATTR_TYPE_END) != 0
|| vstream_fflush(stream) != 0
|| read_wait(vstream_fileno(stream),
} else {
#ifdef MUST_READ_AFTER_SENDING_FD
(void) attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_DUMMY, "",
+ SEND_ATTR_STR(MAIL_ATTR_DUMMY, ""),
ATTR_TYPE_END);
(void) vstream_fflush(stream);
#endif
my_dsn.reason = vstring_str(why);
if (mail_command_client(MAIL_CLASS_PRIVATE, var_trace_service,
- ATTR_TYPE_INT, MAIL_ATTR_NREQ, BOUNCE_CMD_APPEND,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, flags,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, id,
- ATTR_TYPE_FUNC, rcpt_print, (void *) rcpt,
- ATTR_TYPE_FUNC, dsn_print, (void *) &my_dsn,
+ SEND_ATTR_INT(MAIL_ATTR_NREQ, BOUNCE_CMD_APPEND),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, flags),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUEID, id),
+ SEND_ATTR_FUNC(rcpt_print, (void *) rcpt),
+ SEND_ATTR_FUNC(dsn_print, (void *) &my_dsn),
ATTR_TYPE_END) != 0) {
msg_warn("%s: %s service failure", id, var_trace_service);
req_stat = -1;
const char *dsn_envid, int dsn_ret)
{
if (mail_command_client(MAIL_CLASS_PRIVATE, var_trace_service,
- ATTR_TYPE_INT, MAIL_ATTR_NREQ, BOUNCE_CMD_TRACE,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, flags,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUE, queue,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, id,
- ATTR_TYPE_STR, MAIL_ATTR_ENCODING, encoding,
- ATTR_TYPE_STR, MAIL_ATTR_SENDER, sender,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_ENVID, dsn_envid,
- ATTR_TYPE_INT, MAIL_ATTR_DSN_RET, dsn_ret,
+ SEND_ATTR_INT(MAIL_ATTR_NREQ, BOUNCE_CMD_TRACE),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, flags),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUE, queue),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUEID, id),
+ SEND_ATTR_STR(MAIL_ATTR_ENCODING, encoding),
+ SEND_ATTR_STR(MAIL_ATTR_SENDER, sender),
+ SEND_ATTR_STR(MAIL_ATTR_DSN_ENVID, dsn_envid),
+ SEND_ATTR_INT(MAIL_ATTR_DSN_RET, dsn_ret),
ATTR_TYPE_END) == 0) {
return (0);
} else {
errno = 0;
count += 1;
if (attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, VRFY_REQ_QUERY,
- ATTR_TYPE_STR, MAIL_ATTR_ADDR, addr,
+ SEND_ATTR_STR(MAIL_ATTR_REQ, VRFY_REQ_QUERY),
+ SEND_ATTR_STR(MAIL_ATTR_ADDR, addr),
ATTR_TYPE_END) != 0
|| vstream_fflush(stream)
|| attr_scan(stream, ATTR_FLAG_MISSING,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &request_status,
- ATTR_TYPE_INT, MAIL_ATTR_ADDR_STATUS, addr_status,
- ATTR_TYPE_STR, MAIL_ATTR_WHY, why,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &request_status),
+ RECV_ATTR_INT(MAIL_ATTR_ADDR_STATUS, addr_status),
+ RECV_ATTR_STR(MAIL_ATTR_WHY, why),
ATTR_TYPE_END) != 3) {
if (msg_verbose || count > 1 || (errno && errno != EPIPE && errno != ENOENT))
msg_warn("problem talking to service %s: %m",
stream = clnt_stream_access(vrfy_clnt);
errno = 0;
if (attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, VRFY_REQ_UPDATE,
- ATTR_TYPE_STR, MAIL_ATTR_ADDR, addr,
- ATTR_TYPE_INT, MAIL_ATTR_ADDR_STATUS, addr_status,
- ATTR_TYPE_STR, MAIL_ATTR_WHY, why,
+ SEND_ATTR_STR(MAIL_ATTR_REQ, VRFY_REQ_UPDATE),
+ SEND_ATTR_STR(MAIL_ATTR_ADDR, addr),
+ SEND_ATTR_INT(MAIL_ATTR_ADDR_STATUS, addr_status),
+ SEND_ATTR_STR(MAIL_ATTR_WHY, why),
ATTR_TYPE_END) != 0
|| attr_scan(stream, ATTR_FLAG_MISSING,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &request_status,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &request_status),
ATTR_TYPE_END) != 1) {
if (msg_verbose || (errno != EPIPE && errno != ENOENT))
msg_warn("problem talking to service %s: %m",
FORWARD_OPEN_RETURN(0);
close_on_exec(vstream_fileno(cleanup), CLOSE_ON_EXEC);
if (attr_scan(cleanup, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, buffer,
+ RECV_ATTR_STR(MAIL_ATTR_QUEUEID, buffer),
ATTR_TYPE_END) != 1) {
vstream_fclose(cleanup);
FORWARD_OPEN_RETURN(0);
CLEANUP_FLAG_SMTPUTF8 : 0))
attr_print(cleanup, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, FORWARD_CLEANUP_FLAGS,
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, FORWARD_CLEANUP_FLAGS),
ATTR_TYPE_END);
/*
if (status == 0)
if (vstream_fflush(info->cleanup)
|| attr_scan(info->cleanup, ATTR_FLAG_MISSING,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &status,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &status),
ATTR_TYPE_END) != 1)
status = 1;
* Send the filter macro name lists.
*/
(void) attr_print(stream, ATTR_FLAG_MORE,
- ATTR_TYPE_FUNC, milter_macros_print,
- (void *) milters->macros,
+ SEND_ATTR_FUNC(milter_macros_print,
+ (void *) milters->macros),
ATTR_TYPE_END);
/*
*/
if (status != 0
|| attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &status,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &status),
ATTR_TYPE_END) != 1
|| status != 0) {
msg_warn("cannot send milters to service %s", VSTREAM_PATH(stream));
*/
milters->macros = milter_macros_alloc(MILTER_MACROS_ALLOC_ZERO);
if (attr_scan(stream, ATTR_FLAG_STRICT | ATTR_FLAG_MORE,
- ATTR_TYPE_FUNC, milter_macros_scan,
- (void *) milters->macros,
+ RECV_ATTR_FUNC(milter_macros_scan,
+ (void *) milters->macros),
ATTR_TYPE_END) != 1) {
milter_free(milters);
return (0);
* Over to you.
*/
(void) attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, 0,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, 0),
ATTR_TYPE_END);
return (milters);
}
vstream_fflush(milter->fp);
if (attr_print(stream, ATTR_FLAG_MORE,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_NAME, milter->m.name,
- ATTR_TYPE_INT, MAIL_ATTR_MILT_VERS, milter->version,
- ATTR_TYPE_INT, MAIL_ATTR_MILT_ACTS, milter->rq_mask,
- ATTR_TYPE_INT, MAIL_ATTR_MILT_EVTS, milter->ev_mask,
- ATTR_TYPE_INT, MAIL_ATTR_MILT_NPTS, milter->np_mask,
- ATTR_TYPE_INT, MAIL_ATTR_MILT_STAT, milter->state,
- ATTR_TYPE_INT, MAIL_ATTR_MILT_CONN, milter->conn_timeout,
- ATTR_TYPE_INT, MAIL_ATTR_MILT_CMD, milter->cmd_timeout,
- ATTR_TYPE_INT, MAIL_ATTR_MILT_MSG, milter->msg_timeout,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_ACT, milter->def_action,
- ATTR_TYPE_INT, MAIL_ATTR_MILT_MAC, milter->m.macros != 0,
+ SEND_ATTR_STR(MAIL_ATTR_MILT_NAME, milter->m.name),
+ SEND_ATTR_INT(MAIL_ATTR_MILT_VERS, milter->version),
+ SEND_ATTR_INT(MAIL_ATTR_MILT_ACTS, milter->rq_mask),
+ SEND_ATTR_INT(MAIL_ATTR_MILT_EVTS, milter->ev_mask),
+ SEND_ATTR_INT(MAIL_ATTR_MILT_NPTS, milter->np_mask),
+ SEND_ATTR_INT(MAIL_ATTR_MILT_STAT, milter->state),
+ SEND_ATTR_INT(MAIL_ATTR_MILT_CONN, milter->conn_timeout),
+ SEND_ATTR_INT(MAIL_ATTR_MILT_CMD, milter->cmd_timeout),
+ SEND_ATTR_INT(MAIL_ATTR_MILT_MSG, milter->msg_timeout),
+ SEND_ATTR_STR(MAIL_ATTR_MILT_ACT, milter->def_action),
+ SEND_ATTR_INT(MAIL_ATTR_MILT_MAC, milter->m.macros != 0),
ATTR_TYPE_END) != 0
|| (milter->m.macros != 0
&& attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_FUNC, milter_macros_print,
- (void *) milter->m.macros,
+ SEND_ATTR_FUNC(milter_macros_print,
+ (void *) milter->m.macros),
ATTR_TYPE_END) != 0)
|| (milter->m.macros == 0
&& attr_print(stream, ATTR_FLAG_NONE,
return (-1);
#ifdef CANT_WRITE_BEFORE_SENDING_FD
} else if (attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_DUMMY, milter->buf,
+ RECV_ATTR_STR(MAIL_ATTR_DUMMY, milter->buf),
ATTR_TYPE_END) != 1) {
return (-1);
#endif
return (-1);
#ifdef MUST_READ_AFTER_SENDING_FD
} else if (attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_DUMMY, milter->buf,
+ RECV_ATTR_STR(MAIL_ATTR_DUMMY, milter->buf),
ATTR_TYPE_END) != 1) {
return (-1);
#endif
act_buf = vstring_alloc(10);
}
if (attr_scan(stream, ATTR_FLAG_STRICT | ATTR_FLAG_MORE,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_NAME, name_buf,
- ATTR_TYPE_INT, MAIL_ATTR_MILT_VERS, &version,
- ATTR_TYPE_INT, MAIL_ATTR_MILT_ACTS, &rq_mask,
- ATTR_TYPE_INT, MAIL_ATTR_MILT_EVTS, &ev_mask,
- ATTR_TYPE_INT, MAIL_ATTR_MILT_NPTS, &np_mask,
- ATTR_TYPE_INT, MAIL_ATTR_MILT_STAT, &state,
- ATTR_TYPE_INT, MAIL_ATTR_MILT_CONN, &conn_timeout,
- ATTR_TYPE_INT, MAIL_ATTR_MILT_CMD, &cmd_timeout,
- ATTR_TYPE_INT, MAIL_ATTR_MILT_MSG, &msg_timeout,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_ACT, act_buf,
- ATTR_TYPE_INT, MAIL_ATTR_MILT_MAC, &has_macros,
+ RECV_ATTR_STR(MAIL_ATTR_MILT_NAME, name_buf),
+ RECV_ATTR_INT(MAIL_ATTR_MILT_VERS, &version),
+ RECV_ATTR_INT(MAIL_ATTR_MILT_ACTS, &rq_mask),
+ RECV_ATTR_INT(MAIL_ATTR_MILT_EVTS, &ev_mask),
+ RECV_ATTR_INT(MAIL_ATTR_MILT_NPTS, &np_mask),
+ RECV_ATTR_INT(MAIL_ATTR_MILT_STAT, &state),
+ RECV_ATTR_INT(MAIL_ATTR_MILT_CONN, &conn_timeout),
+ RECV_ATTR_INT(MAIL_ATTR_MILT_CMD, &cmd_timeout),
+ RECV_ATTR_INT(MAIL_ATTR_MILT_MSG, &msg_timeout),
+ RECV_ATTR_STR(MAIL_ATTR_MILT_ACT, act_buf),
+ RECV_ATTR_INT(MAIL_ATTR_MILT_MAC, &has_macros),
ATTR_TYPE_END) < 10
|| (has_macros != 0
&& attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_FUNC, milter_macros_scan,
- (void *) (macros =
- milter_macros_alloc(MILTER_MACROS_ALLOC_ZERO)),
+ RECV_ATTR_FUNC(milter_macros_scan,
+ (void *) (macros =
+ milter_macros_alloc(MILTER_MACROS_ALLOC_ZERO))),
ATTR_TYPE_END) < 1)
|| (has_macros == 0
&& attr_scan(stream, ATTR_FLAG_STRICT,
FREE_MACROS_AND_RETURN(0);
#ifdef CANT_WRITE_BEFORE_SENDING_FD
} else if (attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_DUMMY, "",
+ SEND_ATTR_STR(MAIL_ATTR_DUMMY, ""),
ATTR_TYPE_END) != 0
|| vstream_fflush(stream) != 0) {
FREE_MACROS_AND_RETURN(0);
} else {
#ifdef MUST_READ_AFTER_SENDING_FD
(void) attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_DUMMY, "",
+ SEND_ATTR_STR(MAIL_ATTR_DUMMY, ""),
ATTR_TYPE_END);
#endif
#define NO_PROTOCOL ((char *) 0)
/* print routine. milter_macros_print() is meant to be passed
/* as a call-back to attr_print*(), thusly:
/*
-/* ATTR_TYPE_FUNC, milter_macros_print, (void *) macros,
+/* SEND_ATTR_FUNC(milter_macros_print, (void *) macros),
/*
/* milter_macros_scan() reads a MILTER_MACROS structure from
/* the named stream using the specified attribute scan routine.
/* members. milter_macros_scan() is meant to be passed as a
/* call-back to attr_scan*(), thusly:
/*
-/* ATTR_TYPE_FUNC, milter_macros_scan, (void *) macros,
+/* RECV_ATTR_FUNC(milter_macros_scan, (void *) macros),
/* DIAGNOSTICS
/* Fatal: out of memory.
/* LICENSE
* as in the milter_macros_scan() function.
*/
ret = print_fn(fp, flags | ATTR_FLAG_MORE,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_MAC_CONN, mp->conn_macros,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_MAC_HELO, mp->helo_macros,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_MAC_MAIL, mp->mail_macros,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_MAC_RCPT, mp->rcpt_macros,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_MAC_DATA, mp->data_macros,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_MAC_EOH, mp->eoh_macros,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_MAC_EOD, mp->eod_macros,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_MAC_UNK, mp->unk_macros,
+ SEND_ATTR_STR(MAIL_ATTR_MILT_MAC_CONN, mp->conn_macros),
+ SEND_ATTR_STR(MAIL_ATTR_MILT_MAC_HELO, mp->helo_macros),
+ SEND_ATTR_STR(MAIL_ATTR_MILT_MAC_MAIL, mp->mail_macros),
+ SEND_ATTR_STR(MAIL_ATTR_MILT_MAC_RCPT, mp->rcpt_macros),
+ SEND_ATTR_STR(MAIL_ATTR_MILT_MAC_DATA, mp->data_macros),
+ SEND_ATTR_STR(MAIL_ATTR_MILT_MAC_EOH, mp->eoh_macros),
+ SEND_ATTR_STR(MAIL_ATTR_MILT_MAC_EOD, mp->eod_macros),
+ SEND_ATTR_STR(MAIL_ATTR_MILT_MAC_UNK, mp->unk_macros),
ATTR_TYPE_END);
return (ret);
}
* as in the milter_macros_print() function.
*/
ret = scan_fn(fp, flags | ATTR_FLAG_MORE,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_MAC_CONN, conn_macros,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_MAC_HELO, helo_macros,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_MAC_MAIL, mail_macros,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_MAC_RCPT, rcpt_macros,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_MAC_DATA, data_macros,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_MAC_EOH, eoh_macros,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_MAC_EOD, eod_macros,
- ATTR_TYPE_STR, MAIL_ATTR_MILT_MAC_UNK, unk_macros,
+ RECV_ATTR_STR(MAIL_ATTR_MILT_MAC_CONN, conn_macros),
+ RECV_ATTR_STR(MAIL_ATTR_MILT_MAC_HELO, helo_macros),
+ RECV_ATTR_STR(MAIL_ATTR_MILT_MAC_MAIL, mail_macros),
+ RECV_ATTR_STR(MAIL_ATTR_MILT_MAC_RCPT, rcpt_macros),
+ RECV_ATTR_STR(MAIL_ATTR_MILT_MAC_DATA, data_macros),
+ RECV_ATTR_STR(MAIL_ATTR_MILT_MAC_EOH, eoh_macros),
+ RECV_ATTR_STR(MAIL_ATTR_MILT_MAC_EOD, eod_macros),
+ RECV_ATTR_STR(MAIL_ATTR_MILT_MAC_UNK, unk_macros),
ATTR_TYPE_END);
/*
msg_warn("%s: premature disconnect", VSTREAM_PATH(stream));
return (DELIVER_STAT_CRASH);
} else if (attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &stat,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &stat),
ATTR_TYPE_END) != 1) {
msg_warn("%s: malformed response", VSTREAM_PATH(stream));
return (DELIVER_STAT_CRASH);
msg_warn("%s: premature disconnect", VSTREAM_PATH(stream));
return (DELIVER_STAT_CRASH);
} else if (attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_FUNC, dsb_scan, (void *) dsb,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &stat,
+ RECV_ATTR_FUNC(dsb_scan, (void *) dsb),
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &stat),
ATTR_TYPE_END) != 2) {
msg_warn("%s: malformed response", VSTREAM_PATH(stream));
return (DELIVER_STAT_CRASH);
| (message->inspect_xport ? DEL_REQ_FLAG_BOUNCE : DEL_REQ_FLAG_DEFLT);
(void) QMGR_MSG_STATS(&stats, message);
attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, flags,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUE, message->queue_name,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, message->queue_id,
- ATTR_TYPE_LONG, MAIL_ATTR_OFFSET, message->data_offset,
- ATTR_TYPE_LONG, MAIL_ATTR_SIZE, message->cont_length,
- ATTR_TYPE_STR, MAIL_ATTR_NEXTHOP, entry->queue->nexthop,
- ATTR_TYPE_STR, MAIL_ATTR_ENCODING, message->encoding,
- ATTR_TYPE_INT, MAIL_ATTR_SMTPUTF8, smtputf8,
- ATTR_TYPE_STR, MAIL_ATTR_SENDER, sender,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_ENVID, message->dsn_envid,
- ATTR_TYPE_INT, MAIL_ATTR_DSN_RET, message->dsn_ret,
- ATTR_TYPE_FUNC, msg_stats_print, (void *) &stats,
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, flags),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUE, message->queue_name),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUEID, message->queue_id),
+ SEND_ATTR_LONG(MAIL_ATTR_OFFSET, message->data_offset),
+ SEND_ATTR_LONG(MAIL_ATTR_SIZE, message->cont_length),
+ SEND_ATTR_STR(MAIL_ATTR_NEXTHOP, entry->queue->nexthop),
+ SEND_ATTR_STR(MAIL_ATTR_ENCODING, message->encoding),
+ SEND_ATTR_INT(MAIL_ATTR_SMTPUTF8, smtputf8),
+ SEND_ATTR_STR(MAIL_ATTR_SENDER, sender),
+ SEND_ATTR_STR(MAIL_ATTR_DSN_ENVID, message->dsn_envid),
+ SEND_ATTR_INT(MAIL_ATTR_DSN_RET, message->dsn_ret),
+ SEND_ATTR_FUNC(msg_stats_print, (void *) &stats),
/* XXX Should be encapsulated with ATTR_TYPE_FUNC. */
- ATTR_TYPE_STR, MAIL_ATTR_LOG_CLIENT_NAME, message->client_name,
- ATTR_TYPE_STR, MAIL_ATTR_LOG_CLIENT_ADDR, message->client_addr,
- ATTR_TYPE_STR, MAIL_ATTR_LOG_CLIENT_PORT, message->client_port,
- ATTR_TYPE_STR, MAIL_ATTR_LOG_PROTO_NAME, message->client_proto,
- ATTR_TYPE_STR, MAIL_ATTR_LOG_HELO_NAME, message->client_helo,
+ SEND_ATTR_STR(MAIL_ATTR_LOG_CLIENT_NAME, message->client_name),
+ SEND_ATTR_STR(MAIL_ATTR_LOG_CLIENT_ADDR, message->client_addr),
+ SEND_ATTR_STR(MAIL_ATTR_LOG_CLIENT_PORT, message->client_port),
+ SEND_ATTR_STR(MAIL_ATTR_LOG_PROTO_NAME, message->client_proto),
+ SEND_ATTR_STR(MAIL_ATTR_LOG_HELO_NAME, message->client_helo),
/* XXX Should be encapsulated with ATTR_TYPE_FUNC. */
- ATTR_TYPE_STR, MAIL_ATTR_SASL_METHOD, message->sasl_method,
- ATTR_TYPE_STR, MAIL_ATTR_SASL_USERNAME, message->sasl_username,
- ATTR_TYPE_STR, MAIL_ATTR_SASL_SENDER, message->sasl_sender,
+ SEND_ATTR_STR(MAIL_ATTR_SASL_METHOD, message->sasl_method),
+ SEND_ATTR_STR(MAIL_ATTR_SASL_USERNAME, message->sasl_username),
+ SEND_ATTR_STR(MAIL_ATTR_SASL_SENDER, message->sasl_sender),
/* XXX Ditto if we want to pass TLS certificate info. */
- ATTR_TYPE_STR, MAIL_ATTR_LOG_IDENT, message->log_ident,
- ATTR_TYPE_STR, MAIL_ATTR_RWR_CONTEXT, message->rewrite_context,
- ATTR_TYPE_INT, MAIL_ATTR_RCPT_COUNT, list.len,
+ SEND_ATTR_STR(MAIL_ATTR_LOG_IDENT, message->log_ident),
+ SEND_ATTR_STR(MAIL_ATTR_RWR_CONTEXT, message->rewrite_context),
+ SEND_ATTR_INT(MAIL_ATTR_RCPT_COUNT, list.len),
ATTR_TYPE_END);
if (sender_buf != 0)
vstring_free(sender_buf);
for (recipient = list.info; recipient < list.info + list.len; recipient++)
attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_FUNC, rcpt_print, (void *) recipient,
+ SEND_ATTR_FUNC(rcpt_print, (void *) recipient),
ATTR_TYPE_END);
if (vstream_fflush(stream) != 0) {
msg_warn("write to process (%s): %m", entry->queue->transport->name);
*/
rec_fputs(cleanup, REC_TYPE_END, "");
if (attr_scan(cleanup, ATTR_FLAG_MISSING,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &status,
- ATTR_TYPE_STR, MAIL_ATTR_WHY, buf,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &status),
+ RECV_ATTR_STR(MAIL_ATTR_WHY, buf),
ATTR_TYPE_END) != 2)
return (cleanup_service_error(info, CLEANUP_STAT_WRITE));
cleanup = mail_connect_wait(MAIL_CLASS_PUBLIC, var_cleanup_service);
if (attr_scan(cleanup, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, buf,
+ RECV_ATTR_STR(MAIL_ATTR_QUEUEID, buf),
ATTR_TYPE_END) != 1
|| attr_print(cleanup, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, cleanup_flags,
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, cleanup_flags),
ATTR_TYPE_END) != 0) {
status = KEEP_MESSAGE_FILE;
} else {
dst = mail_stream_file(MAIL_QUEUE_MAILDROP, MAIL_CLASS_PUBLIC,
var_pickup_service, 0444);
attr_print(VSTREAM_OUT, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, dst->id,
+ SEND_ATTR_STR(MAIL_ATTR_QUEUEID, dst->id),
ATTR_TYPE_END);
vstream_fflush(VSTREAM_OUT);
postdrop_path = mystrdup(VSTREAM_PATH(dst->stream));
* Send the completion status to the caller and terminate.
*/
attr_print(VSTREAM_OUT, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, status,
- ATTR_TYPE_STR, MAIL_ATTR_WHY, "",
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, status),
+ SEND_ATTR_STR(MAIL_ATTR_WHY, ""),
ATTR_TYPE_END);
vstream_fflush(VSTREAM_OUT);
exit(status);
if (event == EVENT_READ
&& attr_scan(stream,
ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_RBL_DOMAIN, reply_dnsbl,
- ATTR_TYPE_STR, MAIL_ATTR_ACT_CLIENT_ADDR, reply_client,
- ATTR_TYPE_INT, MAIL_ATTR_LABEL, &request_id,
- ATTR_TYPE_STR, MAIL_ATTR_RBL_ADDR, reply_addr,
+ RECV_ATTR_STR(MAIL_ATTR_RBL_DOMAIN, reply_dnsbl),
+ RECV_ATTR_STR(MAIL_ATTR_ACT_CLIENT_ADDR, reply_client),
+ RECV_ATTR_INT(MAIL_ATTR_LABEL, &request_id),
+ RECV_ATTR_STR(MAIL_ATTR_RBL_ADDR, reply_addr),
ATTR_TYPE_END) == 4
&& (score = (PSC_DNSBL_SCORE *)
htable_find(dnsbl_score_cache, STR(reply_client))) != 0
VSTREAM_CTL_CONTEXT, ht[0]->key,
VSTREAM_CTL_END);
attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_RBL_DOMAIN, ht[0]->key,
- ATTR_TYPE_STR, MAIL_ATTR_ACT_CLIENT_ADDR, client_addr,
- ATTR_TYPE_INT, MAIL_ATTR_LABEL, score->request_id,
+ SEND_ATTR_STR(MAIL_ATTR_RBL_DOMAIN, ht[0]->key),
+ SEND_ATTR_STR(MAIL_ATTR_ACT_CLIENT_ADDR, client_addr),
+ SEND_ATTR_INT(MAIL_ATTR_LABEL, score->request_id),
ATTR_TYPE_END);
if (vstream_fflush(stream) != 0) {
msg_warn("%s: error sending to %s service: %m",
(LOCAL_SEND_FD(server_fd,
vstream_fileno(state->smtp_client_stream)) < 0
|| (attr_print(fp, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_ACT_CLIENT_ADDR, state->smtp_client_addr,
- ATTR_TYPE_STR, MAIL_ATTR_ACT_CLIENT_PORT, state->smtp_client_port,
- ATTR_TYPE_STR, MAIL_ATTR_ACT_SERVER_ADDR, state->smtp_server_addr,
- ATTR_TYPE_STR, MAIL_ATTR_ACT_SERVER_PORT, state->smtp_server_port,
+ SEND_ATTR_STR(MAIL_ATTR_ACT_CLIENT_ADDR, state->smtp_client_addr),
+ SEND_ATTR_STR(MAIL_ATTR_ACT_CLIENT_PORT, state->smtp_client_port),
+ SEND_ATTR_STR(MAIL_ATTR_ACT_SERVER_ADDR, state->smtp_server_addr),
+ SEND_ATTR_STR(MAIL_ATTR_ACT_SERVER_PORT, state->smtp_server_port),
ATTR_TYPE_END) || vstream_fflush(fp)));
+ /* XXX Note: no read between attr_print() and vstream_fdclose(). */
(void) vstream_fdclose(fp);
if (pass_err != 0) {
msg_warn("cannot pass connection to service %s: %m",
*/
if (event != EVENT_READ
|| attr_scan(tlsproxy_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &status,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &status),
ATTR_TYPE_END) != 1 || status == 0) {
/*
vstring_sprintf(remote_endpt, "[%s]:%s", smtp_state->smtp_client_addr,
smtp_state->smtp_client_port);
attr_print(tlsproxy_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_REMOTE_ENDPT, STR(remote_endpt),
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, TLS_PROXY_FLAG_ROLE_SERVER,
- ATTR_TYPE_INT, MAIL_ATTR_TIMEOUT, psc_normal_cmd_time_limit,
- ATTR_TYPE_STR, MAIL_ATTR_SERVER_ID, MAIL_SERVICE_SMTPD, /* XXX */
+ SEND_ATTR_STR(MAIL_ATTR_REMOTE_ENDPT, STR(remote_endpt)),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, TLS_PROXY_FLAG_ROLE_SERVER),
+ SEND_ATTR_INT(MAIL_ATTR_TIMEOUT, psc_normal_cmd_time_limit),
+ SEND_ATTR_STR(MAIL_ATTR_SERVER_ID, MAIL_SERVICE_SMTPD), /* XXX */
ATTR_TYPE_END);
if (vstream_fflush(tlsproxy_stream) != 0) {
msg_warn("error sending request to %s service: %m", psc_tlsp_service);
* Process the request.
*/
if (attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_TABLE, request_map,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, &request_flags,
- ATTR_TYPE_INT, MAIL_ATTR_FUNC, &request_func,
+ RECV_ATTR_STR(MAIL_ATTR_TABLE, request_map),
+ RECV_ATTR_INT(MAIL_ATTR_FLAGS, &request_flags),
+ RECV_ATTR_INT(MAIL_ATTR_FUNC, &request_func),
ATTR_TYPE_END) != 3
|| (request_func != DICT_SEQ_FUN_FIRST
&& request_func != DICT_SEQ_FUN_NEXT)) {
* Respond to the client.
*/
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, reply_status,
- ATTR_TYPE_STR, MAIL_ATTR_KEY, reply_key,
- ATTR_TYPE_STR, MAIL_ATTR_VALUE, reply_value,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, reply_status),
+ SEND_ATTR_STR(MAIL_ATTR_KEY, reply_key),
+ SEND_ATTR_STR(MAIL_ATTR_VALUE, reply_value),
ATTR_TYPE_END);
}
* Process the request.
*/
if (attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_TABLE, request_map,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, &request_flags,
- ATTR_TYPE_STR, MAIL_ATTR_KEY, request_key,
+ RECV_ATTR_STR(MAIL_ATTR_TABLE, request_map),
+ RECV_ATTR_INT(MAIL_ATTR_FLAGS, &request_flags),
+ RECV_ATTR_STR(MAIL_ATTR_KEY, request_key),
ATTR_TYPE_END) != 3) {
reply_status = PROXY_STAT_BAD;
reply_value = "";
* Respond to the client.
*/
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, reply_status,
- ATTR_TYPE_STR, MAIL_ATTR_VALUE, reply_value,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, reply_status),
+ SEND_ATTR_STR(MAIL_ATTR_VALUE, reply_value),
ATTR_TYPE_END);
}
* otherwise.
*/
if (attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_TABLE, request_map,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, &request_flags,
- ATTR_TYPE_STR, MAIL_ATTR_KEY, request_key,
- ATTR_TYPE_STR, MAIL_ATTR_VALUE, request_value,
+ RECV_ATTR_STR(MAIL_ATTR_TABLE, request_map),
+ RECV_ATTR_INT(MAIL_ATTR_FLAGS, &request_flags),
+ RECV_ATTR_STR(MAIL_ATTR_KEY, request_key),
+ RECV_ATTR_STR(MAIL_ATTR_VALUE, request_value),
ATTR_TYPE_END) != 4) {
reply_status = PROXY_STAT_BAD;
} else if (proxy_writer == 0) {
* Respond to the client.
*/
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, reply_status,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, reply_status),
ATTR_TYPE_END);
}
* that the on-disk data is in a consistent state between updates.
*/
if (attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_TABLE, request_map,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, &request_flags,
- ATTR_TYPE_STR, MAIL_ATTR_KEY, request_key,
+ RECV_ATTR_STR(MAIL_ATTR_TABLE, request_map),
+ RECV_ATTR_INT(MAIL_ATTR_FLAGS, &request_flags),
+ RECV_ATTR_STR(MAIL_ATTR_KEY, request_key),
ATTR_TYPE_END) != 3) {
reply_status = PROXY_STAT_BAD;
} else if (proxy_writer == 0) {
* Respond to the client.
*/
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, reply_status,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, reply_status),
ATTR_TYPE_END);
}
* Process the request.
*/
if (attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_TABLE, request_map,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, &request_flags,
+ RECV_ATTR_STR(MAIL_ATTR_TABLE, request_map),
+ RECV_ATTR_INT(MAIL_ATTR_FLAGS, &request_flags),
ATTR_TYPE_END) != 2) {
reply_status = PROXY_STAT_BAD;
reply_flags = 0;
* Respond to the client.
*/
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, reply_status,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, reply_flags,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, reply_status),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, reply_flags),
ATTR_TYPE_END);
}
VSTREAM_CTL_END);
if (attr_scan(client_stream,
ATTR_FLAG_MORE | ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, request,
+ RECV_ATTR_STR(MAIL_ATTR_REQ, request),
ATTR_TYPE_END) == 1) {
if (VSTREQ(request, PROXY_REQ_LOOKUP)) {
proxymap_lookup_service(client_stream);
} else {
msg_warn("unrecognized request: \"%s\", ignored", STR(request));
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, PROXY_STAT_BAD,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, PROXY_STAT_BAD),
ATTR_TYPE_END);
}
}
msg_warn("%s: premature disconnect", VSTREAM_PATH(stream));
return (DELIVER_STAT_CRASH);
} else if (attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &stat,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &stat),
ATTR_TYPE_END) != 1) {
msg_warn("%s: malformed response", VSTREAM_PATH(stream));
return (DELIVER_STAT_CRASH);
msg_warn("%s: premature disconnect", VSTREAM_PATH(stream));
return (DELIVER_STAT_CRASH);
} else if (attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_FUNC, dsb_scan, (void *) dsb,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &stat,
+ RECV_ATTR_FUNC(dsb_scan, (void *) dsb),
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &stat),
ATTR_TYPE_END) != 2) {
msg_warn("%s: malformed response", VSTREAM_PATH(stream));
return (DELIVER_STAT_CRASH);
| (message->inspect_xport ? DEL_REQ_FLAG_BOUNCE : DEL_REQ_FLAG_DEFLT);
(void) QMGR_MSG_STATS(&stats, message);
attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, flags,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUE, message->queue_name,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, message->queue_id,
- ATTR_TYPE_LONG, MAIL_ATTR_OFFSET, message->data_offset,
- ATTR_TYPE_LONG, MAIL_ATTR_SIZE, message->cont_length,
- ATTR_TYPE_STR, MAIL_ATTR_NEXTHOP, entry->queue->nexthop,
- ATTR_TYPE_STR, MAIL_ATTR_ENCODING, message->encoding,
- ATTR_TYPE_INT, MAIL_ATTR_SMTPUTF8, smtputf8,
- ATTR_TYPE_STR, MAIL_ATTR_SENDER, sender,
- ATTR_TYPE_STR, MAIL_ATTR_DSN_ENVID, message->dsn_envid,
- ATTR_TYPE_INT, MAIL_ATTR_DSN_RET, message->dsn_ret,
- ATTR_TYPE_FUNC, msg_stats_print, (void *) &stats,
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, flags),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUE, message->queue_name),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUEID, message->queue_id),
+ SEND_ATTR_LONG(MAIL_ATTR_OFFSET, message->data_offset),
+ SEND_ATTR_LONG(MAIL_ATTR_SIZE, message->cont_length),
+ SEND_ATTR_STR(MAIL_ATTR_NEXTHOP, entry->queue->nexthop),
+ SEND_ATTR_STR(MAIL_ATTR_ENCODING, message->encoding),
+ SEND_ATTR_INT(MAIL_ATTR_SMTPUTF8, smtputf8),
+ SEND_ATTR_STR(MAIL_ATTR_SENDER, sender),
+ SEND_ATTR_STR(MAIL_ATTR_DSN_ENVID, message->dsn_envid),
+ SEND_ATTR_INT(MAIL_ATTR_DSN_RET, message->dsn_ret),
+ SEND_ATTR_FUNC(msg_stats_print, (void *) &stats),
/* XXX Should be encapsulated with ATTR_TYPE_FUNC. */
- ATTR_TYPE_STR, MAIL_ATTR_LOG_CLIENT_NAME, message->client_name,
- ATTR_TYPE_STR, MAIL_ATTR_LOG_CLIENT_ADDR, message->client_addr,
- ATTR_TYPE_STR, MAIL_ATTR_LOG_CLIENT_PORT, message->client_port,
- ATTR_TYPE_STR, MAIL_ATTR_LOG_PROTO_NAME, message->client_proto,
- ATTR_TYPE_STR, MAIL_ATTR_LOG_HELO_NAME, message->client_helo,
+ SEND_ATTR_STR(MAIL_ATTR_LOG_CLIENT_NAME, message->client_name),
+ SEND_ATTR_STR(MAIL_ATTR_LOG_CLIENT_ADDR, message->client_addr),
+ SEND_ATTR_STR(MAIL_ATTR_LOG_CLIENT_PORT, message->client_port),
+ SEND_ATTR_STR(MAIL_ATTR_LOG_PROTO_NAME, message->client_proto),
+ SEND_ATTR_STR(MAIL_ATTR_LOG_HELO_NAME, message->client_helo),
/* XXX Should be encapsulated with ATTR_TYPE_FUNC. */
- ATTR_TYPE_STR, MAIL_ATTR_SASL_METHOD, message->sasl_method,
- ATTR_TYPE_STR, MAIL_ATTR_SASL_USERNAME, message->sasl_username,
- ATTR_TYPE_STR, MAIL_ATTR_SASL_SENDER, message->sasl_sender,
+ SEND_ATTR_STR(MAIL_ATTR_SASL_METHOD, message->sasl_method),
+ SEND_ATTR_STR(MAIL_ATTR_SASL_USERNAME, message->sasl_username),
+ SEND_ATTR_STR(MAIL_ATTR_SASL_SENDER, message->sasl_sender),
/* XXX Ditto if we want to pass TLS certificate info. */
- ATTR_TYPE_STR, MAIL_ATTR_LOG_IDENT, message->log_ident,
- ATTR_TYPE_STR, MAIL_ATTR_RWR_CONTEXT, message->rewrite_context,
- ATTR_TYPE_INT, MAIL_ATTR_RCPT_COUNT, list.len,
+ SEND_ATTR_STR(MAIL_ATTR_LOG_IDENT, message->log_ident),
+ SEND_ATTR_STR(MAIL_ATTR_RWR_CONTEXT, message->rewrite_context),
+ SEND_ATTR_INT(MAIL_ATTR_RCPT_COUNT, list.len),
ATTR_TYPE_END);
if (sender_buf != 0)
vstring_free(sender_buf);
for (recipient = list.info; recipient < list.info + list.len; recipient++)
attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_FUNC, rcpt_print, (void *) recipient,
+ SEND_ATTR_FUNC(rcpt_print, (void *) recipient),
ATTR_TYPE_END);
if (vstream_fflush(stream) != 0) {
msg_warn("write to process (%s): %m", entry->queue->transport->name);
state->dest = mail_stream_service(MAIL_CLASS_PUBLIC, var_cleanup_service);
if (state->dest == 0
|| attr_print(state->dest->stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, cleanup_flags,
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, cleanup_flags),
ATTR_TYPE_END) != 0)
msg_fatal("unable to connect to the %s %s service",
MAIL_CLASS_PUBLIC, var_cleanup_service);
if (attr_scan(client_stream,
ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_TTL, &ttl,
- ATTR_TYPE_STR, MAIL_ATTR_LABEL, scache_endp_label,
- ATTR_TYPE_STR, MAIL_ATTR_PROP, scache_endp_prop,
+ RECV_ATTR_INT(MAIL_ATTR_TTL, &ttl),
+ RECV_ATTR_STR(MAIL_ATTR_LABEL, scache_endp_label),
+ RECV_ATTR_STR(MAIL_ATTR_PROP, scache_endp_prop),
ATTR_TYPE_END) != 3
|| ttl <= 0) {
msg_warn("%s: bad or missing request parameter", myname);
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, SCACHE_STAT_BAD,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, SCACHE_STAT_BAD),
ATTR_TYPE_END);
return;
} else if (
#ifdef CANT_WRITE_BEFORE_SENDING_FD
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_DUMMY, "",
+ SEND_ATTR_STR(MAIL_ATTR_DUMMY, ""),
ATTR_TYPE_END) != 0
|| vstream_fflush(client_stream) != 0
|| read_wait(vstream_fileno(client_stream),
(fd = LOCAL_RECV_FD(vstream_fileno(client_stream))) < 0) {
msg_warn("%s: unable to receive file descriptor: %m", myname);
(void) attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, SCACHE_STAT_FAIL,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, SCACHE_STAT_FAIL),
ATTR_TYPE_END);
return;
} else {
ttl > var_scache_ttl_lim ? var_scache_ttl_lim : ttl,
STR(scache_endp_label), STR(scache_endp_prop), fd);
(void) attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, SCACHE_STAT_OK,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, SCACHE_STAT_OK),
ATTR_TYPE_END);
scache_size(scache, &size);
if (size.endp_count > scache_endp_count)
if (attr_scan(client_stream,
ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_LABEL, scache_endp_label,
+ RECV_ATTR_STR(MAIL_ATTR_LABEL, scache_endp_label),
ATTR_TYPE_END) != 1) {
msg_warn("%s: bad or missing request parameter", myname);
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, SCACHE_STAT_BAD,
- ATTR_TYPE_STR, MAIL_ATTR_PROP, "",
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, SCACHE_STAT_BAD),
+ SEND_ATTR_STR(MAIL_ATTR_PROP, ""),
ATTR_TYPE_END);
return;
} else if ((fd = scache_find_endp(scache, STR(scache_endp_label),
scache_endp_prop)) < 0) {
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, SCACHE_STAT_FAIL,
- ATTR_TYPE_STR, MAIL_ATTR_PROP, "",
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, SCACHE_STAT_FAIL),
+ SEND_ATTR_STR(MAIL_ATTR_PROP, ""),
ATTR_TYPE_END);
scache_endp_miss++;
return;
} else {
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, SCACHE_STAT_OK,
- ATTR_TYPE_STR, MAIL_ATTR_PROP, STR(scache_endp_prop),
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, SCACHE_STAT_OK),
+ SEND_ATTR_STR(MAIL_ATTR_PROP, STR(scache_endp_prop)),
ATTR_TYPE_END);
if (vstream_fflush(client_stream) != 0
#ifdef CANT_WRITE_BEFORE_SENDING_FD
|| attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_DUMMY, scache_dummy,
+ RECV_ATTR_STR(MAIL_ATTR_DUMMY, scache_dummy),
ATTR_TYPE_END) != 1
#endif
|| LOCAL_SEND_FD(vstream_fileno(client_stream), fd) < 0
#ifdef MUST_READ_AFTER_SENDING_FD
|| attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_DUMMY, scache_dummy,
+ RECV_ATTR_STR(MAIL_ATTR_DUMMY, scache_dummy),
ATTR_TYPE_END) != 1
#endif
)
if (attr_scan(client_stream,
ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_TTL, &ttl,
- ATTR_TYPE_STR, MAIL_ATTR_LABEL, scache_dest_label,
- ATTR_TYPE_STR, MAIL_ATTR_PROP, scache_dest_prop,
- ATTR_TYPE_STR, MAIL_ATTR_LABEL, scache_endp_label,
+ RECV_ATTR_INT(MAIL_ATTR_TTL, &ttl),
+ RECV_ATTR_STR(MAIL_ATTR_LABEL, scache_dest_label),
+ RECV_ATTR_STR(MAIL_ATTR_PROP, scache_dest_prop),
+ RECV_ATTR_STR(MAIL_ATTR_LABEL, scache_endp_label),
ATTR_TYPE_END) != 4
|| ttl <= 0) {
msg_warn("%s: bad or missing request parameter", myname);
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, SCACHE_STAT_BAD,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, SCACHE_STAT_BAD),
ATTR_TYPE_END);
return;
} else {
STR(scache_dest_label), STR(scache_dest_prop),
STR(scache_endp_label));
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, SCACHE_STAT_OK,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, SCACHE_STAT_OK),
ATTR_TYPE_END);
scache_size(scache, &size);
if (size.dest_count > scache_dest_count)
if (attr_scan(client_stream,
ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_LABEL, scache_dest_label,
+ RECV_ATTR_STR(MAIL_ATTR_LABEL, scache_dest_label),
ATTR_TYPE_END) != 1) {
msg_warn("%s: bad or missing request parameter", myname);
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, SCACHE_STAT_BAD,
- ATTR_TYPE_STR, MAIL_ATTR_PROP, "",
- ATTR_TYPE_STR, MAIL_ATTR_PROP, "",
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, SCACHE_STAT_BAD),
+ SEND_ATTR_STR(MAIL_ATTR_PROP, ""),
+ SEND_ATTR_STR(MAIL_ATTR_PROP, ""),
ATTR_TYPE_END);
return;
} else if ((fd = scache_find_dest(scache, STR(scache_dest_label),
scache_dest_prop,
scache_endp_prop)) < 0) {
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, SCACHE_STAT_FAIL,
- ATTR_TYPE_STR, MAIL_ATTR_PROP, "",
- ATTR_TYPE_STR, MAIL_ATTR_PROP, "",
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, SCACHE_STAT_FAIL),
+ SEND_ATTR_STR(MAIL_ATTR_PROP, ""),
+ SEND_ATTR_STR(MAIL_ATTR_PROP, ""),
ATTR_TYPE_END);
scache_dest_miss++;
return;
} else {
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, SCACHE_STAT_OK,
- ATTR_TYPE_STR, MAIL_ATTR_PROP, STR(scache_dest_prop),
- ATTR_TYPE_STR, MAIL_ATTR_PROP, STR(scache_endp_prop),
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, SCACHE_STAT_OK),
+ SEND_ATTR_STR(MAIL_ATTR_PROP, STR(scache_dest_prop)),
+ SEND_ATTR_STR(MAIL_ATTR_PROP, STR(scache_endp_prop)),
ATTR_TYPE_END);
if (vstream_fflush(client_stream) != 0
#ifdef CANT_WRITE_BEFORE_SENDING_FD
|| attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_DUMMY, scache_dummy,
+ RECV_ATTR_STR(MAIL_ATTR_DUMMY, scache_dummy),
ATTR_TYPE_END) != 1
#endif
|| LOCAL_SEND_FD(vstream_fileno(client_stream), fd) < 0
#ifdef MUST_READ_AFTER_SENDING_FD
|| attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_DUMMY, scache_dummy,
+ RECV_ATTR_STR(MAIL_ATTR_DUMMY, scache_dummy),
ATTR_TYPE_END) != 1
#endif
)
do {
if (attr_scan(client_stream,
ATTR_FLAG_MORE | ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, scache_request,
+ RECV_ATTR_STR(MAIL_ATTR_REQ, scache_request),
ATTR_TYPE_END) == 1) {
if (VSTREQ(scache_request, SCACHE_REQ_SAVE_DEST)) {
scache_save_dest_service(client_stream);
msg_warn("unrecognized request: \"%s\", ignored",
STR(scache_request));
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, SCACHE_STAT_BAD,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, SCACHE_STAT_BAD),
ATTR_TYPE_END);
}
}
var_cleanup_service);
if (state->dest == 0
|| attr_print(state->dest->stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, cleanup_flags,
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, cleanup_flags),
ATTR_TYPE_END) != 0)
msg_fatal("unable to connect to the %s %s service",
MAIL_CLASS_PUBLIC, var_cleanup_service);
if (attr_clnt_request(policy_clnt->client,
ATTR_FLAG_NONE, /* Query attributes. */
- ATTR_TYPE_STR, MAIL_ATTR_REQ, "smtpd_access_policy",
- ATTR_TYPE_STR, MAIL_ATTR_PROTO_STATE, state->where,
- ATTR_TYPE_STR, MAIL_ATTR_ACT_PROTO_NAME, state->protocol,
- ATTR_TYPE_STR, MAIL_ATTR_ACT_CLIENT_ADDR, state->addr,
- ATTR_TYPE_STR, MAIL_ATTR_ACT_CLIENT_NAME, state->name,
- ATTR_TYPE_STR, MAIL_ATTR_ACT_CLIENT_PORT, state->port,
- ATTR_TYPE_STR, MAIL_ATTR_ACT_REVERSE_CLIENT_NAME,
- state->reverse_name,
- ATTR_TYPE_STR, MAIL_ATTR_ACT_HELO_NAME,
- state->helo_name ? state->helo_name : "",
- ATTR_TYPE_STR, MAIL_ATTR_SENDER,
- state->sender ? state->sender : "",
- ATTR_TYPE_STR, MAIL_ATTR_RECIP,
- state->recipient ? state->recipient : "",
- ATTR_TYPE_INT, MAIL_ATTR_RCPT_COUNT,
- ((strcasecmp(state->where, SMTPD_CMD_DATA) == 0) ||
- (strcasecmp(state->where, SMTPD_AFTER_DOT) == 0)) ?
- state->rcpt_count : 0,
- ATTR_TYPE_STR, MAIL_ATTR_QUEUEID,
- state->queue_id ? state->queue_id : "",
- ATTR_TYPE_STR, MAIL_ATTR_INSTANCE,
- STR(state->instance),
- ATTR_TYPE_LONG, MAIL_ATTR_SIZE,
- (unsigned long) (state->act_size > 0 ?
- state->act_size : state->msg_size),
- ATTR_TYPE_STR, MAIL_ATTR_ETRN_DOMAIN,
- state->etrn_name ? state->etrn_name : "",
- ATTR_TYPE_STR, MAIL_ATTR_STRESS, var_stress,
+ SEND_ATTR_STR(MAIL_ATTR_REQ, "smtpd_access_policy"),
+ SEND_ATTR_STR(MAIL_ATTR_PROTO_STATE, state->where),
+ SEND_ATTR_STR(MAIL_ATTR_ACT_PROTO_NAME, state->protocol),
+ SEND_ATTR_STR(MAIL_ATTR_ACT_CLIENT_ADDR, state->addr),
+ SEND_ATTR_STR(MAIL_ATTR_ACT_CLIENT_NAME, state->name),
+ SEND_ATTR_STR(MAIL_ATTR_ACT_CLIENT_PORT, state->port),
+ SEND_ATTR_STR(MAIL_ATTR_ACT_REVERSE_CLIENT_NAME,
+ state->reverse_name),
+ SEND_ATTR_STR(MAIL_ATTR_ACT_HELO_NAME,
+ state->helo_name ? state->helo_name : ""),
+ SEND_ATTR_STR(MAIL_ATTR_SENDER,
+ state->sender ? state->sender : ""),
+ SEND_ATTR_STR(MAIL_ATTR_RECIP,
+ state->recipient ? state->recipient : ""),
+ SEND_ATTR_INT(MAIL_ATTR_RCPT_COUNT,
+ ((strcasecmp(state->where, SMTPD_CMD_DATA) == 0) ||
+ (strcasecmp(state->where, SMTPD_AFTER_DOT) == 0)) ?
+ state->rcpt_count : 0),
+ SEND_ATTR_STR(MAIL_ATTR_QUEUEID,
+ state->queue_id ? state->queue_id : ""),
+ SEND_ATTR_STR(MAIL_ATTR_INSTANCE,
+ STR(state->instance)),
+ SEND_ATTR_LONG(MAIL_ATTR_SIZE,
+ (unsigned long) (state->act_size > 0 ?
+ state->act_size : state->msg_size)),
+ SEND_ATTR_STR(MAIL_ATTR_ETRN_DOMAIN,
+ state->etrn_name ? state->etrn_name : ""),
+ SEND_ATTR_STR(MAIL_ATTR_STRESS, var_stress),
#ifdef USE_SASL_AUTH
- ATTR_TYPE_STR, MAIL_ATTR_SASL_METHOD,
- state->sasl_method ? state->sasl_method : "",
- ATTR_TYPE_STR, MAIL_ATTR_SASL_USERNAME,
- state->sasl_username ? state->sasl_username : "",
- ATTR_TYPE_STR, MAIL_ATTR_SASL_SENDER,
- state->sasl_sender ? state->sasl_sender : "",
+ SEND_ATTR_STR(MAIL_ATTR_SASL_METHOD,
+ state->sasl_method ? state->sasl_method : ""),
+ SEND_ATTR_STR(MAIL_ATTR_SASL_USERNAME,
+ state->sasl_username ? state->sasl_username : ""),
+ SEND_ATTR_STR(MAIL_ATTR_SASL_SENDER,
+ state->sasl_sender ? state->sasl_sender : ""),
#endif
#ifdef USE_TLS
#define IF_ENCRYPTED(x, y) ((state->tls_context && ((x) != 0)) ? (x) : (y))
- ATTR_TYPE_STR, MAIL_ATTR_CCERT_SUBJECT, subject,
- ATTR_TYPE_STR, MAIL_ATTR_CCERT_ISSUER, issuer,
+ SEND_ATTR_STR(MAIL_ATTR_CCERT_SUBJECT, subject),
+ SEND_ATTR_STR(MAIL_ATTR_CCERT_ISSUER, issuer),
/*
* When directly checking the fingerprint, it is OK if the issuing CA is
* not trusted.
*/
- ATTR_TYPE_STR, MAIL_ATTR_CCERT_CERT_FPRINT,
- IF_ENCRYPTED(state->tls_context->peer_cert_fprint, ""),
- ATTR_TYPE_STR, MAIL_ATTR_CCERT_PKEY_FPRINT,
- IF_ENCRYPTED(state->tls_context->peer_pkey_fprint, ""),
- ATTR_TYPE_STR, MAIL_ATTR_CRYPTO_PROTOCOL,
- IF_ENCRYPTED(state->tls_context->protocol, ""),
- ATTR_TYPE_STR, MAIL_ATTR_CRYPTO_CIPHER,
- IF_ENCRYPTED(state->tls_context->cipher_name, ""),
- ATTR_TYPE_INT, MAIL_ATTR_CRYPTO_KEYSIZE,
- IF_ENCRYPTED(state->tls_context->cipher_usebits, 0),
+ SEND_ATTR_STR(MAIL_ATTR_CCERT_CERT_FPRINT,
+ IF_ENCRYPTED(state->tls_context->peer_cert_fprint, "")),
+ SEND_ATTR_STR(MAIL_ATTR_CCERT_PKEY_FPRINT,
+ IF_ENCRYPTED(state->tls_context->peer_pkey_fprint, "")),
+ SEND_ATTR_STR(MAIL_ATTR_CRYPTO_PROTOCOL,
+ IF_ENCRYPTED(state->tls_context->protocol, "")),
+ SEND_ATTR_STR(MAIL_ATTR_CRYPTO_CIPHER,
+ IF_ENCRYPTED(state->tls_context->cipher_name, "")),
+ SEND_ATTR_INT(MAIL_ATTR_CRYPTO_KEYSIZE,
+ IF_ENCRYPTED(state->tls_context->cipher_usebits, 0)),
#endif
ATTR_TYPE_END,
ATTR_FLAG_MISSING, /* Reply attributes. */
- ATTR_TYPE_STR, MAIL_ATTR_ACTION, action,
+ RECV_ATTR_STR(MAIL_ATTR_ACTION, action),
ATTR_TYPE_END) != 1) {
NOCLOBBER static int nesting_level = 0;
jmp_buf savebuf;
*/
if (attr_clnt_request(tls_mgr,
ATTR_FLAG_NONE, /* Request attributes */
- ATTR_TYPE_STR, TLS_MGR_ATTR_REQ, TLS_MGR_REQ_SEED,
- ATTR_TYPE_INT, TLS_MGR_ATTR_SIZE, len,
+ SEND_ATTR_STR(TLS_MGR_ATTR_REQ, TLS_MGR_REQ_SEED),
+ SEND_ATTR_INT(TLS_MGR_ATTR_SIZE, len),
ATTR_TYPE_END,
ATTR_FLAG_MISSING, /* Reply attributes */
- ATTR_TYPE_INT, TLS_MGR_ATTR_STATUS, &status,
- ATTR_TYPE_DATA, TLS_MGR_ATTR_SEED, buf,
+ RECV_ATTR_INT(TLS_MGR_ATTR_STATUS, &status),
+ RECV_ATTR_DATA(TLS_MGR_ATTR_SEED, buf),
ATTR_TYPE_END) != 2)
status = TLS_MGR_STAT_FAIL;
return (status);
*/
if (attr_clnt_request(tls_mgr,
ATTR_FLAG_NONE, /* Request attributes */
- ATTR_TYPE_STR, TLS_MGR_ATTR_REQ, TLS_MGR_REQ_POLICY,
- ATTR_TYPE_STR, TLS_MGR_ATTR_CACHE_TYPE, cache_type,
+ SEND_ATTR_STR(TLS_MGR_ATTR_REQ, TLS_MGR_REQ_POLICY),
+ SEND_ATTR_STR(TLS_MGR_ATTR_CACHE_TYPE, cache_type),
ATTR_TYPE_END,
ATTR_FLAG_MISSING, /* Reply attributes */
- ATTR_TYPE_INT, TLS_MGR_ATTR_STATUS, &status,
- ATTR_TYPE_INT, TLS_MGR_ATTR_CACHABLE, cachable,
- ATTR_TYPE_INT, TLS_MGR_ATTR_SESSTOUT, timeout,
+ RECV_ATTR_INT(TLS_MGR_ATTR_STATUS, &status),
+ RECV_ATTR_INT(TLS_MGR_ATTR_CACHABLE, cachable),
+ RECV_ATTR_INT(TLS_MGR_ATTR_SESSTOUT, timeout),
ATTR_TYPE_END) != 3)
status = TLS_MGR_STAT_FAIL;
return (status);
*/
if (attr_clnt_request(tls_mgr,
ATTR_FLAG_NONE, /* Request */
- ATTR_TYPE_STR, TLS_MGR_ATTR_REQ, TLS_MGR_REQ_LOOKUP,
- ATTR_TYPE_STR, TLS_MGR_ATTR_CACHE_TYPE, cache_type,
- ATTR_TYPE_STR, TLS_MGR_ATTR_CACHE_ID, cache_id,
+ SEND_ATTR_STR(TLS_MGR_ATTR_REQ, TLS_MGR_REQ_LOOKUP),
+ SEND_ATTR_STR(TLS_MGR_ATTR_CACHE_TYPE, cache_type),
+ SEND_ATTR_STR(TLS_MGR_ATTR_CACHE_ID, cache_id),
ATTR_TYPE_END,
ATTR_FLAG_MISSING, /* Reply */
- ATTR_TYPE_INT, TLS_MGR_ATTR_STATUS, &status,
- ATTR_TYPE_DATA, TLS_MGR_ATTR_SESSION, buf,
+ RECV_ATTR_INT(TLS_MGR_ATTR_STATUS, &status),
+ RECV_ATTR_DATA(TLS_MGR_ATTR_SESSION, buf),
ATTR_TYPE_END) != 2)
status = TLS_MGR_STAT_FAIL;
return (status);
*/
if (attr_clnt_request(tls_mgr,
ATTR_FLAG_NONE, /* Request */
- ATTR_TYPE_STR, TLS_MGR_ATTR_REQ, TLS_MGR_REQ_UPDATE,
- ATTR_TYPE_STR, TLS_MGR_ATTR_CACHE_TYPE, cache_type,
- ATTR_TYPE_STR, TLS_MGR_ATTR_CACHE_ID, cache_id,
- ATTR_TYPE_DATA, TLS_MGR_ATTR_SESSION, len, buf,
+ SEND_ATTR_STR(TLS_MGR_ATTR_REQ, TLS_MGR_REQ_UPDATE),
+ SEND_ATTR_STR(TLS_MGR_ATTR_CACHE_TYPE, cache_type),
+ SEND_ATTR_STR(TLS_MGR_ATTR_CACHE_ID, cache_id),
+ SEND_ATTR_DATA(TLS_MGR_ATTR_SESSION, len, buf),
ATTR_TYPE_END,
ATTR_FLAG_MISSING, /* Reply */
- ATTR_TYPE_INT, TLS_MGR_ATTR_STATUS, &status,
+ RECV_ATTR_INT(TLS_MGR_ATTR_STATUS, &status),
ATTR_TYPE_END) != 1)
status = TLS_MGR_STAT_FAIL;
return (status);
*/
if (attr_clnt_request(tls_mgr,
ATTR_FLAG_NONE, /* Request */
- ATTR_TYPE_STR, TLS_MGR_ATTR_REQ, TLS_MGR_REQ_DELETE,
- ATTR_TYPE_STR, TLS_MGR_ATTR_CACHE_TYPE, cache_type,
- ATTR_TYPE_STR, TLS_MGR_ATTR_CACHE_ID, cache_id,
+ SEND_ATTR_STR(TLS_MGR_ATTR_REQ, TLS_MGR_REQ_DELETE),
+ SEND_ATTR_STR(TLS_MGR_ATTR_CACHE_TYPE, cache_type),
+ SEND_ATTR_STR(TLS_MGR_ATTR_CACHE_ID, cache_id),
ATTR_TYPE_END,
ATTR_FLAG_MISSING, /* Reply */
- ATTR_TYPE_INT, TLS_MGR_ATTR_STATUS, &status,
+ RECV_ATTR_INT(TLS_MGR_ATTR_STATUS, &status),
ATTR_TYPE_END) != 1)
status = TLS_MGR_STAT_FAIL;
return (status);
*/
if (attr_clnt_request(tls_mgr,
ATTR_FLAG_NONE, /* Request */
- ATTR_TYPE_STR, TLS_MGR_ATTR_REQ, TLS_MGR_REQ_TKTKEY,
- ATTR_TYPE_DATA, TLS_MGR_ATTR_KEYNAME, len, name,
+ SEND_ATTR_STR(TLS_MGR_ATTR_REQ, TLS_MGR_REQ_TKTKEY),
+ SEND_ATTR_DATA(TLS_MGR_ATTR_KEYNAME, len, name),
ATTR_TYPE_END,
ATTR_FLAG_MISSING, /* Reply */
- ATTR_TYPE_INT, TLS_MGR_ATTR_STATUS, &status,
- ATTR_TYPE_DATA, TLS_MGR_ATTR_KEYBUF, keybuf,
+ RECV_ATTR_INT(TLS_MGR_ATTR_STATUS, &status),
+ RECV_ATTR_DATA(TLS_MGR_ATTR_KEYBUF, keybuf),
ATTR_TYPE_END) != 2
|| status != TLS_MGR_STAT_OK
|| LEN(keybuf) != sizeof(tmp))
tlsproxy_stream = vstream_fdopen(fd, O_RDWR);
vstring_sprintf(remote_endpt, "[%s]:%s", peer_addr, peer_port);
attr_print(tlsproxy_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_STR, MAIL_ATTR_REMOTE_ENDPT, STR(remote_endpt),
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, flags,
- ATTR_TYPE_INT, MAIL_ATTR_TIMEOUT, timeout,
+ SEND_ATTR_STR(MAIL_ATTR_REMOTE_ENDPT, STR(remote_endpt)),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, flags),
+ SEND_ATTR_INT(MAIL_ATTR_TIMEOUT, timeout),
ATTR_TYPE_END);
if (vstream_fflush(tlsproxy_stream) != 0) {
msg_warn("error sending request to %s service: %m",
* descriptor. We can't assume UNIX-domain socket semantics here.
*/
if (attr_scan(tlsproxy_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, &status,
+ RECV_ATTR_INT(MAIL_ATTR_STATUS, &status),
ATTR_TYPE_END) != 1 || status == 0) {
/*
tls_context = (TLS_SESS_STATE *) mymalloc(sizeof(*tls_context));
if (attr_scan(proxy_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_FUNC, tls_proxy_context_scan, (void *) tls_context,
+ RECV_ATTR_FUNC(tls_proxy_context_scan, (void *) tls_context),
ATTR_TYPE_END) != 1) {
tls_proxy_context_free(tls_context);
return (0);
/* routine. TLS_SESS_STATE() is meant to be passed as a call-back
/* to attr_print(), thusly:
/*
-/* ... ATTR_TYPE_FUNC, tls_proxy_context_print, (void *) tls_context, ...
+/* ... SEND_ATTR_FUNC(tls_proxy_context_print, (void *) tls_context), ...
/* DIAGNOSTICS
/* Fatal: out of memory.
/* LICENSE
#define STRING_OR_EMPTY(s) ((s) ? (s) : "")
ret = print_fn(fp, flags | ATTR_FLAG_MORE,
- ATTR_TYPE_STR, MAIL_ATTR_PEER_CN,
- STRING_OR_EMPTY(tp->peer_CN),
- ATTR_TYPE_STR, MAIL_ATTR_ISSUER_CN,
- STRING_OR_EMPTY(tp->issuer_CN),
- ATTR_TYPE_STR, MAIL_ATTR_PEER_CERT_FPT,
- STRING_OR_EMPTY(tp->peer_cert_fprint),
- ATTR_TYPE_STR, MAIL_ATTR_PEER_PKEY_FPT,
- STRING_OR_EMPTY(tp->peer_pkey_fprint),
- ATTR_TYPE_INT, MAIL_ATTR_PEER_STATUS,
- tp->peer_status,
- ATTR_TYPE_STR, MAIL_ATTR_CIPHER_PROTOCOL,
- STRING_OR_EMPTY(tp->protocol),
- ATTR_TYPE_STR, MAIL_ATTR_CIPHER_NAME,
- STRING_OR_EMPTY(tp->cipher_name),
- ATTR_TYPE_INT, MAIL_ATTR_CIPHER_USEBITS,
- tp->cipher_usebits,
- ATTR_TYPE_INT, MAIL_ATTR_CIPHER_ALGBITS,
- tp->cipher_algbits,
+ SEND_ATTR_STR(MAIL_ATTR_PEER_CN,
+ STRING_OR_EMPTY(tp->peer_CN)),
+ SEND_ATTR_STR(MAIL_ATTR_ISSUER_CN,
+ STRING_OR_EMPTY(tp->issuer_CN)),
+ SEND_ATTR_STR(MAIL_ATTR_PEER_CERT_FPT,
+ STRING_OR_EMPTY(tp->peer_cert_fprint)),
+ SEND_ATTR_STR(MAIL_ATTR_PEER_PKEY_FPT,
+ STRING_OR_EMPTY(tp->peer_pkey_fprint)),
+ SEND_ATTR_INT(MAIL_ATTR_PEER_STATUS,
+ tp->peer_status),
+ SEND_ATTR_STR(MAIL_ATTR_CIPHER_PROTOCOL,
+ STRING_OR_EMPTY(tp->protocol)),
+ SEND_ATTR_STR(MAIL_ATTR_CIPHER_NAME,
+ STRING_OR_EMPTY(tp->cipher_name)),
+ SEND_ATTR_INT(MAIL_ATTR_CIPHER_USEBITS,
+ tp->cipher_usebits),
+ SEND_ATTR_INT(MAIL_ATTR_CIPHER_ALGBITS,
+ tp->cipher_algbits),
ATTR_TYPE_END);
return (ret);
}
/* routine. tls_proxy_context_scan() is meant to be passed as
/* a call-back to attr_scan(), thusly:
/*
-/* ... ATTR_TYPE_FUNC, tls_proxy_context_scan, (void *) tls_context, ...
+/* ... RECV_ATTR_FUNC(tls_proxy_context_scan, (void *) tls_context), ...
/* DIAGNOSTICS
/* Fatal: out of memory.
/* LICENSE
*/
memset(ptr, 0, sizeof(TLS_SESS_STATE));
ret = scan_fn(fp, flags | ATTR_FLAG_MORE,
- ATTR_TYPE_STR, MAIL_ATTR_PEER_CN, peer_CN,
- ATTR_TYPE_STR, MAIL_ATTR_ISSUER_CN, issuer_CN,
- ATTR_TYPE_STR, MAIL_ATTR_PEER_CERT_FPT, peer_cert_fprint,
- ATTR_TYPE_STR, MAIL_ATTR_PEER_PKEY_FPT, peer_pkey_fprint,
- ATTR_TYPE_INT, MAIL_ATTR_PEER_STATUS,
- &tls_context->peer_status,
- ATTR_TYPE_STR, MAIL_ATTR_CIPHER_PROTOCOL, protocol,
- ATTR_TYPE_STR, MAIL_ATTR_CIPHER_NAME, cipher_name,
- ATTR_TYPE_INT, MAIL_ATTR_CIPHER_USEBITS,
- &tls_context->cipher_usebits,
- ATTR_TYPE_INT, MAIL_ATTR_CIPHER_ALGBITS,
- &tls_context->cipher_algbits,
+ RECV_ATTR_STR(MAIL_ATTR_PEER_CN, peer_CN),
+ RECV_ATTR_STR(MAIL_ATTR_ISSUER_CN, issuer_CN),
+ RECV_ATTR_STR(MAIL_ATTR_PEER_CERT_FPT, peer_cert_fprint),
+ RECV_ATTR_STR(MAIL_ATTR_PEER_PKEY_FPT, peer_pkey_fprint),
+ RECV_ATTR_INT(MAIL_ATTR_PEER_STATUS,
+ &tls_context->peer_status),
+ RECV_ATTR_STR(MAIL_ATTR_CIPHER_PROTOCOL, protocol),
+ RECV_ATTR_STR(MAIL_ATTR_CIPHER_NAME, cipher_name),
+ RECV_ATTR_INT(MAIL_ATTR_CIPHER_USEBITS,
+ &tls_context->cipher_usebits),
+ RECV_ATTR_INT(MAIL_ATTR_CIPHER_ALGBITS,
+ &tls_context->cipher_algbits),
ATTR_TYPE_END);
tls_context->peer_CN = vstring_export(peer_CN);
tls_context->issuer_CN = vstring_export(issuer_CN);
else {
if (attr_scan(client_stream,
ATTR_FLAG_MORE | ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, TLS_MGR_ATTR_REQ, request,
+ RECV_ATTR_STR(TLS_MGR_ATTR_REQ, request),
ATTR_TYPE_END) != 1) {
return (-1);
}
*/
if (STREQ(STR(request), TLS_MGR_REQ_LOOKUP)) {
if (attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, TLS_MGR_ATTR_CACHE_TYPE, cache_type,
- ATTR_TYPE_STR, TLS_MGR_ATTR_CACHE_ID, cache_id,
+ RECV_ATTR_STR(TLS_MGR_ATTR_CACHE_TYPE, cache_type),
+ RECV_ATTR_STR(TLS_MGR_ATTR_CACHE_ID, cache_id),
ATTR_TYPE_END) == 2) {
for (ent = cache_table; ent->cache_label; ++ent)
if (strcmp(ent->cache_label, STR(cache_type)) == 0)
}
}
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, status,
- ATTR_TYPE_DATA, TLS_MGR_ATTR_SESSION,
- LEN(buffer), STR(buffer),
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, status),
+ SEND_ATTR_DATA(TLS_MGR_ATTR_SESSION,
+ LEN(buffer), STR(buffer)),
ATTR_TYPE_END);
}
*/
else if (STREQ(STR(request), TLS_MGR_REQ_UPDATE)) {
if (attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, TLS_MGR_ATTR_CACHE_TYPE, cache_type,
- ATTR_TYPE_STR, TLS_MGR_ATTR_CACHE_ID, cache_id,
- ATTR_TYPE_DATA, TLS_MGR_ATTR_SESSION, buffer,
+ RECV_ATTR_STR(TLS_MGR_ATTR_CACHE_TYPE, cache_type),
+ RECV_ATTR_STR(TLS_MGR_ATTR_CACHE_ID, cache_id),
+ RECV_ATTR_DATA(TLS_MGR_ATTR_SESSION, buffer),
ATTR_TYPE_END) == 3) {
for (ent = cache_table; ent->cache_label; ++ent)
if (strcmp(ent->cache_label, STR(cache_type)) == 0)
}
}
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, status,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, status),
ATTR_TYPE_END);
}
*/
else if (STREQ(STR(request), TLS_MGR_REQ_DELETE)) {
if (attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, TLS_MGR_ATTR_CACHE_TYPE, cache_type,
- ATTR_TYPE_STR, TLS_MGR_ATTR_CACHE_ID, cache_id,
+ RECV_ATTR_STR(TLS_MGR_ATTR_CACHE_TYPE, cache_type),
+ RECV_ATTR_STR(TLS_MGR_ATTR_CACHE_ID, cache_id),
ATTR_TYPE_END) == 2) {
for (ent = cache_table; ent->cache_label; ++ent)
if (strcmp(ent->cache_label, STR(cache_type)) == 0)
}
}
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, status,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, status),
ATTR_TYPE_END);
}
*/
else if (STREQ(STR(request), TLS_MGR_REQ_TKTKEY)) {
if (attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_DATA, TLS_MGR_ATTR_KEYNAME, buffer,
+ RECV_ATTR_DATA(TLS_MGR_ATTR_KEYNAME, buffer),
ATTR_TYPE_END) == 1) {
if (LEN(buffer) != 0 && LEN(buffer) != TLS_TICKET_NAMELEN) {
msg_warn("invalid session ticket key name length: %ld",
}
}
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, status,
- ATTR_TYPE_DATA, TLS_MGR_ATTR_KEYBUF,
- LEN(buffer), STR(buffer),
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, status),
+ SEND_ATTR_DATA(TLS_MGR_ATTR_KEYBUF,
+ LEN(buffer), STR(buffer)),
ATTR_TYPE_END);
}
*/
else if (STREQ(STR(request), TLS_MGR_REQ_SEED)) {
if (attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_INT, TLS_MGR_ATTR_SIZE, &len,
+ RECV_ATTR_INT(TLS_MGR_ATTR_SIZE, &len),
ATTR_TYPE_END) == 1) {
VSTRING_RESET(buffer);
if (len <= 0 || len > 255) {
}
}
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, status,
- ATTR_TYPE_DATA, TLS_MGR_ATTR_SEED,
- LEN(buffer), STR(buffer),
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, status),
+ SEND_ATTR_DATA(TLS_MGR_ATTR_SEED,
+ LEN(buffer), STR(buffer)),
ATTR_TYPE_END);
}
int timeout = 0;
if (attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, TLS_MGR_ATTR_CACHE_TYPE, cache_type,
+ RECV_ATTR_STR(TLS_MGR_ATTR_CACHE_TYPE, cache_type),
ATTR_TYPE_END) == 1) {
for (ent = cache_table; ent->cache_label; ++ent)
if (strcmp(ent->cache_label, STR(cache_type)) == 0)
}
}
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, status,
- ATTR_TYPE_INT, TLS_MGR_ATTR_CACHABLE, cachable,
- ATTR_TYPE_INT, TLS_MGR_ATTR_SESSTOUT, timeout,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, status),
+ SEND_ATTR_INT(TLS_MGR_ATTR_CACHABLE, cachable),
+ SEND_ATTR_INT(TLS_MGR_ATTR_SESSTOUT, timeout),
ATTR_TYPE_END);
}
*/
else {
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, TLS_MGR_STAT_FAIL,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, TLS_MGR_STAT_FAIL),
ATTR_TYPE_END);
}
vstream_fflush(client_stream);
}
if ((state->req_flags & TLS_PROXY_FLAG_SEND_CONTEXT) != 0
&& (attr_print(state->plaintext_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_FUNC, tls_proxy_context_print,
- (void *) state->tls_context, ATTR_TYPE_END) != 0
+ SEND_ATTR_FUNC(tls_proxy_context_print,
+ (void *) state->tls_context),
+ ATTR_TYPE_END) != 0
|| vstream_fflush(state->plaintext_stream) != 0)) {
msg_warn("cannot send TLS context: %m");
tlsp_state_free(state);
*/
if (event != EVENT_READ
|| attr_scan(plaintext_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_REMOTE_ENDPT, remote_endpt,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, &req_flags,
- ATTR_TYPE_INT, MAIL_ATTR_TIMEOUT, &timeout,
- ATTR_TYPE_STR, MAIL_ATTR_SERVER_ID, server_id,
+ RECV_ATTR_STR(MAIL_ATTR_REMOTE_ENDPT, remote_endpt),
+ RECV_ATTR_INT(MAIL_ATTR_FLAGS, &req_flags),
+ RECV_ATTR_INT(MAIL_ATTR_TIMEOUT, &timeout),
+ RECV_ATTR_STR(MAIL_ATTR_SERVER_ID, server_id),
ATTR_TYPE_END) != 4) {
msg_warn("%s: receive request attributes: %m", myname);
event_disable_readwrite(plaintext_fd);
ready = ((req_flags & TLS_PROXY_FLAG_ROLE_SERVER) != 0
&& tlsp_server_ctx != 0);
if (attr_print(plaintext_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, ready,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, ready),
ATTR_TYPE_END) != 0
|| vstream_fflush(plaintext_stream) != 0
|| ready == 0) {
/* resolve_class - determine domain address class */
-int resolve_class(const char *domain)
+int resolve_class(const char *domain)
{
int ret;
int flags;
if (attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_SENDER, sender,
- ATTR_TYPE_STR, MAIL_ATTR_ADDR, query,
+ RECV_ATTR_STR(MAIL_ATTR_SENDER, sender),
+ RECV_ATTR_STR(MAIL_ATTR_ADDR, query),
ATTR_TYPE_END) != 2)
return (-1);
STR(nexthop), STR(nextrcpt), flags);
attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, server_flags,
- ATTR_TYPE_STR, MAIL_ATTR_TRANSPORT, STR(channel),
- ATTR_TYPE_STR, MAIL_ATTR_NEXTHOP, STR(nexthop),
- ATTR_TYPE_STR, MAIL_ATTR_RECIP, STR(nextrcpt),
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, flags,
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, server_flags),
+ SEND_ATTR_STR(MAIL_ATTR_TRANSPORT, STR(channel)),
+ SEND_ATTR_STR(MAIL_ATTR_NEXTHOP, STR(nexthop)),
+ SEND_ATTR_STR(MAIL_ATTR_RECIP, STR(nextrcpt)),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, flags),
ATTR_TYPE_END);
if (vstream_fflush(stream) != 0) {
TOK822 *tree;
if (attr_scan(stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_RULE, ruleset,
- ATTR_TYPE_STR, MAIL_ATTR_ADDR, address,
+ RECV_ATTR_STR(MAIL_ATTR_RULE, ruleset),
+ RECV_ATTR_STR(MAIL_ATTR_ADDR, address),
ATTR_TYPE_END) != 2)
return (-1);
vstring_str(address), vstring_str(result));
attr_print(stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_FLAGS, server_flags,
- ATTR_TYPE_STR, MAIL_ATTR_ADDR, vstring_str(result),
+ SEND_ATTR_INT(MAIL_ATTR_FLAGS, server_flags),
+ SEND_ATTR_STR(MAIL_ATTR_ADDR, vstring_str(result)),
ATTR_TYPE_END);
if (vstream_fflush(stream) != 0) {
* handled by the common code in multi_server.c.
*/
if (attr_scan(stream, ATTR_FLAG_STRICT | ATTR_FLAG_MORE,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, command,
+ RECV_ATTR_STR(MAIL_ATTR_REQ, command),
ATTR_TYPE_END) == 1) {
if (strcmp(vstring_str(command), REWRITE_ADDR) == 0) {
status = rewrite_proto(stream);
#define ATTR_HASH_LIMIT 1024 /* Size of hash table */
+ /*
+ * Optional wrappers to enable type checking on varargs argument lists. Each
+ * non-pointer argument is handled by a want_xxx_val() wrapper (xxx = int,
+ * long or ssize_t), and each pointer argument is handled by a
+ * want_xxx_ptr() wrapper. With VARARGS_ATTR_DEBUG defined, the wrappers
+ * will detect type mis-matches of interest.
+ *
+ * Note 1: Non-pointer types. With VARARGS_ATTR_DEBUG defined, we don't detect
+ * type mismatches between non-pointer types. Reason: the want_xxx_val()
+ * wrappers cannot force the caller to actually pass an int, long or ssize_t
+ * argument. We do detect type mismatches between pointer/non-pointer types.
+ * Since type mismatches between non-pointers cannot be detected with
+ * VARARGS_ATTR_DEBUG defined, the want_xxx_val() wrappers use a typecast
+ * with VARARGS_ATTR_DEBUG undefined.
+ *
+ * Note 2: Pointer types. With VARARGS_ATTR_DEBUG defined, we do detect type
+ * mismatches between pointer types. The want_(const_)void_ptr() wrappers
+ * expect char* arguments instead of void*, because the latter would never
+ * complain about pointer type mismatches. If the caller actually passes a
+ * void* argument, then the implicit conversion to char* will be silent, and
+ * that is exactly what we want. We also detect type mismatches between
+ * pointer/non-pointer types. Since all type mismatches of interest can be
+ * detected with VARARGS_ATTR_DEBUG defined, the want_xxx_ptr() wrappers
+ * become NOOPs with VARARGS_ATTR_DEBUG undefined.
+ */
+#ifdef VARARGS_ATTR_DEBUG
+static inline int want_int_val(int v)
+{ /* Note 1 */
+ return (v);
+}
+static inline long want_long_val(long v)
+{ /* Note 1 */
+ return (v);
+}
+static inline ssize_t want_ssize_t_val(ssize_t v)
+{ /* Note 1 */
+ return (v);
+}
+static inline int *want_int_ptr(int *p)
+{
+ return (p);
+}
+static inline const char *want_const_char_ptr(const char *p)
+{
+ return (p);
+}
+static inline char *want_char_ptr(char *p)
+{
+ return (p);
+}
+static inline struct VSTRING *want_vstr_ptr(struct VSTRING *p)
+{
+ return (p);
+}
+static inline const struct HTABLE *want_const_ht_ptr(const struct HTABLE *p)
+{
+ return (p);
+}
+static inline struct HTABLE *want_ht_ptr(struct HTABLE *p)
+{
+ return (p);
+}
+static inline const struct NVTABLE *want_const_nv_ptr(const struct NVTABLE * p)
+{
+ return (p);
+}
+static inline struct NVTABLE *want_nv_ptr(struct NVTABLE * p)
+{
+ return (p);
+}
+static inline long *want_long_ptr(long *p)
+{
+ return (p);
+}
+static inline const char *want_const_void_ptr(const char *p)
+{ /* Note 2 */
+ return (p);
+}
+static inline char *want_void_ptr(char *p)
+{ /* Note 2 */
+ return (p);
+}
+
+#else
+#define want_int_val(val) (int) (val) /* Note 1 */
+#define want_long_val(val) (long) (val) /* Note 1 */
+#define want_ssize_t_val(val) (ssize_t) (val) /* Note 1 */
+#define want_int_ptr(val) (val)
+#define want_const_char_ptr(val) (val)
+#define want_char_ptr(val) (val)
+#define want_vstr_ptr(val) (val)
+#define want_const_ht_ptr(val) (val)
+#define want_ht_ptr(val) (val)
+#define want_const_nv_ptr(val) (val)
+#define want_nv_ptr(val) (val)
+#define want_long_ptr(val) (val)
+#define want_const_void_ptr(val) (val)
+#define want_void_ptr(val) (val)
+#endif
+
+#define want_name(name) want_const_char_ptr(name)
+
+#define SEND_ATTR_INT(name, val) ATTR_TYPE_INT, want_name(name), want_int_val(val)
+#define SEND_ATTR_STR(name, val) ATTR_TYPE_STR, want_name(name), want_const_char_ptr(val)
+#define SEND_ATTR_HASH(name, val) ATTR_TYPE_HASH, want_name(name), want_const_ht_ptr(val)
+#define SEND_ATTR_NV(name, val) ATTR_TYPE_NV, want_name(name), want_const_nv_ptr(val)
+#define SEND_ATTR_LONG(name, val) ATTR_TYPE_LONG, want_name(name), want_long_val(val)
+#define SEND_ATTR_DATA(name, len, val) ATTR_TYPE_DATA, want_name(name), want_ssize_t_val(len), want_const_void_ptr(val)
+#define SEND_ATTR_FUNC(func, val) ATTR_TYPE_FUNC, (func), want_const_void_ptr(val)
+
+#define RECV_ATTR_INT(name, val) ATTR_TYPE_INT, want_name(name), want_int_ptr(val)
+#define RECV_ATTR_STR(name, val) ATTR_TYPE_STR, want_name(name), want_vstr_ptr(val)
+#define RECV_ATTR_HASH(name, val) ATTR_TYPE_HASH, want_name(name), want_ht_ptr(val)
+#define RECV_ATTR_NV(name, val) ATTR_TYPE_NV, want_name(name), want_nv_ptr(val)
+#define RECV_ATTR_LONG(name, val) ATTR_TYPE_LONG, want_name(name), want_long_ptr(val)
+#define RECV_ATTR_DATA(name, val) ATTR_TYPE_DATA, want_name(name), want_vstr_ptr(val)
+#define RECV_ATTR_FUNC(func, val) ATTR_TYPE_FUNC, (func), want_void_ptr(val)
+
/*
* Flags that control processing. See attr_scan(3) for documentation.
*/
/*
* Delegation for better data abstraction.
*/
-typedef int (*ATTR_SCAN_MASTER_FN) (VSTREAM *, int, ...);
+typedef int (*ATTR_SCAN_MASTER_FN) (VSTREAM *, int,...);
typedef int (*ATTR_SCAN_SLAVE_FN) (ATTR_SCAN_MASTER_FN, VSTREAM *, int, void *);
typedef int (*ATTR_PRINT_MASTER_FN) (VSTREAM *, int,...);
typedef int (*ATTR_PRINT_SLAVE_FN) (ATTR_PRINT_MASTER_FN, VSTREAM *, int, void *);
long updated;
if (attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_ADDR, addr,
- ATTR_TYPE_INT, MAIL_ATTR_ADDR_STATUS, &addr_status,
- ATTR_TYPE_STR, MAIL_ATTR_WHY, text,
+ RECV_ATTR_STR(MAIL_ATTR_ADDR, addr),
+ RECV_ATTR_INT(MAIL_ATTR_ADDR_STATUS, &addr_status),
+ RECV_ATTR_STR(MAIL_ATTR_WHY, text),
ATTR_TYPE_END) == 3) {
/* FIX 200501 IPv6 patch did not neuter ":" in address literals. */
translit(STR(addr), ":", "_");
msg_warn("bad recipient status %d for recipient %s",
addr_status, STR(addr));
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, VRFY_STAT_BAD,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, VRFY_STAT_BAD),
ATTR_TYPE_END);
} else {
dict_cache_update(verify_map, STR(addr), STR(buf));
}
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, VRFY_STAT_OK,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, VRFY_STAT_OK),
ATTR_TYPE_END);
}
}
char *text;
if (attr_scan(client_stream, ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_ADDR, addr,
+ RECV_ATTR_STR(MAIL_ATTR_ADDR, addr),
ATTR_TYPE_END) == 1) {
long now = (long) time((time_t *) 0);
* Respond to the client.
*/
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, VRFY_STAT_OK,
- ATTR_TYPE_INT, MAIL_ATTR_ADDR_STATUS, addr_status,
- ATTR_TYPE_STR, MAIL_ATTR_WHY, text,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, VRFY_STAT_OK),
+ SEND_ATTR_INT(MAIL_ATTR_ADDR_STATUS, addr_status),
+ SEND_ATTR_STR(MAIL_ATTR_WHY, text),
ATTR_TYPE_END);
/*
*/
if (attr_scan(client_stream,
ATTR_FLAG_MORE | ATTR_FLAG_STRICT,
- ATTR_TYPE_STR, MAIL_ATTR_REQ, request,
+ RECV_ATTR_STR(MAIL_ATTR_REQ, request),
ATTR_TYPE_END) == 1) {
if (STREQ(STR(request), VRFY_REQ_UPDATE)) {
verify_update_service(client_stream);
} else {
msg_warn("unrecognized request: \"%s\", ignored", STR(request));
attr_print(client_stream, ATTR_FLAG_NONE,
- ATTR_TYPE_INT, MAIL_ATTR_STATUS, VRFY_STAT_BAD,
+ SEND_ATTR_INT(MAIL_ATTR_STATUS, VRFY_STAT_BAD),
ATTR_TYPE_END);
}
}
projects / thirdparty / postfix.git / commitdiff
