|
0
|
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
|
