From: Wietse Venema Date: Sun, 14 Dec 2014 05:00:00 +0000 (-0500) Subject: postfix-2.12-20141214-nonprod X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=ac172c8981a7d09af641ae0d42f26512f29b8ca2;p=thirdparty%2Fpostfix.git postfix-2.12-20141214-nonprod --- diff --git a/postfix/HISTORY b/postfix/HISTORY index cd8d5d5a3..b0185e511 100644 --- a/postfix/HISTORY +++ b/postfix/HISTORY @@ -21090,6 +21090,30 @@ Apologies for any names omitted. 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. diff --git a/postfix/makedefs b/postfix/makedefs index 6d69bb545..58eb0cca4 100644 --- a/postfix/makedefs +++ b/postfix/makedefs @@ -758,7 +758,7 @@ CCARGS="$CCARGS -DSNAPSHOT" # 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" diff --git a/postfix/src/anvil/anvil.c b/postfix/src/anvil/anvil.c index 07e4bb013..59549e878 100644 --- a/postfix/src/anvil/anvil.c +++ b/postfix/src/anvil/anvil.c @@ -525,12 +525,12 @@ static void anvil_remote_lookup(VSTREAM *client_stream, const char *ident) 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 { @@ -541,12 +541,12 @@ static void anvil_remote_lookup(VSTREAM *client_stream, const char *ident) && 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); } } @@ -617,9 +617,9 @@ static void anvil_remote_connect(VSTREAM *client_stream, const char *ident) * 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); /* @@ -649,8 +649,8 @@ static void anvil_remote_mail(VSTREAM *client_stream, const char *ident) */ 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); /* @@ -678,8 +678,8 @@ static void anvil_remote_rcpt(VSTREAM *client_stream, const char *ident) */ 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); /* @@ -707,8 +707,8 @@ static void anvil_remote_newtls(VSTREAM *client_stream, const char *ident) */ 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); /* @@ -747,8 +747,8 @@ static void anvil_remote_newtls_stat(VSTREAM *client_stream, const char *ident) * 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); } @@ -784,7 +784,7 @@ static void anvil_remote_disconnect(VSTREAM *client_stream, const char *ident) * 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); } @@ -884,14 +884,14 @@ static void anvil_service(VSTREAM *client_stream, char *unused_service, char **a 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; } diff --git a/postfix/src/bounce/bounce.c b/postfix/src/bounce/bounce.c index 5ab4a0eae..2016a3433 100644 --- a/postfix/src/bounce/bounce.c +++ b/postfix/src/bounce/bounce.c @@ -223,10 +223,10 @@ static int bounce_append_proto(char *service_name, VSTREAM *client) * 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); @@ -295,14 +295,14 @@ static int bounce_notify_proto(char *service_name, VSTREAM *client, * 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); @@ -355,15 +355,15 @@ static int bounce_verp_proto(char *service_name, VSTREAM *client) * 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); @@ -429,16 +429,16 @@ static int bounce_one_proto(char *service_name, VSTREAM *client) * 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); @@ -518,7 +518,7 @@ static void bounce_service(VSTREAM *client, char *service_name, char **argv) * 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) { @@ -546,7 +546,7 @@ static void bounce_service(VSTREAM *client, char *service_name, char **argv) * 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); diff --git a/postfix/src/cleanup/cleanup.c b/postfix/src/cleanup/cleanup.c index a3530fa0e..3c05943f9 100644 --- a/postfix/src/cleanup/cleanup.c +++ b/postfix/src/cleanup/cleanup.c @@ -459,10 +459,10 @@ static void cleanup_service(VSTREAM *src, char *unused_service, char **argv) * 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; @@ -521,11 +521,11 @@ static void cleanup_service(VSTREAM *src, char *unused_service, char **argv) */ 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); diff --git a/postfix/src/dnsblog/dnsblog.c b/postfix/src/dnsblog/dnsblog.c index 33af6c852..d12ce69ae 100644 --- a/postfix/src/dnsblog/dnsblog.c +++ b/postfix/src/dnsblog/dnsblog.c @@ -231,18 +231,18 @@ static void dnsblog_service(VSTREAM *client_stream, char *unused_service, */ 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); } diff --git a/postfix/src/flush/flush.c b/postfix/src/flush/flush.c index 7b4fd01a5..1f544bdef 100644 --- a/postfix/src/flush/flush.c +++ b/postfix/src/flush/flush.c @@ -707,7 +707,7 @@ static int flush_request_receive(VSTREAM *client_stream, VSTRING *request) 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); } @@ -749,50 +749,50 @@ static void flush_service(VSTREAM *client_stream, char *unused_service, 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) diff --git a/postfix/src/global/abounce.c b/postfix/src/global/abounce.c index 4f1e96e98..efbf1050f 100644 --- a/postfix/src/global/abounce.c +++ b/postfix/src/global/abounce.c @@ -255,7 +255,7 @@ static void abounce_event(int event, void *context) 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); } @@ -288,16 +288,16 @@ static void abounce_request_verp(const char *class, const char *service, 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, @@ -360,15 +360,15 @@ static void abounce_request(const char *class, const char *service, 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, diff --git a/postfix/src/global/anvil_clnt.c b/postfix/src/global/anvil_clnt.c index 02ecac2f9..34d3c0f31 100644 --- a/postfix/src/global/anvil_clnt.c +++ b/postfix/src/global/anvil_clnt.c @@ -188,16 +188,16 @@ int anvil_clnt_lookup(ANVIL_CLNT *anvil_clnt, const char *service, 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) @@ -216,13 +216,13 @@ int anvil_clnt_connect(ANVIL_CLNT *anvil_clnt, const char *service, 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) @@ -241,12 +241,12 @@ int anvil_clnt_mail(ANVIL_CLNT *anvil_clnt, const char *service, 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) @@ -265,12 +265,12 @@ int anvil_clnt_rcpt(ANVIL_CLNT *anvil_clnt, const char *service, 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) @@ -289,12 +289,12 @@ int anvil_clnt_newtls(ANVIL_CLNT *anvil_clnt, const char *service, 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) @@ -313,12 +313,12 @@ int anvil_clnt_newtls_stat(ANVIL_CLNT *anvil_clnt, const char *service, 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) @@ -337,11 +337,11 @@ int anvil_clnt_disconnect(ANVIL_CLNT *anvil_clnt, const char *service, 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) diff --git a/postfix/src/global/bounce.c b/postfix/src/global/bounce.c index e45d9427a..134bcd248 100644 --- a/postfix/src/global/bounce.c +++ b/postfix/src/global/bounce.c @@ -310,11 +310,11 @@ int bounce_append_intern(int flags, const char *id, MSG_STATS *stats, 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, @@ -353,15 +353,15 @@ int bounce_flush(int flags, const char *queue, const char *id, 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) { @@ -387,16 +387,16 @@ int bounce_flush_verp(int flags, const char *queue, const char *id, 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) { @@ -494,17 +494,17 @@ int bounce_one_intern(int flags, const char *queue, const char *id, 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, diff --git a/postfix/src/global/defer.c b/postfix/src/global/defer.c index 110d2fc91..7b5c0ae8e 100644 --- a/postfix/src/global/defer.c +++ b/postfix/src/global/defer.c @@ -25,7 +25,7 @@ /* 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; @@ -257,11 +257,11 @@ int defer_append_intern(int flags, const char *id, MSG_STATS *stats, 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"); @@ -301,15 +301,15 @@ int defer_flush(int flags, const char *queue, const char *id, 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 { @@ -321,19 +321,19 @@ int defer_flush(int flags, const char *queue, const char *id, * 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 { diff --git a/postfix/src/global/deliver_pass.c b/postfix/src/global/deliver_pass.c index 01b70b942..e2112bafc 100644 --- a/postfix/src/global/deliver_pass.c +++ b/postfix/src/global/deliver_pass.c @@ -81,7 +81,7 @@ static int deliver_pass_initial_reply(VSTREAM *stream) 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; @@ -98,35 +98,35 @@ static int deliver_pass_send_request(VSTREAM *stream, DELIVER_REQUEST *request, 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)) { @@ -145,8 +145,8 @@ static int deliver_pass_final_reply(VSTREAM *stream, DSN_BUF *dsb) 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); diff --git a/postfix/src/global/deliver_request.c b/postfix/src/global/deliver_request.c index 087170bbe..f5c775ab2 100644 --- a/postfix/src/global/deliver_request.c +++ b/postfix/src/global/deliver_request.c @@ -137,7 +137,7 @@ static int deliver_request_initial(VSTREAM *stream) 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) @@ -165,8 +165,8 @@ static int deliver_request_final(VSTREAM *stream, DELIVER_REQUEST *request, 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) @@ -241,32 +241,32 @@ static int deliver_request_get(VSTREAM *stream, DELIVER_REQUEST *request) * 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); @@ -305,7 +305,7 @@ static int deliver_request_get(VSTREAM *stream, DELIVER_REQUEST *request) */ 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); diff --git a/postfix/src/global/dict_proxy.c b/postfix/src/global/dict_proxy.c index 86682f84d..29410d785 100644 --- a/postfix/src/global/dict_proxy.c +++ b/postfix/src/global/dict_proxy.c @@ -119,16 +119,16 @@ static int dict_proxy_sequence(DICT *dict, int function, 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)); @@ -194,15 +194,15 @@ static const char *dict_proxy_lookup(DICT *dict, const char *key) 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)); @@ -262,15 +262,15 @@ static int dict_proxy_update(DICT *dict, const char *key, const char *value) 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)); @@ -329,14 +329,14 @@ static int dict_proxy_delete(DICT *dict, const char *key) 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)) @@ -465,14 +465,14 @@ DICT *dict_proxy_open(const char *map, int open_flags, int dict_flags) 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); diff --git a/postfix/src/global/dsb_scan.c b/postfix/src/global/dsb_scan.c index 8331022c5..e99c4436b 100644 --- a/postfix/src/global/dsb_scan.c +++ b/postfix/src/global/dsb_scan.c @@ -16,7 +16,7 @@ /* 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 @@ -56,13 +56,13 @@ int dsb_scan(ATTR_SCAN_MASTER_FN scan_fn, VSTREAM *fp, * 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); } diff --git a/postfix/src/global/dsn_print.c b/postfix/src/global/dsn_print.c index 58f06a34c..369804839 100644 --- a/postfix/src/global/dsn_print.c +++ b/postfix/src/global/dsn_print.c @@ -16,7 +16,7 @@ /* 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 @@ -56,13 +56,13 @@ int dsn_print(ATTR_PRINT_MASTER_FN print_fn, VSTREAM *fp, * 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); } diff --git a/postfix/src/global/flush_clnt.c b/postfix/src/global/flush_clnt.c index 898181293..07985dc20 100644 --- a/postfix/src/global/flush_clnt.c +++ b/postfix/src/global/flush_clnt.c @@ -125,7 +125,7 @@ int flush_purge(void) 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) @@ -151,7 +151,7 @@ int flush_refresh(void) 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) @@ -182,8 +182,8 @@ int flush_send_site(const char *site) 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; @@ -210,8 +210,8 @@ int flush_send_file(const char *queue_id) * 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) @@ -242,9 +242,9 @@ int flush_add(const char *site, const char *queue_id) 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; diff --git a/postfix/src/global/mail_command_client.c b/postfix/src/global/mail_command_client.c index db4360972..b5cb21c78 100644 --- a/postfix/src/global/mail_command_client.c +++ b/postfix/src/global/mail_command_client.c @@ -75,7 +75,7 @@ int mail_command_client(const char *class, const char *name,...) 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); diff --git a/postfix/src/global/mail_stream.c b/postfix/src/global/mail_stream.c index 941c77db0..f760636ee 100644 --- a/postfix/src/global/mail_stream.c +++ b/postfix/src/global/mail_stream.c @@ -378,11 +378,11 @@ static int mail_stream_finish_ipc(MAIL_STREAM *info, VSTRING *why) * 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; @@ -441,7 +441,7 @@ MAIL_STREAM *mail_stream_service(const char *class, const char *name) 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 { @@ -493,7 +493,7 @@ MAIL_STREAM *mail_stream_command(const char *command) 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); diff --git a/postfix/src/global/msg_stats_print.c b/postfix/src/global/msg_stats_print.c index f39b73c99..18d2ee26d 100644 --- a/postfix/src/global/msg_stats_print.c +++ b/postfix/src/global/msg_stats_print.c @@ -17,7 +17,7 @@ /* 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 @@ -58,7 +58,7 @@ int msg_stats_print(ATTR_PRINT_MASTER_FN print_fn, VSTREAM *fp, * 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); } diff --git a/postfix/src/global/msg_stats_scan.c b/postfix/src/global/msg_stats_scan.c index 3c05ce07e..280d32107 100644 --- a/postfix/src/global/msg_stats_scan.c +++ b/postfix/src/global/msg_stats_scan.c @@ -16,7 +16,7 @@ /* 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 @@ -70,7 +70,7 @@ int msg_stats_scan(ATTR_SCAN_MASTER_FN scan_fn, VSTREAM *fp, * 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)) { diff --git a/postfix/src/global/post_mail.c b/postfix/src/global/post_mail.c index 3a1cbc48d..a267e34c5 100644 --- a/postfix/src/global/post_mail.c +++ b/postfix/src/global/post_mail.c @@ -209,10 +209,10 @@ static void post_mail_init(VSTREAM *stream, const char *sender, * 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); @@ -425,7 +425,7 @@ int post_mail_fclose(VSTREAM *cleanup) 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; } diff --git a/postfix/src/global/rcpt_buf.c b/postfix/src/global/rcpt_buf.c index 1da56483b..73175fd03 100644 --- a/postfix/src/global/rcpt_buf.c +++ b/postfix/src/global/rcpt_buf.c @@ -126,11 +126,11 @@ int rcpb_scan(ATTR_SCAN_MASTER_FN scan_fn, VSTREAM *fp, * 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); } diff --git a/postfix/src/global/rcpt_print.c b/postfix/src/global/rcpt_print.c index c98809cc4..60d9d30a3 100644 --- a/postfix/src/global/rcpt_print.c +++ b/postfix/src/global/rcpt_print.c @@ -17,7 +17,7 @@ /* 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 @@ -61,11 +61,11 @@ int rcpt_print(ATTR_PRINT_MASTER_FN print_fn, VSTREAM *fp, */ 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); } diff --git a/postfix/src/global/resolve_clnt.c b/postfix/src/global/resolve_clnt.c index 5b28772c1..40ef3b77c 100644 --- a/postfix/src/global/resolve_clnt.c +++ b/postfix/src/global/resolve_clnt.c @@ -231,17 +231,17 @@ void resolve_clnt(const char *class, const char *sender, 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", diff --git a/postfix/src/global/rewrite_clnt.c b/postfix/src/global/rewrite_clnt.c index 43b892a25..e11f81a4a 100644 --- a/postfix/src/global/rewrite_clnt.c +++ b/postfix/src/global/rewrite_clnt.c @@ -134,14 +134,14 @@ VSTRING *rewrite_clnt(const char *rule, const char *addr, VSTRING *result) 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", diff --git a/postfix/src/global/scache_clnt.c b/postfix/src/global/scache_clnt.c index 1ffebdc5c..536053234 100644 --- a/postfix/src/global/scache_clnt.c +++ b/postfix/src/global/scache_clnt.c @@ -113,20 +113,20 @@ static void scache_clnt_save_endp(SCACHE *scache, int endp_ttl, 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", @@ -175,13 +175,13 @@ static int scache_clnt_find_endp(SCACHE *scache, const char *endp_label, 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", @@ -194,7 +194,7 @@ static int scache_clnt_find_endp(SCACHE *scache, const char *endp_label, } 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), @@ -208,7 +208,7 @@ static int scache_clnt_find_endp(SCACHE *scache, const char *endp_label, } 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 @@ -263,15 +263,15 @@ static void scache_clnt_save_dest(SCACHE *scache, int dest_ttl, 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", @@ -318,14 +318,14 @@ static int scache_clnt_find_dest(SCACHE *scache, const char *dest_label, 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", @@ -338,7 +338,7 @@ static int scache_clnt_find_dest(SCACHE *scache, const char *dest_label, } 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), @@ -352,7 +352,7 @@ static int scache_clnt_find_dest(SCACHE *scache, const char *dest_label, } 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 diff --git a/postfix/src/global/trace.c b/postfix/src/global/trace.c index e6e86ee06..d451b4f45 100644 --- a/postfix/src/global/trace.c +++ b/postfix/src/global/trace.c @@ -121,11 +121,11 @@ int trace_append(int flags, const char *id, MSG_STATS *stats, 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; @@ -145,14 +145,14 @@ int trace_flush(int flags, const char *queue, const char *id, 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 { diff --git a/postfix/src/global/verify_clnt.c b/postfix/src/global/verify_clnt.c index e6de59bcc..131ca1cc7 100644 --- a/postfix/src/global/verify_clnt.c +++ b/postfix/src/global/verify_clnt.c @@ -112,14 +112,14 @@ int verify_clnt_query(const char *addr, int *addr_status, VSTRING *why) 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", @@ -154,13 +154,13 @@ int verify_clnt_update(const char *addr, int addr_status, const char *why) 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", diff --git a/postfix/src/local/forward.c b/postfix/src/local/forward.c index b30ab5e50..c63027ff9 100644 --- a/postfix/src/local/forward.c +++ b/postfix/src/local/forward.c @@ -138,7 +138,7 @@ static FORWARD_INFO *forward_open(DELIVER_REQUEST *request, const char *sender) 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); @@ -155,7 +155,7 @@ static FORWARD_INFO *forward_open(DELIVER_REQUEST *request, const char *sender) 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); /* @@ -305,7 +305,7 @@ static int forward_send(FORWARD_INFO *info, DELIVER_REQUEST *request, 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; diff --git a/postfix/src/milter/milter.c b/postfix/src/milter/milter.c index 014d9c4dc..5b067a532 100644 --- a/postfix/src/milter/milter.c +++ b/postfix/src/milter/milter.c @@ -716,8 +716,8 @@ int milter_send(MILTERS *milters, VSTREAM *stream) * 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); /* @@ -732,7 +732,7 @@ int milter_send(MILTERS *milters, VSTREAM *stream) */ 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)); @@ -779,8 +779,8 @@ MILTERS *milter_receive(VSTREAM *stream, int count) */ 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); @@ -809,7 +809,7 @@ MILTERS *milter_receive(VSTREAM *stream, int count) * 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); } diff --git a/postfix/src/milter/milter8.c b/postfix/src/milter/milter8.c index 02adb8393..c813d3c8b 100644 --- a/postfix/src/milter/milter8.c +++ b/postfix/src/milter/milter8.c @@ -2660,22 +2660,22 @@ static int milter8_send(MILTER *m, VSTREAM *stream) 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, @@ -2684,7 +2684,7 @@ static int milter8_send(MILTER *m, VSTREAM *stream) 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 @@ -2693,7 +2693,7 @@ static int milter8_send(MILTER *m, VSTREAM *stream) 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 @@ -2736,23 +2736,23 @@ MILTER *milter8_receive(VSTREAM *stream, MILTERS *parent) 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, @@ -2760,7 +2760,7 @@ MILTER *milter8_receive(VSTREAM *stream, MILTERS *parent) 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); @@ -2770,7 +2770,7 @@ MILTER *milter8_receive(VSTREAM *stream, MILTERS *parent) } 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) diff --git a/postfix/src/milter/milter_macros.c b/postfix/src/milter/milter_macros.c index 4e575aae0..95126b1ed 100644 --- a/postfix/src/milter/milter_macros.c +++ b/postfix/src/milter/milter_macros.c @@ -77,7 +77,7 @@ /* 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. @@ -85,7 +85,7 @@ /* 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 @@ -141,14 +141,14 @@ int milter_macros_print(ATTR_PRINT_MASTER_FN print_fn, VSTREAM *fp, * 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); } @@ -178,14 +178,14 @@ int milter_macros_scan(ATTR_SCAN_MASTER_FN scan_fn, VSTREAM *fp, * 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); /* diff --git a/postfix/src/oqmgr/qmgr_deliver.c b/postfix/src/oqmgr/qmgr_deliver.c index 69e52d615..cd6f35a1d 100644 --- a/postfix/src/oqmgr/qmgr_deliver.c +++ b/postfix/src/oqmgr/qmgr_deliver.c @@ -96,7 +96,7 @@ static int qmgr_deliver_initial_reply(VSTREAM *stream) 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); @@ -115,8 +115,8 @@ static int qmgr_deliver_final_reply(VSTREAM *stream, DSN_BUF *dsb) 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); @@ -169,38 +169,38 @@ static int qmgr_deliver_send_request(QMGR_ENTRY *entry, VSTREAM *stream) | (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); diff --git a/postfix/src/pickup/pickup.c b/postfix/src/pickup/pickup.c index 27a86543d..1b11fda28 100644 --- a/postfix/src/pickup/pickup.c +++ b/postfix/src/pickup/pickup.c @@ -396,8 +396,8 @@ static int pickup_copy(VSTREAM *qfile, VSTREAM *cleanup, */ 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)); @@ -471,10 +471,10 @@ static int pickup_file(PICKUP_INFO *info) 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 { diff --git a/postfix/src/postdrop/postdrop.c b/postfix/src/postdrop/postdrop.c index 437e8b3a4..14e320663 100644 --- a/postfix/src/postdrop/postdrop.c +++ b/postfix/src/postdrop/postdrop.c @@ -374,7 +374,7 @@ int main(int argc, char **argv) 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)); @@ -516,8 +516,8 @@ int main(int argc, char **argv) * 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); diff --git a/postfix/src/postscreen/postscreen_dnsbl.c b/postfix/src/postscreen/postscreen_dnsbl.c index 5aa7850e7..8d5167338 100644 --- a/postfix/src/postscreen/postscreen_dnsbl.c +++ b/postfix/src/postscreen/postscreen_dnsbl.c @@ -370,10 +370,10 @@ static void psc_dnsbl_receive(int event, void *context) 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 @@ -509,9 +509,9 @@ int psc_dnsbl_request(const char *client_addr, 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", diff --git a/postfix/src/postscreen/postscreen_send.c b/postfix/src/postscreen/postscreen_send.c index 7abb73426..9561629da 100644 --- a/postfix/src/postscreen/postscreen_send.c +++ b/postfix/src/postscreen/postscreen_send.c @@ -209,11 +209,12 @@ void psc_send_socket(PSC_STATE *state) (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", diff --git a/postfix/src/postscreen/postscreen_starttls.c b/postfix/src/postscreen/postscreen_starttls.c index d00f12443..a4b40085c 100644 --- a/postfix/src/postscreen/postscreen_starttls.c +++ b/postfix/src/postscreen/postscreen_starttls.c @@ -118,7 +118,7 @@ static void psc_starttls_finish(int event, void *context) */ 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) { /* @@ -226,10 +226,10 @@ void psc_starttls_open(PSC_STATE *smtp_state, EVENT_NOTIFY_FN resume_event) 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); diff --git a/postfix/src/proxymap/proxymap.c b/postfix/src/proxymap/proxymap.c index 11a1b2fb1..31ae405fb 100644 --- a/postfix/src/proxymap/proxymap.c +++ b/postfix/src/proxymap/proxymap.c @@ -361,9 +361,9 @@ static void proxymap_sequence_service(VSTREAM *client_stream) * 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)) { @@ -391,9 +391,9 @@ static void proxymap_sequence_service(VSTREAM *client_stream) * 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); } @@ -410,9 +410,9 @@ static void proxymap_lookup_service(VSTREAM *client_stream) * 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 = ""; @@ -435,8 +435,8 @@ static void proxymap_lookup_service(VSTREAM *client_stream) * 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); } @@ -459,10 +459,10 @@ static void proxymap_update_service(VSTREAM *client_stream) * 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) { @@ -490,7 +490,7 @@ static void proxymap_update_service(VSTREAM *client_stream) * 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); } @@ -510,9 +510,9 @@ static void proxymap_delete_service(VSTREAM *client_stream) * 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) { @@ -540,7 +540,7 @@ static void proxymap_delete_service(VSTREAM *client_stream) * 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); } @@ -557,8 +557,8 @@ static void proxymap_open_service(VSTREAM *client_stream) * 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; @@ -574,8 +574,8 @@ static void proxymap_open_service(VSTREAM *client_stream) * 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); } @@ -609,7 +609,7 @@ static void proxymap_service(VSTREAM *client_stream, char *unused_service, 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); @@ -624,7 +624,7 @@ static void proxymap_service(VSTREAM *client_stream, char *unused_service, } 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); } } diff --git a/postfix/src/qmgr/qmgr_deliver.c b/postfix/src/qmgr/qmgr_deliver.c index 6a7bdba91..2c7ca7f8d 100644 --- a/postfix/src/qmgr/qmgr_deliver.c +++ b/postfix/src/qmgr/qmgr_deliver.c @@ -101,7 +101,7 @@ static int qmgr_deliver_initial_reply(VSTREAM *stream) 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); @@ -120,8 +120,8 @@ static int qmgr_deliver_final_reply(VSTREAM *stream, DSN_BUF *dsb) 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); @@ -174,38 +174,38 @@ static int qmgr_deliver_send_request(QMGR_ENTRY *entry, VSTREAM *stream) | (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); diff --git a/postfix/src/qmqpd/qmqpd.c b/postfix/src/qmqpd/qmqpd.c index 7e01485cc..a1b4ba06c 100644 --- a/postfix/src/qmqpd/qmqpd.c +++ b/postfix/src/qmqpd/qmqpd.c @@ -253,7 +253,7 @@ static void qmqpd_open_file(QMQPD_STATE *state) 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); diff --git a/postfix/src/scache/scache.c b/postfix/src/scache/scache.c index 94a967f11..4af9a6261 100644 --- a/postfix/src/scache/scache.c +++ b/postfix/src/scache/scache.c @@ -220,20 +220,20 @@ static void scache_save_endp_service(VSTREAM *client_stream) 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), @@ -243,7 +243,7 @@ static void scache_save_endp_service(VSTREAM *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 { @@ -251,7 +251,7 @@ static void scache_save_endp_service(VSTREAM *client_stream) 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) @@ -271,37 +271,37 @@ static void scache_find_endp_service(VSTREAM *client_stream) 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 ) @@ -323,15 +323,15 @@ static void scache_save_dest_service(VSTREAM *client_stream) 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 { @@ -340,7 +340,7 @@ static void scache_save_dest_service(VSTREAM *client_stream) 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) @@ -360,41 +360,41 @@ static void scache_find_dest_service(VSTREAM *client_stream) 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 ) @@ -433,7 +433,7 @@ static void scache_service(VSTREAM *client_stream, char *unused_service, 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); @@ -447,7 +447,7 @@ static void scache_service(VSTREAM *client_stream, char *unused_service, 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); } } diff --git a/postfix/src/smtpd/smtpd.c b/postfix/src/smtpd/smtpd.c index 0444866a6..935a14855 100644 --- a/postfix/src/smtpd/smtpd.c +++ b/postfix/src/smtpd/smtpd.c @@ -1924,7 +1924,7 @@ static int mail_open_stream(SMTPD_STATE *state) 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); diff --git a/postfix/src/smtpd/smtpd_check.c b/postfix/src/smtpd/smtpd_check.c index 8e61bfca2..0c34982f7 100644 --- a/postfix/src/smtpd/smtpd_check.c +++ b/postfix/src/smtpd/smtpd_check.c @@ -3867,65 +3867,65 @@ static int check_policy_service(SMTPD_STATE *state, const char *server, 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; diff --git a/postfix/src/tls/tls_mgr.c b/postfix/src/tls/tls_mgr.c index b9fe04270..60fc0e705 100644 --- a/postfix/src/tls/tls_mgr.c +++ b/postfix/src/tls/tls_mgr.c @@ -188,12 +188,12 @@ int tls_mgr_seed(VSTRING *buf, int len) */ 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); @@ -216,13 +216,13 @@ int tls_mgr_policy(const char *cache_type, int *cachable, int *timeout) */ 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); @@ -246,13 +246,13 @@ int tls_mgr_lookup(const char *cache_type, const char *cache_id, */ 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); @@ -276,13 +276,13 @@ int tls_mgr_update(const char *cache_type, const char *cache_id, */ 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); @@ -305,12 +305,12 @@ int tls_mgr_delete(const char *cache_type, const char *cache_id) */ 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); @@ -344,12 +344,12 @@ static TLS_TICKET_KEY *request_scache_key(unsigned char *keyname) */ 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)) diff --git a/postfix/src/tls/tls_proxy_clnt.c b/postfix/src/tls/tls_proxy_clnt.c index 8b4e0d069..70c0096dc 100644 --- a/postfix/src/tls/tls_proxy_clnt.c +++ b/postfix/src/tls/tls_proxy_clnt.c @@ -155,9 +155,9 @@ VSTREAM *tls_proxy_open(const char *service, int flags, 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", @@ -174,7 +174,7 @@ VSTREAM *tls_proxy_open(const char *service, int flags, * 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) { /* @@ -216,7 +216,7 @@ TLS_SESS_STATE *tls_proxy_context_receive(VSTREAM *proxy_stream) 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); diff --git a/postfix/src/tls/tls_proxy_print.c b/postfix/src/tls/tls_proxy_print.c index a850cb1d4..e30e8be88 100644 --- a/postfix/src/tls/tls_proxy_print.c +++ b/postfix/src/tls/tls_proxy_print.c @@ -17,7 +17,7 @@ /* 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 @@ -61,24 +61,24 @@ int tls_proxy_context_print(ATTR_PRINT_MASTER_FN print_fn, VSTREAM *fp, #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); } diff --git a/postfix/src/tls/tls_proxy_scan.c b/postfix/src/tls/tls_proxy_scan.c index 428f24a57..29a0cd9f9 100644 --- a/postfix/src/tls/tls_proxy_scan.c +++ b/postfix/src/tls/tls_proxy_scan.c @@ -17,7 +17,7 @@ /* 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 @@ -69,18 +69,18 @@ int tls_proxy_context_scan(ATTR_SCAN_MASTER_FN scan_fn, VSTREAM *fp, */ 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); diff --git a/postfix/src/tlsmgr/tlsmgr.c b/postfix/src/tlsmgr/tlsmgr.c index 601855507..7072c0c6b 100644 --- a/postfix/src/tlsmgr/tlsmgr.c +++ b/postfix/src/tlsmgr/tlsmgr.c @@ -574,7 +574,7 @@ static int tlsmgr_request_receive(VSTREAM *client_stream, VSTRING *request) 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); } @@ -628,8 +628,8 @@ static void tlsmgr_service(VSTREAM *client_stream, char *unused_service, */ 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) @@ -651,9 +651,9 @@ static void tlsmgr_service(VSTREAM *client_stream, char *unused_service, } } 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); } @@ -662,9 +662,9 @@ static void tlsmgr_service(VSTREAM *client_stream, char *unused_service, */ 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) @@ -680,7 +680,7 @@ static void tlsmgr_service(VSTREAM *client_stream, char *unused_service, } } attr_print(client_stream, ATTR_FLAG_NONE, - ATTR_TYPE_INT, MAIL_ATTR_STATUS, status, + SEND_ATTR_INT(MAIL_ATTR_STATUS, status), ATTR_TYPE_END); } @@ -689,8 +689,8 @@ static void tlsmgr_service(VSTREAM *client_stream, char *unused_service, */ 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) @@ -705,7 +705,7 @@ static void tlsmgr_service(VSTREAM *client_stream, char *unused_service, } } attr_print(client_stream, ATTR_FLAG_NONE, - ATTR_TYPE_INT, MAIL_ATTR_STATUS, status, + SEND_ATTR_INT(MAIL_ATTR_STATUS, status), ATTR_TYPE_END); } @@ -714,7 +714,7 @@ static void tlsmgr_service(VSTREAM *client_stream, char *unused_service, */ 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", @@ -728,9 +728,9 @@ static void tlsmgr_service(VSTREAM *client_stream, char *unused_service, } } 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); } @@ -739,7 +739,7 @@ static void tlsmgr_service(VSTREAM *client_stream, char *unused_service, */ 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) { @@ -754,9 +754,9 @@ static void tlsmgr_service(VSTREAM *client_stream, char *unused_service, } } 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); } @@ -768,7 +768,7 @@ static void tlsmgr_service(VSTREAM *client_stream, char *unused_service, 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) @@ -783,9 +783,9 @@ static void tlsmgr_service(VSTREAM *client_stream, char *unused_service, } } 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); } @@ -813,7 +813,7 @@ static void tlsmgr_service(VSTREAM *client_stream, char *unused_service, */ 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); diff --git a/postfix/src/tlsproxy/tlsproxy.c b/postfix/src/tlsproxy/tlsproxy.c index 6fdcf46c7..1bd7fc398 100644 --- a/postfix/src/tlsproxy/tlsproxy.c +++ b/postfix/src/tlsproxy/tlsproxy.c @@ -471,8 +471,9 @@ static void tlsp_strategy(TLSP_STATE *state) } 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); @@ -809,10 +810,10 @@ static void tlsp_get_request_event(int event, void *context) */ 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); @@ -827,7 +828,7 @@ static void tlsp_get_request_event(int event, void *context) 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) { diff --git a/postfix/src/trivial-rewrite/resolve.c b/postfix/src/trivial-rewrite/resolve.c index 45b25deae..8ffb196ef 100644 --- a/postfix/src/trivial-rewrite/resolve.c +++ b/postfix/src/trivial-rewrite/resolve.c @@ -140,7 +140,7 @@ static MAPS *relocated_maps; /* resolve_class - determine domain address class */ -int resolve_class(const char *domain) +int resolve_class(const char *domain) { int ret; @@ -751,8 +751,8 @@ int resolve_proto(RES_CONTEXT *context, VSTREAM *stream) 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); @@ -765,11 +765,11 @@ int resolve_proto(RES_CONTEXT *context, VSTREAM *stream) 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) { diff --git a/postfix/src/trivial-rewrite/rewrite.c b/postfix/src/trivial-rewrite/rewrite.c index de8323958..ec01f9e79 100644 --- a/postfix/src/trivial-rewrite/rewrite.c +++ b/postfix/src/trivial-rewrite/rewrite.c @@ -244,8 +244,8 @@ int rewrite_proto(VSTREAM *stream) 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); @@ -281,8 +281,8 @@ int rewrite_proto(VSTREAM *stream) 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) { diff --git a/postfix/src/trivial-rewrite/trivial-rewrite.c b/postfix/src/trivial-rewrite/trivial-rewrite.c index bbb6757ed..d167a9a7c 100644 --- a/postfix/src/trivial-rewrite/trivial-rewrite.c +++ b/postfix/src/trivial-rewrite/trivial-rewrite.c @@ -479,7 +479,7 @@ static void rewrite_service(VSTREAM *stream, char *unused_service, char **argv) * 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); diff --git a/postfix/src/util/attr.h b/postfix/src/util/attr.h index cdaeb79a9..b424611ce 100644 --- a/postfix/src/util/attr.h +++ b/postfix/src/util/attr.h @@ -36,6 +36,124 @@ #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. */ @@ -50,7 +168,7 @@ /* * 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 *); diff --git a/postfix/src/verify/verify.c b/postfix/src/verify/verify.c index 520566d4f..d7642c9fc 100644 --- a/postfix/src/verify/verify.c +++ b/postfix/src/verify/verify.c @@ -359,9 +359,9 @@ static void verify_update_service(VSTREAM *client_stream) 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), ":", "_"); @@ -369,7 +369,7 @@ static void verify_update_service(VSTREAM *client_stream) 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 { @@ -391,7 +391,7 @@ static void verify_update_service(VSTREAM *client_stream) 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); } } @@ -427,7 +427,7 @@ static void verify_query_service(VSTREAM *client_stream) 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); @@ -478,9 +478,9 @@ static void verify_query_service(VSTREAM *client_stream) * 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); /* @@ -572,7 +572,7 @@ static void verify_service(VSTREAM *client_stream, char *unused_service, */ 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); @@ -581,7 +581,7 @@ static void verify_service(VSTREAM *client_stream, char *unused_service, } 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); } }