Mercurial > masqmail

comparison src/deliver.c @ 0:08114f7dcc23 0.2.21

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
this is masqmail-0.2.21 from oliver kurth
author meillo@marmaro.de
date Fri, 26 Sep 2008 17:05:23 +0200
parents
children 26e34ae9a3e3
comparison
equal deleted inserted replaced
-1:000000000000 0:08114f7dcc23
1 /* MasqMail
2 Copyright (C) 1999-2002 Oliver Kurth
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17 */
18
19 #include "masqmail.h"
20 #include "smtp_out.h"
21 #include <fnmatch.h>
22 #include <sysexits.h>
23 #include <netdb.h>
24
25 /* collect failed/defered rcpts for failure/warning messages */
26 /* returns TRUE if either there are no failures or a
27 failure message has been successfully sent */
28 gboolean delivery_failures(message *msg, GList *rcpt_list, gchar *err_fmt, ...)
29 {
30 gboolean ok_fail = TRUE, ok_warn = TRUE;
31 time_t now = time(NULL);
32
33 GList *failed_list = NULL, *defered_list = NULL, *rcpt_node;
34 va_list args;
35 va_start(args, err_fmt);
36
37 foreach(rcpt_list, rcpt_node){
38 address *rcpt = (address *)(rcpt_node->data);
39
40 if(addr_is_defered(rcpt)){
41 if((now - msg->received_time) >= conf.max_defer_time){
42 addr_mark_failed(rcpt);
43 }else
44 defered_list = g_list_prepend(defered_list, rcpt);
45 }
46 if(addr_is_failed(rcpt))
47 failed_list = g_list_prepend(failed_list, rcpt);
48 }
49 if(failed_list != NULL){
50 ok_fail = fail_msg(msg, conf.errmsg_file, failed_list, err_fmt, args);
51 g_list_free(failed_list);
52 }
53 if(defered_list != NULL){
54 ok_warn = warn_msg(msg, conf.warnmsg_file, defered_list, err_fmt, args);
55 g_list_free(defered_list);
56 }
57 va_end(args);
58 return ok_fail && ok_warn;
59 }
60
61 static gint _g_list_strcasecmp(gconstpointer a, gconstpointer b)
62 {
63 return (gint)strcasecmp(a, b);
64 }
65
66 gboolean deliver_local(msg_out *msgout)
67 {
68 message *msg = msgout->msg;
69 GList *rcpt_list = msgout->rcpt_list;
70 GList *rcpt_node;
71 gboolean ok = TRUE, flag = FALSE, ok_fail = FALSE;
72
73 DEBUG(5) debugf("deliver_local entered\n");
74
75 flag = (msg->data_list == NULL);
76 if(flag){
77 if(!(ok = spool_read_data(msg))){
78 logwrite(LOG_ALERT, "could not open data spool file for %s\n",
79 msg->uid);
80 }
81 }
82 if(!ok) return FALSE;
83
84 ok = FALSE;
85 for(rcpt_node = g_list_first(rcpt_list);
86 rcpt_node;
87 rcpt_node = g_list_next(rcpt_node)){
88 GList *hdr_list;
89 address *rcpt = (address *)(rcpt_node->data);
90 address *env_addr = addr_find_ancestor(rcpt);
91 address *ret_path = msg->return_path;
92 header *retpath_hdr, *envto_hdr;
93
94 /* we need a private copy of the hdr list because we add headers here
95 that belong to the rcpt only.
96 g_list_copy copies only the nodes, so it is safe to
97 g_list_free it
98 */
99 hdr_list = g_list_copy(msg->hdr_list);
100 retpath_hdr = create_header(HEAD_ENVELOPE_TO,
101 "Envelope-to: %s\n", addr_string(env_addr));
102 envto_hdr = create_header(HEAD_RETURN_PATH,
103 "Return-path: %s\n", addr_string(ret_path));
104
105 hdr_list = g_list_prepend(hdr_list, envto_hdr);
106 hdr_list = g_list_prepend(hdr_list, retpath_hdr);
107
108 if(rcpt->local_part[0] == '|'){
109 DEBUG(1) debugf("attempting to deliver %s with pipe\n", msg->uid);
110 if(pipe_out(msg, hdr_list, rcpt, &(rcpt->local_part[1]),
111 (conf.pipe_fromline ? MSGSTR_FROMLINE : 0) |
112 (conf.pipe_fromhack ? MSGSTR_FROMHACK : 0))){
113 logwrite(LOG_NOTICE, "%s => %s <%s@%s> with pipe\n",
114 msg->uid, rcpt->local_part,
115 env_addr->local_part, env_addr->domain
116 );
117 addr_mark_delivered(rcpt);
118 ok = TRUE;
119 }else{
120 if((errno != (1024 + EX_TEMPFAIL)) && (errno != EAGAIN)){
121 addr_mark_failed(rcpt);
122 }else{
123 addr_mark_defered(rcpt); /* has no effect yet,
124 except that mail remains in spool */
125 }
126 }
127 }else{
128 /* figure out which mailbox type should be used for this user */
129 gchar *user = rcpt->local_part;
130 gchar *mbox_type = conf.mbox_default;
131
132 if(g_list_find_custom(conf.mbox_users, user, _g_list_strcasecmp) != NULL)
133 mbox_type = "mbox";
134 else if(g_list_find_custom(conf.mda_users, user, _g_list_strcasecmp) != NULL)
135 mbox_type = "mda";
136 else if(g_list_find_custom(conf.maildir_users, user, _g_list_strcasecmp) != NULL)
137 mbox_type = "maildir";
138
139 if(strcmp(mbox_type, "mbox") == 0){
140 DEBUG(1) debugf("attempting to deliver %s with mbox\n", msg->uid);
141 if(append_file(msg, hdr_list, rcpt->local_part)){
142 if(env_addr != rcpt){
143 logwrite(LOG_NOTICE, "%s => %s@%s <%s@%s> with mbox\n",
144 msg->uid, rcpt->local_part, rcpt->domain,
145 env_addr->local_part, env_addr->domain
146 );
147 }else{
148 logwrite(LOG_NOTICE, "%s => <%s@%s> with mbox\n",
149 msg->uid, rcpt->local_part, rcpt->domain);
150 }
151 addr_mark_delivered(rcpt);
152 ok = TRUE;
153 }else{
154 if(errno != EAGAIN){ /* prevents 'Resource temporarily unavailable (11)' */
155 addr_mark_failed(rcpt);
156 }else{
157 addr_mark_defered(rcpt);
158 }
159 }
160
161 }else if(strcmp(mbox_type, "mda") == 0){
162 if(conf.mda){
163 gchar *cmd = g_malloc(256);
164 GList *var_table = var_table_rcpt(var_table_msg(NULL, msg), rcpt);
165
166 DEBUG(1) debugf("attempting to deliver %s with mda\n", msg->uid);
167
168 if(expand(var_table, conf.mda, cmd, 256)){
169
170 if(pipe_out(msg, hdr_list, rcpt, cmd,
171 (conf.mda_fromline ? MSGSTR_FROMLINE : 0) |
172 (conf.mda_fromhack ? MSGSTR_FROMHACK : 0))){
173 logwrite(LOG_NOTICE, "%s => %s@%s with mda (cmd = '%s')\n",
174 msg->uid, rcpt->local_part, rcpt->domain, cmd
175 );
176 addr_mark_delivered(rcpt);
177 ok = TRUE;
178 }else{
179 if((errno != (1024 + EX_TEMPFAIL)) && (errno != EAGAIN)){
180 addr_mark_failed(rcpt);
181 }else{
182 addr_mark_defered(rcpt); /* has no effect yet,
183 except that mail remains in spool */
184 }
185 }
186 }else
187 logwrite(LOG_ALERT, "could not expand string %s\n", conf.mda);
188
189 destroy_table(var_table);
190 }else
191 logwrite(LOG_ALERT, "mbox type is mda, but no mda command given in configuration\n");
192
193 #ifdef ENABLE_MAILDIR
194 }else if(strcmp(mbox_type, "maildir") == 0){
195 DEBUG(1) debugf("attempting to deliver %s with maildir\n", msg->uid);
196 if(maildir_out(msg, hdr_list, rcpt->local_part, 0)){
197 if(env_addr != rcpt){
198 logwrite(LOG_NOTICE, "%s => %s@%s <%s@%s> with local\n",
199 msg->uid, rcpt->local_part, rcpt->domain,
200 env_addr->local_part, env_addr->domain
201 );
202 }else{
203 logwrite(LOG_NOTICE, "%s => <%s@%s> with maildir\n",
204 msg->uid, rcpt->local_part, rcpt->domain);
205 }
206 addr_mark_delivered(rcpt);
207 ok = TRUE;
208 }else
209 addr_mark_failed(rcpt);
210 #endif
211 }else
212 logwrite(LOG_ALERT, "unknown mbox type '%s'\n", mbox_type);
213 }
214
215 destroy_header(retpath_hdr);
216 destroy_header(envto_hdr);
217
218 g_list_free(hdr_list);
219 }
220 ok_fail = delivery_failures(msg, rcpt_list, "%s (%d)", ext_strerror(errno), errno);
221
222 if(flag) msg_free_data(msg);
223 if(ok || ok_fail) deliver_finish(msgout);
224
225 return ok;
226 }
227
228 /* make a list of rcpt's of a message that are local
229 return a new copy of the list
230 */
231 void msg_rcptlist_local(GList *rcpt_list, GList **p_local_list, GList **p_nonlocal_list)
232 {
233 GList *rcpt_node;
234
235 foreach(rcpt_list, rcpt_node){
236 address *rcpt = (address *)(rcpt_node->data);
237 GList *dom_node;
238
239 DEBUG(5) debugf("checking address %s\n", rcpt->address);
240
241 /* search for local host list: */
242 foreach(conf.local_hosts, dom_node){
243 if(strcasecmp(dom_node->data, rcpt->domain) == 0){
244 *p_local_list = g_list_append(*p_local_list, rcpt);
245 DEBUG(5) debugf("<%s@%s> is local\n", rcpt->local_part, rcpt->domain);
246 break;
247 }else{
248 *p_nonlocal_list = g_list_append(*p_nonlocal_list, rcpt);
249 }
250 }
251 }
252 }
253
254 gboolean deliver_msglist_host_pipe(connect_route *route, GList *msgout_list, gchar *host, GList *res_list)
255 {
256 gboolean ok = TRUE;
257 GList *msgout_node;
258
259 DEBUG(5) debugf("deliver_msglist_host_pipe entered\n");
260
261 if(route->pipe == NULL){
262 logwrite(LOG_ALERT, "no pipe command given for route (protocol is pipe!)\n");
263 return FALSE;
264 }
265
266 foreach(msgout_list, msgout_node){
267 msg_out *msgout = (msg_out *)(msgout_node->data);
268 gboolean flag, ok_msg = TRUE, ok_fail = FALSE;
269 message *msg = msgout->msg;
270 GList *rcpt_node, *rcpt_list = msgout->rcpt_list;
271
272 DEBUG(1) debugf("attempting to deliver %s with pipe\n", msg->uid);
273
274 flag = (msg->data_list == NULL);
275 if(flag){
276 if(!(ok_msg = spool_read_data(msg))){
277 logwrite(LOG_ALERT, "could not open data spool file for %s\n",
278 msg->uid);
279 }
280 }
281 if(!ok_msg) continue;
282
283 ok = FALSE;
284 foreach(rcpt_list, rcpt_node){
285 address *rcpt = (address *)(rcpt_node->data);
286 gchar *cmd = g_malloc(256);
287 GList *var_table = var_table_rcpt(var_table_msg(NULL, msg), rcpt);
288
289 DEBUG(1) debugf("attempting to deliver %s to %s@%s with pipe\n",
290 msg->uid, rcpt->local_part, rcpt->domain);
291
292 if(expand(var_table, route->pipe, cmd, 256)){
293
294 if(pipe_out(msg, msg->hdr_list, rcpt, cmd,
295 (route->pipe_fromline ? MSGSTR_FROMLINE : 0) |
296 (route->pipe_fromhack ? MSGSTR_FROMHACK : 0))){
297 logwrite(LOG_NOTICE, "%s => %s@%s with pipe (cmd = '%s')\n",
298 msg->uid, rcpt->local_part, rcpt->domain, cmd
299 );
300 addr_mark_delivered(rcpt);
301 ok = TRUE;
302 }else{
303 logwrite(LOG_ALERT, "pipe_out '%s' failed\n", route->pipe);
304
305 if(route->connect_error_fail){
306 addr_mark_failed(rcpt);
307 }else{
308 addr_mark_defered(rcpt);
309 }
310 }
311 }else
312 logwrite(LOG_ALERT, "could not expand string %s\n", route->pipe);
313
314 destroy_table(var_table);
315 }
316 ok_fail = delivery_failures(msg, rcpt_list, "%s", strerror(errno));
317
318 if(flag) msg_free_data(msg);
319
320 if(ok || ok_fail) deliver_finish(msgout);
321 }
322
323 return ok;
324 }
325
326 /* deliver list of messages to one host
327 and finishes them if the message was delivered to at least one
328 rcpt.
329 Returns TRUE if at least one msg was delivered to at least one
330 rcpt.
331 */
332
333 gboolean deliver_msglist_host_smtp(connect_route *route, GList *msgout_list, gchar *host, GList *res_list)
334 {
335 gboolean ok = FALSE;
336 GList *msgout_node;
337 smtp_base *psb;
338 gint port;
339
340 /* paranoid check: */
341 if(msgout_list == NULL){
342 logwrite(LOG_ALERT,
343 "Ooops: empty list of messages in deliver_msglist_host()\n");
344 return FALSE;
345 }
346
347 if(host == NULL){
348 host = route->mail_host->address;
349 port = route->mail_host->port;
350 }else
351 port = conf.remote_port;
352
353 #ifdef ENABLE_POP3
354 if(route->pop3_login){
355 if(!(pop_before_smtp(route->pop3_login)))
356 return FALSE;
357 }
358 #endif
359
360 if((psb = (route->wrapper ?
361 smtp_out_open_child(route->wrapper) :
362 smtp_out_open(host, port, res_list)))){
363
364 if(route->wrapper) psb->remote_host = host;
365
366 set_heloname(psb,
367 route->helo_name ? route->helo_name : conf.host_name,
368 route->do_correct_helo);
369
370 #ifdef ENABLE_AUTH
371 if((route->auth_name) && (route->auth_login) && (route->auth_secret))
372 set_auth(psb, route->auth_name, route->auth_login, route->auth_secret);
373 #endif
374 if(smtp_out_init(psb)){
375
376 if(!route->do_pipelining) psb->use_pipelining = FALSE;
377
378 foreach(msgout_list, msgout_node){
379 msg_out *msgout = (msg_out *)(msgout_node->data);
380 gboolean flag, ok_msg = FALSE, ok_fail = FALSE;
381 message *msg = msgout->msg;
382
383 /* we may have to read the data at this point
384 and remember if we did */
385 flag = (msg->data_list == NULL);
386 if(flag){
387 if(!spool_read_data(msg)){
388 logwrite(LOG_ALERT, "could not open data spool file %s\n",
389 msg->uid);
390 break;
391 }
392 }
393
394 smtp_out_msg(psb, msg,
395 msgout->return_path, msgout->rcpt_list, msgout->hdr_list);
396
397 ok_fail = delivery_failures(msg, msgout->rcpt_list,
398 "while connected with %s, the server replied\n\t%s",
399 host, psb->buffer);
400
401 if((psb->error == smtp_eof) ||
402 (psb->error == smtp_timeout)){
403 /* connection lost */
404 break;
405 }
406 else if(psb->error != smtp_ok){
407 if(g_list_next(msgout_node) != NULL)
408 if(!smtp_out_rset(psb))
409 break;
410 }
411 ok_msg = (psb->error == smtp_ok);
412
413 if(flag) msg_free_data(msg);
414 if(ok_msg) ok = TRUE;
415 if(ok_msg || ok_fail){
416 deliver_finish(msgout);
417 }
418 }
419 if(psb->error == smtp_ok ||
420 (psb->error == smtp_fail) ||
421 (psb->error == smtp_trylater) ||
422 (psb->error == smtp_syntax)){
423
424 smtp_out_quit(psb);
425 }
426 }else{
427 /* smtp_out_init() failed */
428 if((psb->error == smtp_fail) ||
429 (psb->error == smtp_trylater) ||
430 (psb->error == smtp_syntax)){
431 smtp_out_quit(psb);
432
433 foreach(msgout_list, msgout_node){
434 msg_out *msgout = (msg_out *)(msgout_node->data);
435 smtp_out_mark_rcpts(psb, msgout->rcpt_list);
436
437 if(delivery_failures(msgout->msg, msgout->rcpt_list,
438 "while connected with %s, the server replied\n\t%s",
439 host, psb->buffer))
440 deliver_finish(msgout);
441 }
442 }
443 }
444 destroy_smtpbase(psb);
445 }else{
446 /* smtp_out_open() failed */
447 foreach(msgout_list, msgout_node){
448 msg_out *msgout = (msg_out *)(msgout_node->data);
449 GList *rcpt_node;
450
451 for(rcpt_node = g_list_first(msgout->rcpt_list);
452 rcpt_node;
453 rcpt_node = g_list_next(rcpt_node)){
454 address *rcpt = (address *)(rcpt_node->data);
455
456 addr_unmark_delivered(rcpt);
457 if(route->connect_error_fail){
458 addr_mark_failed(rcpt);
459 }else{
460 addr_mark_defered(rcpt);
461 }
462 if(route->wrapper ?
463 delivery_failures(msgout->msg, msgout->rcpt_list,
464 "could not open wrapper:\n\t%s",
465 strerror(errno)) :
466 delivery_failures(msgout->msg, msgout->rcpt_list,
467 "could not open connection to %s:%d :\n\t%s",
468 host, port, h_errno != 0 ? hstrerror(h_errno) : strerror(errno)))
469 deliver_finish(msgout);
470 }
471 }
472 }
473 return ok;
474 }
475
476 gboolean deliver_msglist_host(connect_route *route, GList *msgout_list, gchar *host, GList *res_list)
477 {
478 DEBUG(5) debugf("protocol = %s\n", route->protocol);
479
480 if(strcmp(route->protocol, "pipe") == 0){
481 return deliver_msglist_host_pipe(route, msgout_list, host, res_list);
482 }else{
483 return deliver_msglist_host_smtp(route, msgout_list, host, res_list);
484 }
485 }
486
487 /*
488 delivers messages in msgout_list using route
489 */
490 gboolean deliver_route_msgout_list(connect_route *route, GList *msgout_list)
491 {
492 gboolean ok = FALSE;
493
494 DEBUG(5) debugf("deliver_route_msgout_list entered, route->name = %s\n",
495 route->name);
496
497 if(route->mail_host != NULL){
498 /* this is easy... */
499 if(deliver_msglist_host(route, msgout_list,
500 NULL, route->resolve_list))
501 ok = TRUE;
502
503 }else{
504 /* this is not easy... */
505 GList *mo_ph_list;
506
507 mo_ph_list = route_msgout_list(route, msgout_list);
508 /* okay, now we have ordered our messages by the hosts. */
509 if(mo_ph_list != NULL){
510 GList *mo_ph_node;
511 /* TODO: It would be nice to be able to fork for each host.
512 We cannot do that yet because of complications with finishing the
513 messages. Threads could be a solution because they use the same
514 memory. But we are not thread safe yet...
515 */
516 foreach(mo_ph_list, mo_ph_node){
517 msgout_perhost *mo_ph = (msgout_perhost *)(mo_ph_node->data);
518 if(deliver_msglist_host(route, mo_ph->msgout_list,
519 mo_ph->host, route->resolve_list))
520 ok = TRUE;
521
522 destroy_msgout_perhost(mo_ph);
523 }
524 g_list_free(mo_ph_list);
525 }
526 }
527 return ok;
528 }
529
530 /*
531 calls route_prepare_msg()
532 delivers messages in msg_list using route
533 by calling deliver_route_msgout_list()
534 */
535 gboolean deliver_route_msg_list(connect_route *route, GList *msgout_list)
536 {
537 GList *msgout_list_deliver = NULL;
538 GList *msgout_node;
539 gboolean ok = TRUE;
540
541 DEBUG(6) debugf("deliver_route_msg_list()\n");
542
543 foreach(msgout_list, msgout_node){
544 msg_out *msgout = (msg_out *)(msgout_node->data);
545 msg_out *msgout_cloned = clone_msg_out(msgout);
546 GList *rcpt_list_non_delivered = NULL;
547 GList *rcpt_node;
548
549 /* we have to delete already delivered rcpt's
550 because a previous route may have delivered to it */
551 foreach(msgout_cloned->rcpt_list, rcpt_node){
552 address *rcpt = (address *)(rcpt_node->data);
553 /* failed addresses already have been bounced
554 - there should be a better way to handle those.*/
555 if(!addr_is_delivered(rcpt) && !addr_is_failed(rcpt) && !(rcpt->flags & ADDR_FLAG_LAST_ROUTE))
556 rcpt_list_non_delivered = g_list_append(rcpt_list_non_delivered, rcpt);
557 }
558 g_list_free(msgout_cloned->rcpt_list);
559 msgout_cloned->rcpt_list = rcpt_list_non_delivered;
560
561 if(msgout_cloned->rcpt_list){
562 if(route_is_allowed_mail_local(route, msgout->msg->return_path) &&
563 route_is_allowed_return_path(route, msgout->msg->return_path)){
564 GList *rcpt_list_allowed = NULL, *rcpt_list_notallowed = NULL;
565 msg_rcptlist_route(route, msgout_cloned->rcpt_list,
566 &rcpt_list_allowed, &rcpt_list_notallowed);
567
568 if(rcpt_list_allowed != NULL){
569 logwrite(LOG_NOTICE, "%s using '%s'\n", msgout->msg->uid, route->name);
570
571 g_list_free(msgout_cloned->rcpt_list);
572 msgout_cloned->rcpt_list = rcpt_list_allowed;
573
574 if(route->last_route){
575 GList *rcpt_node;
576 foreach(msgout_cloned->rcpt_list, rcpt_node){
577 address *rcpt = (address *)(rcpt_node->data);
578 rcpt->flags |= ADDR_FLAG_LAST_ROUTE;
579 }
580 }
581
582 route_prepare_msgout(route, msgout_cloned);
583 msgout_list_deliver = g_list_append(msgout_list_deliver, msgout_cloned);
584 }else
585 destroy_msg_out(msgout_cloned);
586 }
587 else
588 destroy_msg_out(msgout_cloned);
589 }else
590 destroy_msg_out(msgout_cloned);
591 }
592
593 if(msgout_list_deliver != NULL){
594 if(deliver_route_msgout_list(route, msgout_list_deliver))
595 ok = TRUE;
596 destroy_msg_out_list(msgout_list_deliver);
597 }
598 return ok;
599 }
600
601 /* copy pointers of delivered addresses to the msg's non_rcpt_list,
602 to make sure that they will not be delivered again.
603 */
604 void update_non_rcpt_list(msg_out *msgout)
605 {
606 GList *rcpt_node;
607 message *msg = msgout->msg;
608
609 foreach(msgout->rcpt_list, rcpt_node){
610 address *rcpt = (address *)(rcpt_node->data);
611 if(addr_is_delivered(rcpt) || addr_is_failed(rcpt))
612 msg->non_rcpt_list = g_list_append(msg->non_rcpt_list, rcpt);
613 }
614 }
615
616 /* after delivery attempts, we check if there are any
617 rcpt addresses left in the message.
618 If all addresses have been completed, the spool files will
619 be deleted, otherwise the header spool will be written back.
620 We never changed the data spool, so there is no need to write that back.
621
622 returns TRUE if all went well.
623 */
624 gboolean deliver_finish(msg_out *msgout)
625 {
626 GList *rcpt_node;
627 gboolean ok = FALSE;
628 message *msg = msgout->msg;
629 gboolean finished = TRUE;
630
631 update_non_rcpt_list(msgout);
632
633 /* we NEVER made copies of the addresses, flags affecting addresses
634 were always set on the original address structs */
635 foreach(msg->rcpt_list, rcpt_node){
636 address *rcpt = (address *)(rcpt_node->data);
637 if(!addr_is_finished_children(rcpt))
638 finished = FALSE;
639 else{
640 /* if ALL children have been delivered,
641 mark parent as delivered.
642 if there is one or more not delivered,
643 it must have failed, we mark the parent as failed as well.
644 */
645 if(addr_is_delivered_children(rcpt)){
646 addr_mark_delivered(rcpt);
647 }else{
648 addr_mark_failed(rcpt);
649 }
650 }
651 }
652
653 if(!finished){
654 /* one not delivered address was found */
655 if(spool_write(msg, FALSE)){
656 ok = TRUE;
657 DEBUG(2) debugf("spool header for %s written back.\n", msg->uid);
658 }else
659 logwrite(LOG_ALERT, "could not write back spool header for %s\n",
660 msg->uid);
661 }else{
662 ok = spool_delete_all(msg);
663 if(ok)
664 logwrite(LOG_NOTICE, "%s completed.\n", msg->uid);
665 }
666 return ok;
667 }
668
669 gboolean deliver_finish_list(GList *msgout_list)
670 {
671 gboolean ok = TRUE;
672 GList *msgout_node;
673 foreach(msgout_list, msgout_node){
674 msg_out *msgout = (msg_out *)(msgout_node->data);
675 if(!deliver_finish(msgout))
676 ok = FALSE;
677 }
678 return ok;
679 }
680
681 gboolean deliver_msgout_list_online(GList *msgout_list)
682 {
683 GList *rf_list = NULL;
684 gchar *connect_name = detect_online();
685 gboolean ok = FALSE;
686
687 if(connect_name != NULL){
688 logwrite(LOG_NOTICE, "detected online configuration %s\n", connect_name);
689 /* we are online! */
690 rf_list = (GList *)table_find(conf.connect_routes, connect_name);
691 if(rf_list != NULL){
692 GList *route_list = read_route_list(rf_list, FALSE);
693 if(route_list){
694 GList *route_node;
695 foreach(route_list, route_node){
696 connect_route *route = (connect_route *)(route_node->data);
697 ok = deliver_route_msg_list(route, msgout_list);
698 }
699 destroy_route_list(route_list);
700 }
701 else
702 logwrite(LOG_ALERT,
703 "could not read route list '%s'\n", connect_name);
704 }else{
705 logwrite(LOG_ALERT, "route list with name '%s' not found.\n", connect_name);
706 }
707 }
708 return ok;
709 }
710
711 gboolean deliver_msg_list(GList *msg_list, guint flags){
712 GList *msgout_list = create_msg_out_list(msg_list);
713 GList *local_msgout_list = NULL, *localnet_msgout_list = NULL, *other_msgout_list = NULL;
714 GList *msgout_node;
715 GList *alias_table = NULL;
716 gboolean ok = TRUE;
717
718 if(conf.alias_file){
719 if(!(alias_table = table_read(conf.alias_file, ':')))
720 return FALSE;
721 }
722
723 /* sort messages for different deliveries */
724 foreach(msgout_list, msgout_node){
725 msg_out *msgout = (msg_out *)(msgout_node->data);
726 GList *rcpt_list;
727 GList *local_rcpt_list = NULL;
728 GList *localnet_rcpt_list = NULL;
729 GList *other_rcpt_list;
730
731 if(!spool_lock(msgout->msg->uid)) continue;
732
733 rcpt_list = g_list_copy(msgout->msg->rcpt_list);
734 if(conf.log_user){
735 address *addr = create_address_qualified(conf.log_user, TRUE, conf.host_name);
736 if(addr)
737 rcpt_list = g_list_prepend(rcpt_list, addr);
738 }
739 if(alias_table){
740 GList *aliased_rcpt_list;
741 aliased_rcpt_list = alias_expand(alias_table, rcpt_list,
742 msgout->msg->non_rcpt_list);
743 g_list_free(rcpt_list);
744 rcpt_list = aliased_rcpt_list;
745 }
746
747 /* local recipients */
748 other_rcpt_list = NULL;
749 rcptlist_with_addr_is_local(rcpt_list, &local_rcpt_list, &other_rcpt_list);
750
751 if(flags & DLVR_LOCAL){
752 if(local_rcpt_list != NULL){
753 msg_out *local_msgout = clone_msg_out(msgout);
754 local_msgout->rcpt_list = local_rcpt_list;
755 local_msgout_list = g_list_append(local_msgout_list, local_msgout);
756 }
757 }
758
759 g_list_free(rcpt_list);
760
761 /* local net recipients */
762 rcpt_list = other_rcpt_list;
763 other_rcpt_list = NULL;
764 rcptlist_with_one_of_hostlist(rcpt_list, conf.local_nets,
765 &localnet_rcpt_list, &other_rcpt_list);
766
767 if(flags & DLVR_LAN){
768 if(localnet_rcpt_list != NULL){
769 msg_out *localnet_msgout = clone_msg_out(msgout);
770 localnet_msgout->rcpt_list = localnet_rcpt_list;
771 localnet_msgout_list = g_list_append(localnet_msgout_list, localnet_msgout);
772 }
773 }
774
775 if(flags & DLVR_ONLINE){
776 /* the rest, this is online delivery */
777 if(other_rcpt_list != NULL){
778 msg_out *other_msgout = clone_msg_out(msgout);
779 other_msgout->rcpt_list = other_rcpt_list;
780 other_msgout_list = g_list_append(other_msgout_list, other_msgout);
781 }
782 }
783 }
784
785 if(alias_table)
786 destroy_table(alias_table);
787
788 /* actual delivery */
789 if(local_msgout_list != NULL){
790 foreach(local_msgout_list, msgout_node){
791 msg_out *msgout = (msg_out *)(msgout_node->data);
792 if(!deliver_local(msgout)) ok = FALSE;
793 }
794 destroy_msg_out_list(local_msgout_list);
795 }
796
797 if(localnet_msgout_list != NULL){
798 GList *route_list = NULL;
799 GList *route_node;
800
801 if(conf.local_net_routes)
802 route_list = read_route_list(conf.local_net_routes, TRUE);
803 else
804 route_list = g_list_append(NULL, create_local_route());
805
806 foreach(route_list, route_node){
807 connect_route *route = (connect_route *)(route_node->data);
808 if(!deliver_route_msg_list(route, localnet_msgout_list)) ok = FALSE;
809 }
810 destroy_msg_out_list(localnet_msgout_list);
811 destroy_route_list(route_list);
812 }
813
814 if(other_msgout_list != NULL){
815 if(!deliver_msgout_list_online(other_msgout_list)) ok = FALSE;
816 destroy_msg_out_list(other_msgout_list);
817 }
818
819 foreach(msgout_list, msgout_node){
820 msg_out *msgout = (msg_out *)(msgout_node->data);
821 spool_unlock(msgout->msg->uid);
822 }
823
824 destroy_msg_out_list(msgout_list);
825
826 return ok;
827 }
828
829 /* This function searches in the list of rcpt addresses
830 for local and 'local net' addresses. Remote addresses
831 which are reachable only when online are treated specially
832 in another function.
833
834 deliver() is called when a message has just been received and should
835 be delivered immediately.
836 */
837 gboolean deliver(message *msg)
838 {
839 gboolean ok;
840
841 GList *msg_list = g_list_append(NULL, msg);
842
843 ok = deliver_msg_list(msg_list, DLVR_ALL);
844
845 g_list_free(msg_list);
846
847 return ok;
848 }
849