1/* $NetBSD: defer.c,v 1.3 2022/10/08 16:12:45 christos Exp $ */ 2 3/*++ 4/* NAME 5/* defer 3 6/* SUMMARY 7/* defer service client interface 8/* SYNOPSIS 9/* #include <defer.h> 10/* 11/* int defer_append(flags, id, stats, rcpt, relay, dsn) 12/* int flags; 13/* const char *id; 14/* MSG_STATS *stats; 15/* RECIPIENT *rcpt; 16/* const char *relay; 17/* DSN *dsn; 18/* 19/* int defer_flush(flags, queue, id, encoding, smtputf8, sender, 20/* dsn_envid, dsn_ret) 21/* int flags; 22/* const char *queue; 23/* const char *id; 24/* const char *encoding; 25/* int smtputf8; 26/* const char *sender; 27/* const char *dsn_envid; 28/* int dsn_ret; 29/* 30/* int defer_warn(flags, queue, id, encoding, smtputf8, sender, 31 dsn_envid, dsn_ret) 32/* int flags; 33/* const char *queue; 34/* const char *id; 35/* const char *encoding; 36/* int smtputf8; 37/* const char *sender; 38/* const char *dsn_envid; 39/* int dsn_ret; 40/* 41/* int defer_one(flags, queue, id, encoding, smtputf8, sender, 42/* dsn_envid, ret, stats, recipient, relay, dsn) 43/* int flags; 44/* const char *queue; 45/* const char *id; 46/* const char *encoding; 47/* int smtputf8; 48/* const char *sender; 49/* const char *dsn_envid; 50/* int dsn_ret; 51/* MSG_STATS *stats; 52/* RECIPIENT *rcpt; 53/* const char *relay; 54/* DSN *dsn; 55/* INTERNAL API 56/* int defer_append_intern(flags, id, stats, rcpt, relay, dsn) 57/* int flags; 58/* const char *id; 59/* MSG_STATS *stats; 60/* RECIPIENT *rcpt; 61/* const char *relay; 62/* DESCRIPTION 63/* This module implements a client interface to the defer service, 64/* which maintains a per-message logfile with status records for 65/* each recipient whose delivery is deferred, and the dsn_text why. 66/* 67/* defer_append() appends a record to the per-message defer log, 68/* with the dsn_text for delayed delivery to the named rcpt, 69/* updates the address verification service, or updates a message 70/* delivery record on request by the sender. The flags argument 71/* determines the action. 72/* The result is a convenient non-zero value. 73/* When the fast flush cache is enabled, the fast flush server is 74/* notified of deferred mail. 75/* 76/* defer_flush() bounces the specified message to the specified 77/* sender, including the defer log that was built with defer_append(). 78/* defer_flush() requests that the deferred recipients are deleted 79/* from the original queue file; the defer logfile is deleted after 80/* successful completion. 81/* The result is zero in case of success, non-zero otherwise. 82/* 83/* defer_warn() sends a warning message that the mail in 84/* question has been deferred. The defer log is not deleted, 85/* and no recipients are deleted from the original queue file. 86/* 87/* defer_one() implements dsn_filter(3) compatibility for the 88/* bounce_one() routine. 89/* 90/* defer_append_intern() is for use after the DSN filter. 91/* 92/* Arguments: 93/* .IP flags 94/* The bit-wise OR of zero or more of the following (specify 95/* BOUNCE_FLAG_NONE to explicitly request not special processing): 96/* .RS 97/* .IP BOUNCE_FLAG_CLEAN 98/* Delete the defer log in case of an error (as in: pretend 99/* that we never even tried to defer this message). 100/* .IP BOUNCE_FLAG_DELRCPT 101/* When specified with a flush request, request that 102/* recipients be deleted from the queue file. 103/* 104/* Note: the bounce daemon ignores this request when the 105/* recipient queue file offset is <= 0. 106/* .IP DEL_REQ_FLAG_MTA_VRFY 107/* The message is an MTA-requested address verification probe. 108/* Update the address verification database instead of deferring 109/* mail. 110/* .IP DEL_REQ_FLAG_USR_VRFY 111/* The message is a user-requested address expansion probe. 112/* Update the message delivery record instead of deferring 113/* mail. 114/* .IP DEL_REQ_FLAG_RECORD 115/* This is a normal message with logged delivery. Update the 116/* message delivery record and defer mail delivery. 117/* .RE 118/* .IP queue 119/* The message queue name of the original message file. 120/* .IP id 121/* The queue id of the original message file. 122/* .IP stats 123/* Time stamps from different message delivery stages 124/* and session reuse count. 125/* .IP rcpt 126/* Recipient information. See recipient_list(3). 127/* .IP relay 128/* Host we could not talk to. 129/* .IP dsn 130/* Delivery status. See dsn(3). The specified action is ignored. 131/* .IP encoding 132/* The body content encoding: MAIL_ATTR_ENC_{7BIT,8BIT,NONE}. 133/* .IP smtputf8 134/* The level of SMTPUTF8 support (to be defined). 135/* .IP sender 136/* The sender envelope address. 137/* .IP dsn_envid 138/* Optional DSN envelope ID. 139/* .IP dsn_ret 140/* Optional DSN return full/headers option. 141/* .PP 142/* For convenience, these functions always return a non-zero result. 143/* DIAGNOSTICS 144/* Warnings: problems connecting to the defer service. 145/* Fatal: out of memory. 146/* BUGS 147/* Should be replaced by routines with an attribute-value based 148/* interface instead of an interface that uses a rigid argument list. 149/* LICENSE 150/* .ad 151/* .fi 152/* The Secure Mailer license must be distributed with this software. 153/* AUTHOR(S) 154/* Wietse Venema 155/* IBM T.J. Watson Research 156/* P.O. Box 704 157/* Yorktown Heights, NY 10598, USA 158/* 159/* Wietse Venema 160/* Google, Inc. 161/* 111 8th Avenue 162/* New York, NY 10011, USA 163/*--*/ 164 165/* System library. */ 166 167#include <sys_defs.h> 168#include <string.h> 169 170/* Utility library. */ 171 172#include <msg.h> 173#include <vstring.h> 174 175/* Global library. */ 176 177#define DSN_INTERN 178#include <mail_params.h> 179#include <mail_queue.h> 180#include <mail_proto.h> 181#include <flush_clnt.h> 182#include <verify.h> 183#include <dsn_util.h> 184#include <rcpt_print.h> 185#include <dsn_print.h> 186#include <log_adhoc.h> 187#include <trace.h> 188#include <defer.h> 189 190#define STR(x) vstring_str(x) 191 192/* defer_append - defer message delivery */ 193 194int defer_append(int flags, const char *id, MSG_STATS *stats, 195 RECIPIENT *rcpt, const char *relay, 196 DSN *dsn) 197{ 198 DSN my_dsn = *dsn; 199 DSN *dsn_res; 200 201 /* 202 * Sanity check. 203 */ 204 if (my_dsn.status[0] != '4' || !dsn_valid(my_dsn.status)) { 205 msg_warn("defer_append: ignoring dsn code \"%s\"", my_dsn.status); 206 my_dsn.status = "4.0.0"; 207 } 208 209 /* 210 * DSN filter (Postfix 3.0). 211 */ 212 if (delivery_status_filter != 0 213 && (dsn_res = dsn_filter_lookup(delivery_status_filter, &my_dsn)) != 0) { 214 if (dsn_res->status[0] == '5') 215 return (bounce_append_intern(flags, id, stats, rcpt, relay, dsn_res)); 216 my_dsn = *dsn_res; 217 } 218 return (defer_append_intern(flags, id, stats, rcpt, relay, &my_dsn)); 219} 220 221/* defer_append_intern - defer message delivery */ 222 223int defer_append_intern(int flags, const char *id, MSG_STATS *stats, 224 RECIPIENT *rcpt, const char *relay, 225 DSN *dsn) 226{ 227 const char *rcpt_domain; 228 DSN my_dsn = *dsn; 229 int status; 230 231 /* 232 * MTA-requested address verification information is stored in the verify 233 * service database. 234 */ 235 if (flags & DEL_REQ_FLAG_MTA_VRFY) { 236 my_dsn.action = "undeliverable"; 237 status = verify_append(id, stats, rcpt, relay, &my_dsn, 238 DEL_RCPT_STAT_DEFER); 239 return (status); 240 } 241 242 /* 243 * User-requested address verification information is logged and mailed 244 * to the requesting user. 245 */ 246 if (flags & DEL_REQ_FLAG_USR_VRFY) { 247 my_dsn.action = "undeliverable"; 248 status = trace_append(flags, id, stats, rcpt, relay, &my_dsn); 249 return (status); 250 } 251 252 /* 253 * Normal mail delivery. May also send a delivery record to the user. 254 * 255 * XXX DSN We write all deferred recipients to the defer logfile regardless 256 * of DSN NOTIFY options, because those options don't apply to mailq(1) 257 * reports or to postmaster notifications. 258 */ 259 else { 260 261 /* 262 * Supply default action. 263 */ 264 my_dsn.action = "delayed"; 265 266 if (mail_command_client(MAIL_CLASS_PRIVATE, var_defer_service, 267 MAIL_ATTR_PROTO_BOUNCE, 268 SEND_ATTR_INT(MAIL_ATTR_NREQ, BOUNCE_CMD_APPEND), 269 SEND_ATTR_INT(MAIL_ATTR_FLAGS, flags), 270 SEND_ATTR_STR(MAIL_ATTR_QUEUEID, id), 271 SEND_ATTR_FUNC(rcpt_print, (const void *) rcpt), 272 SEND_ATTR_FUNC(dsn_print, (const void *) &my_dsn), 273 ATTR_TYPE_END) != 0) 274 msg_warn("%s: %s service failure", id, var_defer_service); 275 log_adhoc(id, stats, rcpt, relay, &my_dsn, "deferred"); 276 277 /* 278 * Traced delivery. 279 */ 280 if (flags & DEL_REQ_FLAG_RECORD) 281 if (trace_append(flags, id, stats, rcpt, relay, &my_dsn) != 0) 282 msg_warn("%s: %s service failure", id, var_trace_service); 283 284 /* 285 * Notify the fast flush service. XXX Should not this belong in the 286 * bounce/defer daemon? Well, doing it here is more robust. 287 */ 288 if ((rcpt_domain = strrchr(rcpt->address, '@')) != 0 289 && *++rcpt_domain != 0) 290 switch (flush_add(rcpt_domain, id)) { 291 case FLUSH_STAT_OK: 292 case FLUSH_STAT_DENY: 293 break; 294 default: 295 msg_warn("%s: %s service failure", id, var_flush_service); 296 break; 297 } 298 return (-1); 299 } 300} 301 302/* defer_flush - flush the defer log and deliver to the sender */ 303 304int defer_flush(int flags, const char *queue, const char *id, 305 const char *encoding, int smtputf8, 306 const char *sender, const char *dsn_envid, 307 int dsn_ret) 308{ 309 flags |= BOUNCE_FLAG_DELRCPT; 310 311 if (mail_command_client(MAIL_CLASS_PRIVATE, var_defer_service, 312 MAIL_ATTR_PROTO_BOUNCE, 313 SEND_ATTR_INT(MAIL_ATTR_NREQ, BOUNCE_CMD_FLUSH), 314 SEND_ATTR_INT(MAIL_ATTR_FLAGS, flags), 315 SEND_ATTR_STR(MAIL_ATTR_QUEUE, queue), 316 SEND_ATTR_STR(MAIL_ATTR_QUEUEID, id), 317 SEND_ATTR_STR(MAIL_ATTR_ENCODING, encoding), 318 SEND_ATTR_INT(MAIL_ATTR_SMTPUTF8, smtputf8), 319 SEND_ATTR_STR(MAIL_ATTR_SENDER, sender), 320 SEND_ATTR_STR(MAIL_ATTR_DSN_ENVID, dsn_envid), 321 SEND_ATTR_INT(MAIL_ATTR_DSN_RET, dsn_ret), 322 ATTR_TYPE_END) == 0) { 323 return (0); 324 } else { 325 return (-1); 326 } 327} 328 329/* defer_warn - send a copy of the defer log to the sender as a warning bounce 330 * do not flush the log */ 331 332int defer_warn(int flags, const char *queue, const char *id, 333 const char *encoding, int smtputf8, 334 const char *sender, const char *envid, int dsn_ret) 335{ 336 if (mail_command_client(MAIL_CLASS_PRIVATE, var_defer_service, 337 MAIL_ATTR_PROTO_BOUNCE, 338 SEND_ATTR_INT(MAIL_ATTR_NREQ, BOUNCE_CMD_WARN), 339 SEND_ATTR_INT(MAIL_ATTR_FLAGS, flags), 340 SEND_ATTR_STR(MAIL_ATTR_QUEUE, queue), 341 SEND_ATTR_STR(MAIL_ATTR_QUEUEID, id), 342 SEND_ATTR_STR(MAIL_ATTR_ENCODING, encoding), 343 SEND_ATTR_INT(MAIL_ATTR_SMTPUTF8, smtputf8), 344 SEND_ATTR_STR(MAIL_ATTR_SENDER, sender), 345 SEND_ATTR_STR(MAIL_ATTR_DSN_ENVID, envid), 346 SEND_ATTR_INT(MAIL_ATTR_DSN_RET, dsn_ret), 347 ATTR_TYPE_END) == 0) { 348 return (0); 349 } else { 350 return (-1); 351 } 352} 353 354/* defer_one - defer mail for one recipient */ 355 356int defer_one(int flags, const char *queue, const char *id, 357 const char *encoding, int smtputf8, 358 const char *sender, const char *dsn_envid, 359 int dsn_ret, MSG_STATS *stats, RECIPIENT *rcpt, 360 const char *relay, DSN *dsn) 361{ 362 DSN my_dsn = *dsn; 363 DSN *dsn_res; 364 365 /* 366 * Sanity check. 367 */ 368 if (my_dsn.status[0] != '4' || !dsn_valid(my_dsn.status)) { 369 msg_warn("defer_one: ignoring dsn code \"%s\"", my_dsn.status); 370 my_dsn.status = "4.0.0"; 371 } 372 373 /* 374 * DSN filter (Postfix 3.0). 375 */ 376 if (delivery_status_filter != 0 377 && (dsn_res = dsn_filter_lookup(delivery_status_filter, &my_dsn)) != 0) { 378 if (dsn_res->status[0] == '5') 379 return (bounce_one_intern(flags, queue, id, encoding, smtputf8, 380 sender, dsn_envid, dsn_ret, stats, 381 rcpt, relay, dsn_res)); 382 my_dsn = *dsn_res; 383 } 384 return (defer_append_intern(flags, id, stats, rcpt, relay, &my_dsn)); 385} 386