Commit | Line | Data |
---|---|---|
2117e02e MW |
1 | #include <sys/types.h> |
2 | #include <sys/stat.h> | |
3 | #include "readwrite.h" | |
4 | #include "sig.h" | |
5 | #include "direntry.h" | |
6 | #include "control.h" | |
7 | #include "select.h" | |
8 | #include "open.h" | |
9 | #include "seek.h" | |
10 | #include "exit.h" | |
11 | #include "lock.h" | |
12 | #include "ndelay.h" | |
13 | #include "now.h" | |
14 | #include "getln.h" | |
15 | #include "substdio.h" | |
16 | #include "alloc.h" | |
17 | #include "error.h" | |
18 | #include "stralloc.h" | |
19 | #include "str.h" | |
20 | #include "byte.h" | |
21 | #include "fmt.h" | |
22 | #include "scan.h" | |
23 | #include "case.h" | |
24 | #include "auto_qmail.h" | |
25 | #include "trigger.h" | |
26 | #include "newfield.h" | |
27 | #include "quote.h" | |
28 | #include "qmail.h" | |
29 | #include "qsutil.h" | |
30 | #include "prioq.h" | |
31 | #include "constmap.h" | |
32 | #include "fmtqfn.h" | |
33 | #include "readsubdir.h" | |
34 | ||
35 | /* critical timing feature #1: if not triggered, do not busy-loop */ | |
36 | /* critical timing feature #2: if triggered, respond within fixed time */ | |
37 | /* important timing feature: when triggered, respond instantly */ | |
38 | #define SLEEP_TODO 1500 /* check todo/ every 25 minutes in any case */ | |
39 | #define SLEEP_FUZZ 1 /* slop a bit on sleeps to avoid zeno effect */ | |
40 | #define SLEEP_FOREVER 86400 /* absolute maximum time spent in select() */ | |
41 | #define SLEEP_CLEANUP 76431 /* time between cleanups */ | |
42 | #define SLEEP_SYSFAIL 123 | |
43 | #define OSSIFIED 129600 /* 36 hours; _must_ exceed q-q's DEATH (24 hours) */ | |
44 | ||
45 | int lifetime = 604800; | |
46 | ||
47 | stralloc percenthack = {0}; | |
48 | struct constmap mappercenthack; | |
49 | stralloc locals = {0}; | |
50 | struct constmap maplocals; | |
51 | stralloc redir = {0}; | |
52 | struct constmap mapredir; | |
53 | stralloc vdoms = {0}; | |
54 | struct constmap mapvdoms; | |
55 | stralloc envnoathost = {0}; | |
56 | stralloc bouncefrom = {0}; | |
57 | stralloc bouncehost = {0}; | |
58 | stralloc doublebounceto = {0}; | |
59 | stralloc doublebouncehost = {0}; | |
60 | ||
61 | char strnum2[FMT_ULONG]; | |
62 | char strnum3[FMT_ULONG]; | |
63 | ||
64 | #define CHANNELS 2 | |
65 | char *chanaddr[CHANNELS] = { "local/", "remote/" }; | |
66 | char *channodelmsg[CHANNELS] = { | |
67 | "local deliveries will be put on hold\n" | |
68 | , "remote deliveries will be put on hold\n" | |
69 | }; | |
70 | char *tochan[CHANNELS] = { " to local ", " to remote " }; | |
71 | int chanfdout[CHANNELS] = { 1, 3 }; | |
72 | int chanfdin[CHANNELS] = { 2, 4 }; | |
73 | int chanskip[CHANNELS] = { 10, 20 }; | |
74 | ||
75 | int flagexitasap = 0; void sigterm() { flagexitasap = 1; } | |
76 | int flagrunasap = 0; void sigalrm() { flagrunasap = 1; } | |
77 | int flagreadasap = 0; void sighup() { flagreadasap = 1; } | |
78 | ||
79 | void cleandied() { log1("alert: oh no! lost qmail-clean connection! dying...\n"); | |
80 | flagexitasap = 1; } | |
81 | ||
82 | int flagspawnalive[CHANNELS]; | |
83 | void spawndied(c) int c; { log1("alert: oh no! lost spawn connection! dying...\n"); | |
84 | flagspawnalive[c] = 0; flagexitasap = 1; } | |
85 | ||
86 | #define REPORTMAX 10000 | |
87 | ||
88 | datetime_sec recent; | |
89 | ||
90 | ||
91 | /* this file is too long ----------------------------------------- FILENAMES */ | |
92 | ||
93 | stralloc fn = {0}; | |
94 | stralloc fn2 = {0}; | |
95 | char fnmake_strnum[FMT_ULONG]; | |
96 | ||
97 | void fnmake_init() | |
98 | { | |
99 | while (!stralloc_ready(&fn,FMTQFN)) nomem(); | |
100 | while (!stralloc_ready(&fn2,FMTQFN)) nomem(); | |
101 | } | |
102 | ||
103 | void fnmake_info(id) unsigned long id; { fn.len = fmtqfn(fn.s,"info/",id,1); } | |
104 | void fnmake_todo(id) unsigned long id; { fn.len = fmtqfn(fn.s,"todo/",id,0); } | |
105 | void fnmake_mess(id) unsigned long id; { fn.len = fmtqfn(fn.s,"mess/",id,1); } | |
106 | void fnmake_foop(id) unsigned long id; { fn.len = fmtqfn(fn.s,"foop/",id,0); } | |
107 | void fnmake_split(id) unsigned long id; { fn.len = fmtqfn(fn.s,"",id,1); } | |
108 | void fnmake2_bounce(id) unsigned long id; | |
109 | { fn2.len = fmtqfn(fn2.s,"bounce/",id,0); } | |
110 | void fnmake_chanaddr(id,c) unsigned long id; int c; | |
111 | { fn.len = fmtqfn(fn.s,chanaddr[c],id,1); } | |
112 | ||
113 | ||
114 | /* this file is too long ----------------------------------------- REWRITING */ | |
115 | ||
116 | stralloc rwline = {0}; | |
117 | ||
118 | /* 1 if by land, 2 if by sea, 0 if out of memory. not allowed to barf. */ | |
119 | /* may trash recip. must set up rwline, between a T and a \0. */ | |
120 | int rewrite(recip) | |
121 | char *recip; | |
122 | { | |
123 | int i; | |
124 | int j; | |
125 | char *x; | |
126 | static stralloc addr = {0}; | |
127 | static stralloc domain = {0}; | |
128 | ||
129 | if (!stralloc_copys(&rwline,"T")) return 0; | |
130 | if (!stralloc_copys(&addr,recip)) return 0; | |
131 | ||
132 | i = byte_rchr(addr.s,addr.len,'@'); | |
133 | if (i == addr.len) { | |
134 | if (!stralloc_cats(&addr,"@")) return 0; | |
135 | if (!stralloc_cat(&addr,&envnoathost)) return 0; | |
136 | } | |
137 | ||
138 | while (constmap(&mappercenthack,addr.s + i + 1,addr.len - i - 1)) { | |
139 | j = byte_rchr(addr.s,i,'%'); | |
140 | if (j == i) break; | |
141 | addr.len = i; | |
142 | i = j; | |
143 | addr.s[i] = '@'; | |
144 | } | |
145 | ||
146 | if (x = constmap(&mapredir,addr.s,addr.len)) | |
147 | if (x[str_chr(x,'@')]) | |
148 | if (!stralloc_copys(&addr,x)) return 0; | |
149 | ||
150 | i = byte_rchr(addr.s,addr.len,'@'); | |
151 | if (!stralloc_copyb(&domain,addr.s + i + 1,addr.len - i - 1)) return 0; | |
152 | addr.len = i; | |
153 | ||
154 | if (constmap(&maplocals,domain.s,domain.len)) { | |
155 | if (!stralloc_cat(&rwline,&addr)) return 0; | |
156 | if (!stralloc_cats(&rwline,"@")) return 0; | |
157 | if (!stralloc_cat(&rwline,&domain)) return 0; | |
158 | if (!stralloc_0(&rwline)) return 0; | |
159 | return 1; | |
160 | } | |
161 | ||
162 | for (i = 0;i <= domain.len;++i) | |
163 | if ((i == 0) || (i == domain.len) || (domain.s[i] == '.')) | |
164 | if (x = constmap(&mapvdoms,domain.s + i,domain.len - i)) { | |
165 | if (!*x) break; | |
166 | if (!stralloc_cats(&rwline,x)) return 0; | |
167 | if (!stralloc_cats(&rwline,"-")) return 0; | |
168 | if (!stralloc_cat(&rwline,&addr)) return 0; | |
169 | if (!stralloc_cats(&rwline,"@")) return 0; | |
170 | if (!stralloc_cat(&rwline,&domain)) return 0; | |
171 | if (!stralloc_0(&rwline)) return 0; | |
172 | return 1; | |
173 | } | |
174 | ||
175 | if (!stralloc_cat(&rwline,&addr)) return 0; | |
176 | if (!stralloc_cats(&rwline,"@")) return 0; | |
177 | if (!stralloc_cat(&rwline,&domain)) return 0; | |
178 | if (!stralloc_0(&rwline)) return 0; | |
179 | return 2; | |
180 | } | |
181 | ||
182 | void senderadd(sa,sender,recip) | |
183 | stralloc *sa; | |
184 | char *sender; | |
185 | char *recip; | |
186 | { | |
187 | int i; | |
188 | int j; | |
189 | int k; | |
190 | ||
191 | i = str_len(sender); | |
192 | if (i >= 4) | |
193 | if (str_equal(sender + i - 4,"-@[]")) | |
194 | { | |
195 | j = byte_rchr(sender,i - 4,'@'); | |
196 | k = str_rchr(recip,'@'); | |
197 | if (recip[k] && (j + 5 <= i)) | |
198 | { | |
199 | /* owner-@host-@[] -> owner-recipbox=reciphost@host */ | |
200 | while (!stralloc_catb(sa,sender,j)) nomem(); | |
201 | while (!stralloc_catb(sa,recip,k)) nomem(); | |
202 | while (!stralloc_cats(sa,"=")) nomem(); | |
203 | while (!stralloc_cats(sa,recip + k + 1)) nomem(); | |
204 | while (!stralloc_cats(sa,"@")) nomem(); | |
205 | while (!stralloc_catb(sa,sender + j + 1,i - 5 - j)) nomem(); | |
206 | return; | |
207 | } | |
208 | } | |
209 | while (!stralloc_cats(sa,sender)) nomem(); | |
210 | } | |
211 | ||
212 | ||
213 | /* this file is too long ---------------------------------------------- INFO */ | |
214 | ||
215 | int getinfo(sa,dt,id) | |
216 | stralloc *sa; | |
217 | datetime_sec *dt; | |
218 | unsigned long id; | |
219 | { | |
220 | int fdinfo; | |
221 | struct stat st; | |
222 | static stralloc line = {0}; | |
223 | int match; | |
224 | substdio ss; | |
225 | char buf[128]; | |
226 | ||
227 | fnmake_info(id); | |
228 | fdinfo = open_read(fn.s); | |
229 | if (fdinfo == -1) return 0; | |
230 | if (fstat(fdinfo,&st) == -1) { close(fdinfo); return 0; } | |
231 | substdio_fdbuf(&ss,read,fdinfo,buf,sizeof(buf)); | |
232 | if (getln(&ss,&line,&match,'\0') == -1) { close(fdinfo); return 0; } | |
233 | close(fdinfo); | |
234 | if (!match) return 0; | |
235 | if (line.s[0] != 'F') return 0; | |
236 | ||
237 | *dt = st.st_mtime; | |
238 | while (!stralloc_copys(sa,line.s + 1)) nomem(); | |
239 | while (!stralloc_0(sa)) nomem(); | |
240 | return 1; | |
241 | } | |
242 | ||
243 | ||
244 | /* this file is too long ------------------------------------- COMMUNICATION */ | |
245 | ||
246 | substdio sstoqc; char sstoqcbuf[1024]; | |
247 | substdio ssfromqc; char ssfromqcbuf[1024]; | |
248 | stralloc comm_buf[CHANNELS] = { {0}, {0} }; | |
249 | int comm_pos[CHANNELS]; | |
250 | ||
251 | void comm_init() | |
252 | { | |
253 | int c; | |
254 | substdio_fdbuf(&sstoqc,write,5,sstoqcbuf,sizeof(sstoqcbuf)); | |
255 | substdio_fdbuf(&ssfromqc,read,6,ssfromqcbuf,sizeof(ssfromqcbuf)); | |
256 | for (c = 0;c < CHANNELS;++c) | |
257 | if (ndelay_on(chanfdout[c]) == -1) | |
258 | /* this is so stupid: NDELAY semantics should be default on write */ | |
259 | spawndied(c); /* drastic, but better than risking deadlock */ | |
260 | } | |
261 | ||
262 | int comm_canwrite(c) | |
263 | int c; | |
264 | { | |
265 | /* XXX: could allow a bigger buffer; say 10 recipients */ | |
266 | if (comm_buf[c].s && comm_buf[c].len) return 0; | |
267 | return 1; | |
268 | } | |
269 | ||
270 | void comm_write(c,delnum,id,sender,recip) | |
271 | int c; | |
272 | int delnum; | |
273 | unsigned long id; | |
274 | char *sender; | |
275 | char *recip; | |
276 | { | |
277 | char ch; | |
278 | if (comm_buf[c].s && comm_buf[c].len) return; | |
279 | while (!stralloc_copys(&comm_buf[c],"")) nomem(); | |
280 | ch = delnum; | |
281 | while (!stralloc_append(&comm_buf[c],&ch)) nomem(); | |
282 | fnmake_split(id); | |
283 | while (!stralloc_cats(&comm_buf[c],fn.s)) nomem(); | |
284 | while (!stralloc_0(&comm_buf[c])) nomem(); | |
285 | senderadd(&comm_buf[c],sender,recip); | |
286 | while (!stralloc_0(&comm_buf[c])) nomem(); | |
287 | while (!stralloc_cats(&comm_buf[c],recip)) nomem(); | |
288 | while (!stralloc_0(&comm_buf[c])) nomem(); | |
289 | comm_pos[c] = 0; | |
290 | } | |
291 | ||
292 | void comm_selprep(nfds,wfds) | |
293 | int *nfds; | |
294 | fd_set *wfds; | |
295 | { | |
296 | int c; | |
297 | for (c = 0;c < CHANNELS;++c) | |
298 | if (flagspawnalive[c]) | |
299 | if (comm_buf[c].s && comm_buf[c].len) | |
300 | { | |
301 | FD_SET(chanfdout[c],wfds); | |
302 | if (*nfds <= chanfdout[c]) | |
303 | *nfds = chanfdout[c] + 1; | |
304 | } | |
305 | } | |
306 | ||
307 | void comm_do(wfds) | |
308 | fd_set *wfds; | |
309 | { | |
310 | int c; | |
311 | for (c = 0;c < CHANNELS;++c) | |
312 | if (flagspawnalive[c]) | |
313 | if (comm_buf[c].s && comm_buf[c].len) | |
314 | if (FD_ISSET(chanfdout[c],wfds)) | |
315 | { | |
316 | int w; | |
317 | int len; | |
318 | len = comm_buf[c].len; | |
319 | w = write(chanfdout[c],comm_buf[c].s + comm_pos[c],len - comm_pos[c]); | |
320 | if (w <= 0) | |
321 | { | |
322 | if ((w == -1) && (errno == error_pipe)) | |
323 | spawndied(c); | |
324 | else | |
325 | continue; /* kernel select() bug; can't avoid busy-looping */ | |
326 | } | |
327 | else | |
328 | { | |
329 | comm_pos[c] += w; | |
330 | if (comm_pos[c] == len) | |
331 | comm_buf[c].len = 0; | |
332 | } | |
333 | } | |
334 | } | |
335 | ||
336 | ||
337 | /* this file is too long ------------------------------------------ CLEANUPS */ | |
338 | ||
339 | int flagcleanup; /* if 1, cleanupdir is initialized and ready */ | |
340 | readsubdir cleanupdir; | |
341 | datetime_sec cleanuptime; | |
342 | ||
343 | void cleanup_init() | |
344 | { | |
345 | flagcleanup = 0; | |
346 | cleanuptime = now(); | |
347 | } | |
348 | ||
349 | void cleanup_selprep(wakeup) | |
350 | datetime_sec *wakeup; | |
351 | { | |
352 | if (flagcleanup) *wakeup = 0; | |
353 | if (*wakeup > cleanuptime) *wakeup = cleanuptime; | |
354 | } | |
355 | ||
356 | void cleanup_do() | |
357 | { | |
358 | char ch; | |
359 | struct stat st; | |
360 | unsigned long id; | |
361 | ||
362 | if (!flagcleanup) | |
363 | { | |
364 | if (recent < cleanuptime) return; | |
365 | readsubdir_init(&cleanupdir,"mess",pausedir); | |
366 | flagcleanup = 1; | |
367 | } | |
368 | ||
369 | switch(readsubdir_next(&cleanupdir,&id)) | |
370 | { | |
371 | case 1: | |
372 | break; | |
373 | case 0: | |
374 | flagcleanup = 0; | |
375 | cleanuptime = recent + SLEEP_CLEANUP; | |
376 | default: | |
377 | return; | |
378 | } | |
379 | ||
380 | fnmake_mess(id); | |
381 | if (stat(fn.s,&st) == -1) return; /* probably qmail-queue deleted it */ | |
382 | if (recent <= st.st_atime + OSSIFIED) return; | |
383 | ||
384 | fnmake_info(id); | |
385 | if (stat(fn.s,&st) == 0) return; | |
386 | if (errno != error_noent) return; | |
387 | fnmake_todo(id); | |
388 | if (stat(fn.s,&st) == 0) return; | |
389 | if (errno != error_noent) return; | |
390 | ||
391 | fnmake_foop(id); | |
392 | if (substdio_putflush(&sstoqc,fn.s,fn.len) == -1) { cleandied(); return; } | |
393 | if (substdio_get(&ssfromqc,&ch,1) != 1) { cleandied(); return; } | |
394 | if (ch != '+') | |
395 | log3("warning: qmail-clean unable to clean up ",fn.s,"\n"); | |
396 | } | |
397 | ||
398 | ||
399 | /* this file is too long ----------------------------------- PRIORITY QUEUES */ | |
400 | ||
401 | prioq pqdone = {0}; /* -todo +info; HOPEFULLY -local -remote */ | |
402 | prioq pqchan[CHANNELS] = { {0}, {0} }; | |
403 | /* pqchan 0: -todo +info +local ?remote */ | |
404 | /* pqchan 1: -todo +info ?local +remote */ | |
405 | prioq pqfail = {0}; /* stat() failure; has to be pqadded again */ | |
406 | ||
407 | void pqadd(id) | |
408 | unsigned long id; | |
409 | { | |
410 | struct prioq_elt pe; | |
411 | struct prioq_elt pechan[CHANNELS]; | |
412 | int flagchan[CHANNELS]; | |
413 | struct stat st; | |
414 | int c; | |
415 | ||
416 | #define CHECKSTAT if (errno != error_noent) goto fail; | |
417 | ||
418 | fnmake_info(id); | |
419 | if (stat(fn.s,&st) == -1) | |
420 | { | |
421 | CHECKSTAT | |
422 | return; /* someone yanking our chain */ | |
423 | } | |
424 | ||
425 | fnmake_todo(id); | |
426 | if (stat(fn.s,&st) != -1) return; /* look, ma, dad crashed writing info! */ | |
427 | CHECKSTAT | |
428 | ||
429 | for (c = 0;c < CHANNELS;++c) | |
430 | { | |
431 | fnmake_chanaddr(id,c); | |
432 | if (stat(fn.s,&st) == -1) { flagchan[c] = 0; CHECKSTAT } | |
433 | else { flagchan[c] = 1; pechan[c].id = id; pechan[c].dt = st.st_mtime; } | |
434 | } | |
435 | ||
436 | for (c = 0;c < CHANNELS;++c) | |
437 | if (flagchan[c]) | |
438 | while (!prioq_insert(&pqchan[c],&pechan[c])) nomem(); | |
439 | ||
440 | for (c = 0;c < CHANNELS;++c) if (flagchan[c]) break; | |
441 | if (c == CHANNELS) | |
442 | { | |
443 | pe.id = id; pe.dt = now(); | |
444 | while (!prioq_insert(&pqdone,&pe)) nomem(); | |
445 | } | |
446 | ||
447 | return; | |
448 | ||
449 | fail: | |
450 | log3("warning: unable to stat ",fn.s,"; will try again later\n"); | |
451 | pe.id = id; pe.dt = now() + SLEEP_SYSFAIL; | |
452 | while (!prioq_insert(&pqfail,&pe)) nomem(); | |
453 | } | |
454 | ||
455 | void pqstart() | |
456 | { | |
457 | readsubdir rs; | |
458 | int x; | |
459 | unsigned long id; | |
460 | ||
461 | readsubdir_init(&rs,"info",pausedir); | |
462 | ||
463 | while (x = readsubdir_next(&rs,&id)) | |
464 | if (x > 0) | |
465 | pqadd(id); | |
466 | } | |
467 | ||
468 | void pqfinish() | |
469 | { | |
470 | int c; | |
471 | struct prioq_elt pe; | |
472 | time_t ut[2]; /* XXX: more portable than utimbuf, but still worrisome */ | |
473 | ||
474 | for (c = 0;c < CHANNELS;++c) | |
475 | while (prioq_min(&pqchan[c],&pe)) | |
476 | { | |
477 | prioq_delmin(&pqchan[c]); | |
478 | fnmake_chanaddr(pe.id,c); | |
479 | ut[0] = ut[1] = pe.dt; | |
480 | if (utime(fn.s,ut) == -1) | |
481 | log3("warning: unable to utime ",fn.s,"; message will be retried too soon\n"); | |
482 | } | |
483 | } | |
484 | ||
485 | void pqrun() | |
486 | { | |
487 | int c; | |
488 | int i; | |
489 | for (c = 0;c < CHANNELS;++c) | |
490 | if (pqchan[c].p) | |
491 | if (pqchan[c].len) | |
492 | for (i = 0;i < pqchan[c].len;++i) | |
493 | pqchan[c].p[i].dt = recent; | |
494 | } | |
495 | ||
496 | ||
497 | /* this file is too long ---------------------------------------------- JOBS */ | |
498 | ||
499 | struct job | |
500 | { | |
501 | int refs; /* if 0, this struct is unused */ | |
502 | unsigned long id; | |
503 | int channel; | |
504 | datetime_sec retry; | |
505 | stralloc sender; | |
506 | int numtodo; | |
507 | int flaghiteof; | |
508 | int flagdying; | |
509 | } | |
510 | ; | |
511 | ||
512 | int numjobs; | |
513 | struct job *jo; | |
514 | ||
515 | void job_init() | |
516 | { | |
517 | int j; | |
518 | while (!(jo = (struct job *) alloc(numjobs * sizeof(struct job)))) nomem(); | |
519 | for (j = 0;j < numjobs;++j) | |
520 | { | |
521 | jo[j].refs = 0; | |
522 | jo[j].sender.s = 0; | |
523 | } | |
524 | } | |
525 | ||
526 | int job_avail() | |
527 | { | |
528 | int j; | |
529 | for (j = 0;j < numjobs;++j) if (!jo[j].refs) return 1; | |
530 | return 0; | |
531 | } | |
532 | ||
533 | int job_open(id,channel) | |
534 | unsigned long id; | |
535 | int channel; | |
536 | { | |
537 | int j; | |
538 | for (j = 0;j < numjobs;++j) if (!jo[j].refs) break; | |
539 | if (j == numjobs) return -1; | |
540 | jo[j].refs = 1; | |
541 | jo[j].id = id; | |
542 | jo[j].channel = channel; | |
543 | jo[j].numtodo = 0; | |
544 | jo[j].flaghiteof = 0; | |
545 | return j; | |
546 | } | |
547 | ||
548 | void job_close(j) | |
549 | int j; | |
550 | { | |
551 | struct prioq_elt pe; | |
552 | struct stat st; | |
553 | ||
554 | if (0 < --jo[j].refs) return; | |
555 | ||
556 | pe.id = jo[j].id; | |
557 | pe.dt = jo[j].retry; | |
558 | if (jo[j].flaghiteof && !jo[j].numtodo) | |
559 | { | |
560 | fnmake_chanaddr(jo[j].id,jo[j].channel); | |
561 | if (unlink(fn.s) == -1) | |
562 | { | |
563 | log3("warning: unable to unlink ",fn.s,"; will try again later\n"); | |
564 | pe.dt = now() + SLEEP_SYSFAIL; | |
565 | } | |
566 | else | |
567 | { | |
568 | int c; | |
569 | for (c = 0;c < CHANNELS;++c) if (c != jo[j].channel) | |
570 | { | |
571 | fnmake_chanaddr(jo[j].id,c); | |
572 | if (stat(fn.s,&st) == 0) return; /* more channels going */ | |
573 | if (errno != error_noent) | |
574 | { | |
575 | log3("warning: unable to stat ",fn.s,"\n"); | |
576 | break; /* this is the only reason for HOPEFULLY */ | |
577 | } | |
578 | } | |
579 | pe.dt = now(); | |
580 | while (!prioq_insert(&pqdone,&pe)) nomem(); | |
581 | return; | |
582 | } | |
583 | } | |
584 | ||
585 | while (!prioq_insert(&pqchan[jo[j].channel],&pe)) nomem(); | |
586 | } | |
587 | ||
588 | ||
589 | /* this file is too long ------------------------------------------- BOUNCES */ | |
590 | ||
591 | char *stripvdomprepend(recip) | |
592 | char *recip; | |
593 | { | |
594 | int i; | |
595 | char *domain; | |
596 | int domainlen; | |
597 | char *prepend; | |
598 | ||
599 | i = str_rchr(recip,'@'); | |
600 | if (!recip[i]) return recip; | |
601 | domain = recip + i + 1; | |
602 | domainlen = str_len(domain); | |
603 | ||
604 | for (i = 0;i <= domainlen;++i) | |
605 | if ((i == 0) || (i == domainlen) || (domain[i] == '.')) | |
606 | if (prepend = constmap(&mapvdoms,domain + i,domainlen - i)) | |
607 | { | |
608 | if (!*prepend) break; | |
609 | i = str_len(prepend); | |
610 | if (str_diffn(recip,prepend,i)) break; | |
611 | if (recip[i] != '-') break; | |
612 | return recip + i + 1; | |
613 | } | |
614 | return recip; | |
615 | } | |
616 | ||
617 | stralloc bouncetext = {0}; | |
618 | ||
619 | void addbounce(id,recip,report) | |
620 | unsigned long id; | |
621 | char *recip; | |
622 | char *report; | |
623 | { | |
624 | int fd; | |
625 | int pos; | |
626 | int w; | |
627 | while (!stralloc_copys(&bouncetext,"<")) nomem(); | |
628 | while (!stralloc_cats(&bouncetext,stripvdomprepend(recip))) nomem(); | |
629 | for (pos = 0;pos < bouncetext.len;++pos) | |
630 | if (bouncetext.s[pos] == '\n') | |
631 | bouncetext.s[pos] = '_'; | |
632 | while (!stralloc_cats(&bouncetext,">:\n")) nomem(); | |
633 | while (!stralloc_cats(&bouncetext,report)) nomem(); | |
634 | if (report[0]) | |
635 | if (report[str_len(report) - 1] != '\n') | |
636 | while (!stralloc_cats(&bouncetext,"\n")) nomem(); | |
637 | for (pos = bouncetext.len - 2;pos > 0;--pos) | |
638 | if (bouncetext.s[pos] == '\n') | |
639 | if (bouncetext.s[pos - 1] == '\n') | |
640 | bouncetext.s[pos] = '/'; | |
641 | while (!stralloc_cats(&bouncetext,"\n")) nomem(); | |
642 | fnmake2_bounce(id); | |
643 | for (;;) | |
644 | { | |
645 | fd = open_append(fn2.s); | |
646 | if (fd != -1) break; | |
647 | log1("alert: unable to append to bounce message; HELP! sleeping...\n"); | |
648 | sleep(10); | |
649 | } | |
650 | pos = 0; | |
651 | while (pos < bouncetext.len) | |
652 | { | |
653 | w = write(fd,bouncetext.s + pos,bouncetext.len - pos); | |
654 | if (w <= 0) | |
655 | { | |
656 | log1("alert: unable to append to bounce message; HELP! sleeping...\n"); | |
657 | sleep(10); | |
658 | } | |
659 | else | |
660 | pos += w; | |
661 | } | |
662 | close(fd); | |
663 | } | |
664 | ||
665 | int injectbounce(id) | |
666 | unsigned long id; | |
667 | { | |
668 | struct qmail qqt; | |
669 | struct stat st; | |
670 | char *bouncesender; | |
671 | char *bouncerecip; | |
672 | int r; | |
673 | int fd; | |
674 | substdio ssread; | |
675 | char buf[128]; | |
676 | char inbuf[128]; | |
677 | static stralloc sender = {0}; | |
678 | static stralloc quoted = {0}; | |
679 | datetime_sec birth; | |
680 | unsigned long qp; | |
681 | ||
682 | if (!getinfo(&sender,&birth,id)) return 0; /* XXX: print warning */ | |
683 | ||
684 | /* owner-@host-@[] -> owner-@host */ | |
685 | if (sender.len >= 5) | |
686 | if (str_equal(sender.s + sender.len - 5,"-@[]")) | |
687 | { | |
688 | sender.len -= 4; | |
689 | sender.s[sender.len - 1] = 0; | |
690 | } | |
691 | ||
692 | fnmake2_bounce(id); | |
693 | fnmake_mess(id); | |
694 | if (stat(fn2.s,&st) == -1) | |
695 | { | |
696 | if (errno == error_noent) | |
697 | return 1; | |
698 | log3("warning: unable to stat ",fn2.s,"\n"); | |
699 | return 0; | |
700 | } | |
701 | if (str_equal(sender.s,"#@[]")) | |
702 | log3("triple bounce: discarding ",fn2.s,"\n"); | |
703 | else | |
704 | { | |
705 | if (qmail_open(&qqt) == -1) | |
706 | { log1("warning: unable to start qmail-queue, will try later\n"); return 0; } | |
707 | qp = qmail_qp(&qqt); | |
708 | ||
709 | if (*sender.s) { bouncesender = ""; bouncerecip = sender.s; } | |
710 | else { bouncesender = "#@[]"; bouncerecip = doublebounceto.s; } | |
711 | ||
712 | while (!newfield_datemake(now())) nomem(); | |
713 | qmail_put(&qqt,newfield_date.s,newfield_date.len); | |
714 | qmail_puts(&qqt,"From: "); | |
715 | while (!quote("ed,&bouncefrom)) nomem(); | |
716 | qmail_put(&qqt,quoted.s,quoted.len); | |
717 | qmail_puts(&qqt,"@"); | |
718 | qmail_put(&qqt,bouncehost.s,bouncehost.len); | |
719 | qmail_puts(&qqt,"\nTo: "); | |
720 | while (!quote2("ed,bouncerecip)) nomem(); | |
721 | qmail_put(&qqt,quoted.s,quoted.len); | |
722 | qmail_puts(&qqt,"\n\ | |
723 | Subject: failure notice\n\ | |
724 | \n\ | |
725 | Hi. This is the qmail-send program at "); | |
726 | qmail_put(&qqt,bouncehost.s,bouncehost.len); | |
727 | qmail_puts(&qqt,*sender.s ? ".\n\ | |
728 | I'm afraid I wasn't able to deliver your message to the following addresses.\n\ | |
729 | This is a permanent error; I've given up. Sorry it didn't work out.\n\ | |
730 | \n\ | |
731 | " : ".\n\ | |
732 | I tried to deliver a bounce message to this address, but the bounce bounced!\n\ | |
733 | \n\ | |
734 | "); | |
735 | ||
736 | fd = open_read(fn2.s); | |
737 | if (fd == -1) | |
738 | qmail_fail(&qqt); | |
739 | else | |
740 | { | |
741 | substdio_fdbuf(&ssread,read,fd,inbuf,sizeof(inbuf)); | |
742 | while ((r = substdio_get(&ssread,buf,sizeof(buf))) > 0) | |
743 | qmail_put(&qqt,buf,r); | |
744 | close(fd); | |
745 | if (r == -1) | |
746 | qmail_fail(&qqt); | |
747 | } | |
748 | ||
749 | qmail_puts(&qqt,*sender.s ? "--- Below this line is a copy of the message.\n\n" : "--- Below this line is the original bounce.\n\n"); | |
750 | qmail_puts(&qqt,"Return-Path: <"); | |
751 | while (!quote2("ed,sender.s)) nomem(); | |
752 | qmail_put(&qqt,quoted.s,quoted.len); | |
753 | qmail_puts(&qqt,">\n"); | |
754 | ||
755 | fd = open_read(fn.s); | |
756 | if (fd == -1) | |
757 | qmail_fail(&qqt); | |
758 | else | |
759 | { | |
760 | substdio_fdbuf(&ssread,read,fd,inbuf,sizeof(inbuf)); | |
761 | while ((r = substdio_get(&ssread,buf,sizeof(buf))) > 0) | |
762 | qmail_put(&qqt,buf,r); | |
763 | close(fd); | |
764 | if (r == -1) | |
765 | qmail_fail(&qqt); | |
766 | } | |
767 | ||
768 | qmail_from(&qqt,bouncesender); | |
769 | qmail_to(&qqt,bouncerecip); | |
770 | if (qmail_close(&qqt)) | |
771 | { log1("warning: trouble injecting bounce message, will try later\n"); return 0; } | |
772 | ||
773 | strnum2[fmt_ulong(strnum2,id)] = 0; | |
774 | log2("bounce msg ",strnum2); | |
775 | strnum2[fmt_ulong(strnum2,qp)] = 0; | |
776 | log3(" qp ",strnum2,"\n"); | |
777 | } | |
778 | if (unlink(fn2.s) == -1) | |
779 | { | |
780 | log3("warning: unable to unlink ",fn2.s,"\n"); | |
781 | return 0; | |
782 | } | |
783 | return 1; | |
784 | } | |
785 | ||
786 | ||
787 | /* this file is too long ---------------------------------------- DELIVERIES */ | |
788 | ||
789 | struct del | |
790 | { | |
791 | int used; | |
792 | int j; | |
793 | unsigned long delid; | |
794 | seek_pos mpos; | |
795 | stralloc recip; | |
796 | } | |
797 | ; | |
798 | ||
799 | unsigned long masterdelid = 1; | |
800 | unsigned int concurrency[CHANNELS] = { 10, 20 }; | |
801 | struct del *d[CHANNELS]; | |
802 | stralloc dline[CHANNELS]; | |
803 | char delbuf[2048]; | |
804 | ||
805 | void del_init() | |
806 | { | |
807 | int c; | |
808 | int i; | |
809 | for (c = 0;c < CHANNELS;++c) | |
810 | { | |
811 | flagspawnalive[c] = 1; | |
812 | while (!(d[c] = (struct del *) alloc(concurrency[c] * sizeof(struct del)))) | |
813 | nomem(); | |
814 | for (i = 0;i < concurrency[c];++i) | |
815 | { d[c][i].used = 0; d[c][i].recip.s = 0; } | |
816 | dline[c].s = 0; | |
817 | while (!stralloc_copys(&dline[c],"")) nomem(); | |
818 | } | |
819 | } | |
820 | ||
821 | int del_canexit() | |
822 | { | |
823 | int i; | |
824 | int c; | |
825 | for (c = 0;c < CHANNELS;++c) | |
826 | if (flagspawnalive[c]) /* if dead, nothing we can do about its jobs */ | |
827 | for (i = 0;i < concurrency[c];++i) | |
828 | if (d[c][i].used) return 0; | |
829 | return 1; | |
830 | } | |
831 | ||
832 | static int del_lastsaid = 0; | |
833 | ||
834 | void del_saywhynoexit() | |
835 | { | |
836 | int i; | |
837 | int c; | |
838 | int n; | |
839 | n = 0; | |
840 | for (c = 0;c < CHANNELS;++c) | |
841 | if (flagspawnalive[c]) | |
842 | for (i = 0;i < concurrency[c];++i) | |
843 | if (d[c][i].used) | |
844 | ++n; | |
845 | if (!del_lastsaid || (n < del_lastsaid)) | |
846 | { | |
847 | strnum2[fmt_ulong(strnum2,(unsigned long) n)] = 0; | |
848 | log3("number of deliveries left before exiting: ",strnum2,"\n"); | |
849 | del_lastsaid = n; | |
850 | } | |
851 | } | |
852 | ||
853 | int del_avail(c) | |
854 | int c; | |
855 | { | |
856 | int i; | |
857 | ||
858 | if (!flagspawnalive[c]) return 0; | |
859 | if (!comm_canwrite(c)) return 0; | |
860 | for (i = 0;i < concurrency[c];++i) if (!d[c][i].used) return 1; | |
861 | return 0; | |
862 | } | |
863 | ||
864 | void del_start(j,mpos,recip) | |
865 | int j; | |
866 | seek_pos mpos; | |
867 | char *recip; | |
868 | { | |
869 | int i; | |
870 | int c; | |
871 | ||
872 | c = jo[j].channel; | |
873 | if (!flagspawnalive[c]) return; | |
874 | if (!comm_canwrite(c)) return; | |
875 | ||
876 | for (i = 0;i < concurrency[c];++i) if (!d[c][i].used) break; | |
877 | if (i == concurrency[c]) return; | |
878 | ||
879 | if (!stralloc_copys(&d[c][i].recip,recip)) { nomem(); return; } | |
880 | if (!stralloc_0(&d[c][i].recip)) { nomem(); return; } | |
881 | d[c][i].j = j; ++jo[j].refs; | |
882 | d[c][i].delid = masterdelid++; | |
883 | d[c][i].mpos = mpos; | |
884 | d[c][i].used = 1; | |
885 | ||
886 | comm_write(c,i,jo[j].id,jo[j].sender.s,recip); | |
887 | ||
888 | strnum2[fmt_ulong(strnum2,d[c][i].delid)] = 0; | |
889 | strnum3[fmt_ulong(strnum3,jo[j].id)] = 0; | |
890 | log2("starting delivery ",strnum2); | |
891 | log3(": msg ",strnum3,tochan[c]); | |
892 | logsafe(recip); | |
893 | log1("\n"); | |
894 | } | |
895 | ||
896 | void markdone(c,id,pos) | |
897 | int c; | |
898 | unsigned long id; | |
899 | seek_pos pos; | |
900 | { | |
901 | struct stat st; | |
902 | int fd; | |
903 | fnmake_chanaddr(id,c); | |
904 | for (;;) | |
905 | { | |
906 | fd = open_write(fn.s); | |
907 | if (fd == -1) break; | |
908 | if (fstat(fd,&st) == -1) { close(fd); break; } | |
909 | if (seek_set(fd,pos) == -1) { close(fd); break; } | |
910 | if (write(fd,"D",1) != 1) { close(fd); break; } | |
911 | /* further errors -> double delivery without us knowing about it, oh well */ | |
912 | close(fd); | |
913 | return; | |
914 | } | |
915 | log3("warning: trouble marking ",fn.s,"; message will be delivered twice!\n"); | |
916 | } | |
917 | ||
918 | void del_dochan(c) | |
919 | int c; | |
920 | { | |
921 | int r; | |
922 | char ch; | |
923 | int i; | |
924 | int delnum; | |
925 | r = read(chanfdin[c],delbuf,sizeof(delbuf)); | |
926 | if (r == -1) return; | |
927 | if (r == 0) { spawndied(c); return; } | |
928 | for (i = 0;i < r;++i) | |
929 | { | |
930 | ch = delbuf[i]; | |
931 | while (!stralloc_append(&dline[c],&ch)) nomem(); | |
932 | if (dline[c].len > REPORTMAX) | |
933 | dline[c].len = REPORTMAX; | |
934 | /* qmail-lspawn and qmail-rspawn are responsible for keeping it short */ | |
935 | /* but from a security point of view, we don't trust rspawn */ | |
936 | if (!ch && (dline[c].len > 1)) | |
937 | { | |
938 | delnum = (unsigned int) (unsigned char) dline[c].s[0]; | |
939 | if ((delnum < 0) || (delnum >= concurrency[c]) || !d[c][delnum].used) | |
940 | log1("warning: internal error: delivery report out of range\n"); | |
941 | else | |
942 | { | |
943 | strnum3[fmt_ulong(strnum3,d[c][delnum].delid)] = 0; | |
944 | if (dline[c].s[1] == 'Z') | |
945 | if (jo[d[c][delnum].j].flagdying) | |
946 | { | |
947 | dline[c].s[1] = 'D'; | |
948 | --dline[c].len; | |
949 | while (!stralloc_cats(&dline[c],"I'm not going to try again; this message has been in the queue too long.\n")) nomem(); | |
950 | while (!stralloc_0(&dline[c])) nomem(); | |
951 | } | |
952 | switch(dline[c].s[1]) | |
953 | { | |
954 | case 'K': | |
955 | log3("delivery ",strnum3,": success: "); | |
956 | logsafe(dline[c].s + 2); | |
957 | log1("\n"); | |
958 | markdone(c,jo[d[c][delnum].j].id,d[c][delnum].mpos); | |
959 | --jo[d[c][delnum].j].numtodo; | |
960 | break; | |
961 | case 'Z': | |
962 | log3("delivery ",strnum3,": deferral: "); | |
963 | logsafe(dline[c].s + 2); | |
964 | log1("\n"); | |
965 | break; | |
966 | case 'D': | |
967 | log3("delivery ",strnum3,": failure: "); | |
968 | logsafe(dline[c].s + 2); | |
969 | log1("\n"); | |
970 | addbounce(jo[d[c][delnum].j].id,d[c][delnum].recip.s,dline[c].s + 2); | |
971 | markdone(c,jo[d[c][delnum].j].id,d[c][delnum].mpos); | |
972 | --jo[d[c][delnum].j].numtodo; | |
973 | break; | |
974 | default: | |
975 | log3("delivery ",strnum3,": report mangled, will defer\n"); | |
976 | } | |
977 | job_close(d[c][delnum].j); | |
978 | d[c][delnum].used = 0; | |
979 | } | |
980 | dline[c].len = 0; | |
981 | } | |
982 | } | |
983 | } | |
984 | ||
985 | void del_selprep(nfds,rfds) | |
986 | int *nfds; | |
987 | fd_set *rfds; | |
988 | { | |
989 | int c; | |
990 | for (c = 0;c < CHANNELS;++c) | |
991 | if (flagspawnalive[c]) | |
992 | { | |
993 | FD_SET(chanfdin[c],rfds); | |
994 | if (*nfds <= chanfdin[c]) | |
995 | *nfds = chanfdin[c] + 1; | |
996 | } | |
997 | } | |
998 | ||
999 | void del_do(rfds) | |
1000 | fd_set *rfds; | |
1001 | { | |
1002 | int c; | |
1003 | for (c = 0;c < CHANNELS;++c) | |
1004 | if (flagspawnalive[c]) | |
1005 | if (FD_ISSET(chanfdin[c],rfds)) | |
1006 | del_dochan(c); | |
1007 | } | |
1008 | ||
1009 | ||
1010 | /* this file is too long -------------------------------------------- PASSES */ | |
1011 | ||
1012 | struct | |
1013 | { | |
1014 | unsigned long id; /* if 0, need a new pass */ | |
1015 | int j; /* defined if id; job number */ | |
1016 | int fd; /* defined if id; reading from {local,remote} */ | |
1017 | seek_pos mpos; /* defined if id; mark position */ | |
1018 | substdio ss; | |
1019 | char buf[128]; | |
1020 | } | |
1021 | pass[CHANNELS]; | |
1022 | ||
1023 | void pass_init() | |
1024 | { | |
1025 | int c; | |
1026 | for (c = 0;c < CHANNELS;++c) pass[c].id = 0; | |
1027 | } | |
1028 | ||
1029 | void pass_selprep(wakeup) | |
1030 | datetime_sec *wakeup; | |
1031 | { | |
1032 | int c; | |
1033 | struct prioq_elt pe; | |
1034 | if (flagexitasap) return; | |
1035 | for (c = 0;c < CHANNELS;++c) | |
1036 | if (pass[c].id) | |
1037 | if (del_avail(c)) | |
1038 | { *wakeup = 0; return; } | |
1039 | if (job_avail()) | |
1040 | for (c = 0;c < CHANNELS;++c) | |
1041 | if (!pass[c].id) | |
1042 | if (prioq_min(&pqchan[c],&pe)) | |
1043 | if (*wakeup > pe.dt) | |
1044 | *wakeup = pe.dt; | |
1045 | if (prioq_min(&pqfail,&pe)) | |
1046 | if (*wakeup > pe.dt) | |
1047 | *wakeup = pe.dt; | |
1048 | if (prioq_min(&pqdone,&pe)) | |
1049 | if (*wakeup > pe.dt) | |
1050 | *wakeup = pe.dt; | |
1051 | } | |
1052 | ||
1053 | static datetime_sec squareroot(x) /* result^2 <= x < (result + 1)^2 */ | |
1054 | datetime_sec x; /* assuming: >= 0 */ | |
1055 | { | |
1056 | datetime_sec y; | |
1057 | datetime_sec yy; | |
1058 | datetime_sec y21; | |
1059 | int j; | |
1060 | ||
1061 | y = 0; yy = 0; | |
1062 | for (j = 15;j >= 0;--j) | |
1063 | { | |
1064 | y21 = (y << (j + 1)) + (1 << (j + j)); | |
1065 | if (y21 <= x - yy) { y += (1 << j); yy += y21; } | |
1066 | } | |
1067 | return y; | |
1068 | } | |
1069 | ||
1070 | datetime_sec nextretry(birth,c) | |
1071 | datetime_sec birth; | |
1072 | int c; | |
1073 | { | |
1074 | int n; | |
1075 | ||
1076 | if (birth > recent) n = 0; | |
1077 | else n = squareroot(recent - birth); /* no need to add fuzz to recent */ | |
1078 | n += chanskip[c]; | |
1079 | return birth + n * n; | |
1080 | } | |
1081 | ||
1082 | void pass_dochan(c) | |
1083 | int c; | |
1084 | { | |
1085 | datetime_sec birth; | |
1086 | struct prioq_elt pe; | |
1087 | static stralloc line = {0}; | |
1088 | int match; | |
1089 | ||
1090 | if (flagexitasap) return; | |
1091 | ||
1092 | if (!pass[c].id) | |
1093 | { | |
1094 | if (!job_avail()) return; | |
1095 | if (!prioq_min(&pqchan[c],&pe)) return; | |
1096 | if (pe.dt > recent) return; | |
1097 | fnmake_chanaddr(pe.id,c); | |
1098 | ||
1099 | prioq_delmin(&pqchan[c]); | |
1100 | pass[c].mpos = 0; | |
1101 | pass[c].fd = open_read(fn.s); | |
1102 | if (pass[c].fd == -1) goto trouble; | |
1103 | if (!getinfo(&line,&birth,pe.id)) { close(pass[c].fd); goto trouble; } | |
1104 | pass[c].id = pe.id; | |
1105 | substdio_fdbuf(&pass[c].ss,read,pass[c].fd,pass[c].buf,sizeof(pass[c].buf)); | |
1106 | pass[c].j = job_open(pe.id,c); | |
1107 | jo[pass[c].j].retry = nextretry(birth,c); | |
1108 | jo[pass[c].j].flagdying = (recent > birth + lifetime); | |
1109 | while (!stralloc_copy(&jo[pass[c].j].sender,&line)) nomem(); | |
1110 | } | |
1111 | ||
1112 | if (!del_avail(c)) return; | |
1113 | ||
1114 | if (getln(&pass[c].ss,&line,&match,'\0') == -1) | |
1115 | { | |
1116 | fnmake_chanaddr(pass[c].id,c); | |
1117 | log3("warning: trouble reading ",fn.s,"; will try again later\n"); | |
1118 | close(pass[c].fd); | |
1119 | job_close(pass[c].j); | |
1120 | pass[c].id = 0; | |
1121 | return; | |
1122 | } | |
1123 | if (!match) | |
1124 | { | |
1125 | close(pass[c].fd); | |
1126 | jo[pass[c].j].flaghiteof = 1; | |
1127 | job_close(pass[c].j); | |
1128 | pass[c].id = 0; | |
1129 | return; | |
1130 | } | |
1131 | switch(line.s[0]) | |
1132 | { | |
1133 | case 'T': | |
1134 | ++jo[pass[c].j].numtodo; | |
1135 | del_start(pass[c].j,pass[c].mpos,line.s + 1); | |
1136 | break; | |
1137 | case 'D': | |
1138 | break; | |
1139 | default: | |
1140 | fnmake_chanaddr(pass[c].id,c); | |
1141 | log3("warning: unknown record type in ",fn.s,"!\n"); | |
1142 | close(pass[c].fd); | |
1143 | job_close(pass[c].j); | |
1144 | pass[c].id = 0; | |
1145 | return; | |
1146 | } | |
1147 | ||
1148 | pass[c].mpos += line.len; | |
1149 | return; | |
1150 | ||
1151 | trouble: | |
1152 | log3("warning: trouble opening ",fn.s,"; will try again later\n"); | |
1153 | pe.dt = recent + SLEEP_SYSFAIL; | |
1154 | while (!prioq_insert(&pqchan[c],&pe)) nomem(); | |
1155 | } | |
1156 | ||
1157 | void messdone(id) | |
1158 | unsigned long id; | |
1159 | { | |
1160 | char ch; | |
1161 | int c; | |
1162 | struct prioq_elt pe; | |
1163 | struct stat st; | |
1164 | ||
1165 | for (c = 0;c < CHANNELS;++c) | |
1166 | { | |
1167 | fnmake_chanaddr(id,c); | |
1168 | if (stat(fn.s,&st) == 0) return; /* false alarm; consequence of HOPEFULLY */ | |
1169 | if (errno != error_noent) | |
1170 | { | |
1171 | log3("warning: unable to stat ",fn.s,"; will try again later\n"); | |
1172 | goto fail; | |
1173 | } | |
1174 | } | |
1175 | ||
1176 | fnmake_todo(id); | |
1177 | if (stat(fn.s,&st) == 0) return; | |
1178 | if (errno != error_noent) | |
1179 | { | |
1180 | log3("warning: unable to stat ",fn.s,"; will try again later\n"); | |
1181 | goto fail; | |
1182 | } | |
1183 | ||
1184 | fnmake_info(id); | |
1185 | if (stat(fn.s,&st) == -1) | |
1186 | { | |
1187 | if (errno == error_noent) return; | |
1188 | log3("warning: unable to stat ",fn.s,"; will try again later\n"); | |
1189 | goto fail; | |
1190 | } | |
1191 | ||
1192 | /* -todo +info -local -remote ?bounce */ | |
1193 | if (!injectbounce(id)) | |
1194 | goto fail; /* injectbounce() produced error message */ | |
1195 | ||
1196 | strnum3[fmt_ulong(strnum3,id)] = 0; | |
1197 | log3("end msg ",strnum3,"\n"); | |
1198 | ||
1199 | /* -todo +info -local -remote -bounce */ | |
1200 | fnmake_info(id); | |
1201 | if (unlink(fn.s) == -1) | |
1202 | { | |
1203 | log3("warning: unable to unlink ",fn.s,"; will try again later\n"); | |
1204 | goto fail; | |
1205 | } | |
1206 | ||
1207 | /* -todo -info -local -remote -bounce; we can relax */ | |
1208 | fnmake_foop(id); | |
1209 | if (substdio_putflush(&sstoqc,fn.s,fn.len) == -1) { cleandied(); return; } | |
1210 | if (substdio_get(&ssfromqc,&ch,1) != 1) { cleandied(); return; } | |
1211 | if (ch != '+') | |
1212 | log3("warning: qmail-clean unable to clean up ",fn.s,"\n"); | |
1213 | ||
1214 | return; | |
1215 | ||
1216 | fail: | |
1217 | pe.id = id; pe.dt = now() + SLEEP_SYSFAIL; | |
1218 | while (!prioq_insert(&pqdone,&pe)) nomem(); | |
1219 | } | |
1220 | ||
1221 | void pass_do() | |
1222 | { | |
1223 | int c; | |
1224 | struct prioq_elt pe; | |
1225 | ||
1226 | for (c = 0;c < CHANNELS;++c) pass_dochan(c); | |
1227 | if (prioq_min(&pqfail,&pe)) | |
1228 | if (pe.dt <= recent) | |
1229 | { | |
1230 | prioq_delmin(&pqfail); | |
1231 | pqadd(pe.id); | |
1232 | } | |
1233 | if (prioq_min(&pqdone,&pe)) | |
1234 | if (pe.dt <= recent) | |
1235 | { | |
1236 | prioq_delmin(&pqdone); | |
1237 | messdone(pe.id); | |
1238 | } | |
1239 | } | |
1240 | ||
1241 | ||
1242 | /* this file is too long ---------------------------------------------- TODO */ | |
1243 | ||
1244 | datetime_sec nexttodorun; | |
1245 | DIR *tododir; /* if 0, have to opendir again */ | |
1246 | stralloc todoline = {0}; | |
1247 | char todobuf[SUBSTDIO_INSIZE]; | |
1248 | char todobufinfo[512]; | |
1249 | char todobufchan[CHANNELS][1024]; | |
1250 | ||
1251 | void todo_init() | |
1252 | { | |
1253 | tododir = 0; | |
1254 | nexttodorun = now(); | |
1255 | trigger_set(); | |
1256 | } | |
1257 | ||
1258 | void todo_selprep(nfds,rfds,wakeup) | |
1259 | int *nfds; | |
1260 | fd_set *rfds; | |
1261 | datetime_sec *wakeup; | |
1262 | { | |
1263 | if (flagexitasap) return; | |
1264 | trigger_selprep(nfds,rfds); | |
1265 | if (tododir) *wakeup = 0; | |
1266 | if (*wakeup > nexttodorun) *wakeup = nexttodorun; | |
1267 | } | |
1268 | ||
1269 | void todo_do(rfds) | |
1270 | fd_set *rfds; | |
1271 | { | |
1272 | struct stat st; | |
1273 | substdio ss; int fd; | |
1274 | substdio ssinfo; int fdinfo; | |
1275 | substdio sschan[CHANNELS]; | |
1276 | int fdchan[CHANNELS]; | |
1277 | int flagchan[CHANNELS]; | |
1278 | struct prioq_elt pe; | |
1279 | char ch; | |
1280 | int match; | |
1281 | unsigned long id; | |
1282 | unsigned int len; | |
1283 | direntry *d; | |
1284 | int c; | |
1285 | unsigned long uid; | |
1286 | unsigned long pid; | |
1287 | ||
1288 | fd = -1; | |
1289 | fdinfo = -1; | |
1290 | for (c = 0;c < CHANNELS;++c) fdchan[c] = -1; | |
1291 | ||
1292 | if (flagexitasap) return; | |
1293 | ||
1294 | if (!tododir) | |
1295 | { | |
1296 | if (!trigger_pulled(rfds)) | |
1297 | if (recent < nexttodorun) | |
1298 | return; | |
1299 | trigger_set(); | |
1300 | tododir = opendir("todo"); | |
1301 | if (!tododir) | |
1302 | { | |
1303 | pausedir("todo"); | |
1304 | return; | |
1305 | } | |
1306 | nexttodorun = recent + SLEEP_TODO; | |
1307 | } | |
1308 | ||
1309 | d = readdir(tododir); | |
1310 | if (!d) | |
1311 | { | |
1312 | closedir(tododir); | |
1313 | tododir = 0; | |
1314 | return; | |
1315 | } | |
1316 | if (str_equal(d->d_name,".")) return; | |
1317 | if (str_equal(d->d_name,"..")) return; | |
1318 | len = scan_ulong(d->d_name,&id); | |
1319 | if (!len || d->d_name[len]) return; | |
1320 | ||
1321 | fnmake_todo(id); | |
1322 | ||
1323 | fd = open_read(fn.s); | |
1324 | if (fd == -1) { log3("warning: unable to open ",fn.s,"\n"); return; } | |
1325 | ||
1326 | fnmake_mess(id); | |
1327 | /* just for the statistics */ | |
1328 | if (stat(fn.s,&st) == -1) | |
1329 | { log3("warning: unable to stat ",fn.s,"\n"); goto fail; } | |
1330 | ||
1331 | for (c = 0;c < CHANNELS;++c) | |
1332 | { | |
1333 | fnmake_chanaddr(id,c); | |
1334 | if (unlink(fn.s) == -1) if (errno != error_noent) | |
1335 | { log3("warning: unable to unlink ",fn.s,"\n"); goto fail; } | |
1336 | } | |
1337 | ||
1338 | fnmake_info(id); | |
1339 | if (unlink(fn.s) == -1) if (errno != error_noent) | |
1340 | { log3("warning: unable to unlink ",fn.s,"\n"); goto fail; } | |
1341 | ||
1342 | fdinfo = open_excl(fn.s); | |
1343 | if (fdinfo == -1) | |
1344 | { log3("warning: unable to create ",fn.s,"\n"); goto fail; } | |
1345 | ||
1346 | strnum3[fmt_ulong(strnum3,id)] = 0; | |
1347 | log3("new msg ",strnum3,"\n"); | |
1348 | ||
1349 | for (c = 0;c < CHANNELS;++c) flagchan[c] = 0; | |
1350 | ||
1351 | substdio_fdbuf(&ss,read,fd,todobuf,sizeof(todobuf)); | |
1352 | substdio_fdbuf(&ssinfo,write,fdinfo,todobufinfo,sizeof(todobufinfo)); | |
1353 | ||
1354 | uid = 0; | |
1355 | pid = 0; | |
1356 | ||
1357 | for (;;) | |
1358 | { | |
1359 | if (getln(&ss,&todoline,&match,'\0') == -1) | |
1360 | { | |
1361 | /* perhaps we're out of memory, perhaps an I/O error */ | |
1362 | fnmake_todo(id); | |
1363 | log3("warning: trouble reading ",fn.s,"\n"); goto fail; | |
1364 | } | |
1365 | if (!match) break; | |
1366 | ||
1367 | switch(todoline.s[0]) | |
1368 | { | |
1369 | case 'u': | |
1370 | scan_ulong(todoline.s + 1,&uid); | |
1371 | break; | |
1372 | case 'p': | |
1373 | scan_ulong(todoline.s + 1,&pid); | |
1374 | break; | |
1375 | case 'F': | |
1376 | if (substdio_putflush(&ssinfo,todoline.s,todoline.len) == -1) | |
1377 | { | |
1378 | fnmake_info(id); | |
1379 | log3("warning: trouble writing to ",fn.s,"\n"); goto fail; | |
1380 | } | |
1381 | log2("info msg ",strnum3); | |
1382 | strnum2[fmt_ulong(strnum2,(unsigned long) st.st_size)] = 0; | |
1383 | log2(": bytes ",strnum2); | |
1384 | log1(" from <"); logsafe(todoline.s + 1); | |
1385 | strnum2[fmt_ulong(strnum2,pid)] = 0; | |
1386 | log2("> qp ",strnum2); | |
1387 | strnum2[fmt_ulong(strnum2,uid)] = 0; | |
1388 | log2(" uid ",strnum2); | |
1389 | log1("\n"); | |
1390 | break; | |
1391 | case 'T': | |
1392 | switch(rewrite(todoline.s + 1)) | |
1393 | { | |
1394 | case 0: nomem(); goto fail; | |
1395 | case 2: c = 1; break; | |
1396 | default: c = 0; break; | |
1397 | } | |
1398 | if (fdchan[c] == -1) | |
1399 | { | |
1400 | fnmake_chanaddr(id,c); | |
1401 | fdchan[c] = open_excl(fn.s); | |
1402 | if (fdchan[c] == -1) | |
1403 | { log3("warning: unable to create ",fn.s,"\n"); goto fail; } | |
1404 | substdio_fdbuf(&sschan[c] | |
1405 | ,write,fdchan[c],todobufchan[c],sizeof(todobufchan[c])); | |
1406 | flagchan[c] = 1; | |
1407 | } | |
1408 | if (substdio_bput(&sschan[c],rwline.s,rwline.len) == -1) | |
1409 | { | |
1410 | fnmake_chanaddr(id,c); | |
1411 | log3("warning: trouble writing to ",fn.s,"\n"); goto fail; | |
1412 | } | |
1413 | break; | |
1414 | default: | |
1415 | fnmake_todo(id); | |
1416 | log3("warning: unknown record type in ",fn.s,"\n"); goto fail; | |
1417 | } | |
1418 | } | |
1419 | ||
1420 | close(fd); fd = -1; | |
1421 | ||
1422 | fnmake_info(id); | |
1423 | if (substdio_flush(&ssinfo) == -1) | |
1424 | { log3("warning: trouble writing to ",fn.s,"\n"); goto fail; } | |
1425 | if (fsync(fdinfo) == -1) | |
1426 | { log3("warning: trouble fsyncing ",fn.s,"\n"); goto fail; } | |
1427 | close(fdinfo); fdinfo = -1; | |
1428 | ||
1429 | for (c = 0;c < CHANNELS;++c) | |
1430 | if (fdchan[c] != -1) | |
1431 | { | |
1432 | fnmake_chanaddr(id,c); | |
1433 | if (substdio_flush(&sschan[c]) == -1) | |
1434 | { log3("warning: trouble writing to ",fn.s,"\n"); goto fail; } | |
1435 | if (fsync(fdchan[c]) == -1) | |
1436 | { log3("warning: trouble fsyncing ",fn.s,"\n"); goto fail; } | |
1437 | close(fdchan[c]); fdchan[c] = -1; | |
1438 | } | |
1439 | ||
1440 | fnmake_todo(id); | |
1441 | if (substdio_putflush(&sstoqc,fn.s,fn.len) == -1) { cleandied(); return; } | |
1442 | if (substdio_get(&ssfromqc,&ch,1) != 1) { cleandied(); return; } | |
1443 | if (ch != '+') | |
1444 | { | |
1445 | log3("warning: qmail-clean unable to clean up ",fn.s,"\n"); | |
1446 | return; | |
1447 | } | |
1448 | ||
1449 | pe.id = id; pe.dt = now(); | |
1450 | for (c = 0;c < CHANNELS;++c) | |
1451 | if (flagchan[c]) | |
1452 | while (!prioq_insert(&pqchan[c],&pe)) nomem(); | |
1453 | ||
1454 | for (c = 0;c < CHANNELS;++c) if (flagchan[c]) break; | |
1455 | if (c == CHANNELS) | |
1456 | while (!prioq_insert(&pqdone,&pe)) nomem(); | |
1457 | ||
1458 | return; | |
1459 | ||
1460 | fail: | |
1461 | if (fd != -1) close(fd); | |
1462 | if (fdinfo != -1) close(fdinfo); | |
1463 | for (c = 0;c < CHANNELS;++c) | |
1464 | if (fdchan[c] != -1) close(fdchan[c]); | |
1465 | } | |
1466 | ||
1467 | ||
1468 | /* this file is too long ---------------------------------------------- MAIN */ | |
1469 | ||
1470 | int getcontrols() { if (control_init() == -1) return 0; | |
1471 | if (control_readint(&lifetime,"control/queuelifetime") == -1) return 0; | |
1472 | if (control_readint(&concurrency[0],"control/concurrencylocal") == -1) return 0; | |
1473 | if (control_readint(&concurrency[1],"control/concurrencyremote") == -1) return 0; | |
1474 | if (control_rldef(&envnoathost,"control/envnoathost",1,"envnoathost") != 1) return 0; | |
1475 | if (control_rldef(&bouncefrom,"control/bouncefrom",0,"MAILER-DAEMON") != 1) return 0; | |
1476 | if (control_rldef(&bouncehost,"control/bouncehost",1,"bouncehost") != 1) return 0; | |
1477 | if (control_rldef(&doublebouncehost,"control/doublebouncehost",1,"doublebouncehost") != 1) return 0; | |
1478 | if (control_rldef(&doublebounceto,"control/doublebounceto",0,"postmaster") != 1) return 0; | |
1479 | if (!stralloc_cats(&doublebounceto,"@")) return 0; | |
1480 | if (!stralloc_cat(&doublebounceto,&doublebouncehost)) return 0; | |
1481 | if (!stralloc_0(&doublebounceto)) return 0; | |
1482 | if (control_readfile(&locals,"control/locals",1) != 1) return 0; | |
1483 | if (!constmap_init(&maplocals,locals.s,locals.len,0)) return 0; | |
1484 | switch(control_readfile(&percenthack,"control/percenthack",0)) | |
1485 | { | |
1486 | case -1: return 0; | |
1487 | case 0: if (!constmap_init(&mappercenthack,"",0,0)) return 0; break; | |
1488 | case 1: if (!constmap_init(&mappercenthack,percenthack.s,percenthack.len,0)) return 0; break; | |
1489 | } | |
1490 | switch(control_readfile(&redir,"control/recipientmap",0)) | |
1491 | { | |
1492 | case -1: return 0; | |
1493 | case 0: if (!constmap_init(&mapredir,"",0,1)) return 0; break; | |
1494 | case 1: if (!constmap_init(&mapredir,redir.s,redir.len,1)) return 0; break; | |
1495 | } | |
1496 | switch(control_readfile(&vdoms,"control/virtualdomains",0)) | |
1497 | { | |
1498 | case -1: return 0; | |
1499 | case 0: if (!constmap_init(&mapvdoms,"",0,1)) return 0; break; | |
1500 | case 1: if (!constmap_init(&mapvdoms,vdoms.s,vdoms.len,1)) return 0; break; | |
1501 | } | |
1502 | return 1; } | |
1503 | ||
1504 | stralloc newlocals = {0}; | |
1505 | stralloc newvdoms = {0}; | |
1506 | ||
1507 | void regetcontrols() | |
1508 | { | |
1509 | int r; | |
1510 | ||
1511 | if (control_readfile(&newlocals,"control/locals",1) != 1) | |
1512 | { log1("alert: unable to reread control/locals\n"); return; } | |
1513 | r = control_readfile(&newvdoms,"control/virtualdomains",0); | |
1514 | if (r == -1) | |
1515 | { log1("alert: unable to reread control/virtualdomains\n"); return; } | |
1516 | ||
1517 | constmap_free(&maplocals); | |
1518 | constmap_free(&mapvdoms); | |
1519 | ||
1520 | while (!stralloc_copy(&locals,&newlocals)) nomem(); | |
1521 | while (!constmap_init(&maplocals,locals.s,locals.len,0)) nomem(); | |
1522 | ||
1523 | if (r) | |
1524 | { | |
1525 | while (!stralloc_copy(&vdoms,&newvdoms)) nomem(); | |
1526 | while (!constmap_init(&mapvdoms,vdoms.s,vdoms.len,1)) nomem(); | |
1527 | } | |
1528 | else | |
1529 | while (!constmap_init(&mapvdoms,"",0,1)) nomem(); | |
1530 | } | |
1531 | ||
1532 | void reread() | |
1533 | { | |
1534 | if (chdir(auto_qmail) == -1) | |
1535 | { | |
1536 | log1("alert: unable to reread controls: unable to switch to home directory\n"); | |
1537 | return; | |
1538 | } | |
1539 | regetcontrols(); | |
1540 | while (chdir("queue") == -1) | |
1541 | { | |
1542 | log1("alert: unable to switch back to queue directory; HELP! sleeping...\n"); | |
1543 | sleep(10); | |
1544 | } | |
1545 | } | |
1546 | ||
1547 | void main() | |
1548 | { | |
1549 | int fd; | |
1550 | datetime_sec wakeup; | |
1551 | fd_set rfds; | |
1552 | fd_set wfds; | |
1553 | int nfds; | |
1554 | struct timeval tv; | |
1555 | int c; | |
1556 | ||
1557 | if (chdir(auto_qmail) == -1) | |
1558 | { log1("alert: cannot start: unable to switch to home directory\n"); _exit(111); } | |
1559 | if (!getcontrols()) | |
1560 | { log1("alert: cannot start: unable to read controls\n"); _exit(111); } | |
1561 | if (chdir("queue") == -1) | |
1562 | { log1("alert: cannot start: unable to switch to queue directory\n"); _exit(111); } | |
1563 | sig_pipeignore(); | |
1564 | sig_termcatch(sigterm); | |
1565 | sig_alarmcatch(sigalrm); | |
1566 | sig_hangupcatch(sighup); | |
1567 | sig_childdefault(); | |
1568 | umask(077); | |
1569 | ||
1570 | fd = open_write("lock/sendmutex"); | |
1571 | if (fd == -1) | |
1572 | { log1("alert: cannot start: unable to open mutex\n"); _exit(111); } | |
1573 | if (lock_exnb(fd) == -1) | |
1574 | { log1("alert: cannot start: qmail-send is already running\n"); _exit(111); } | |
1575 | ||
1576 | numjobs = 0; | |
1577 | for (c = 0;c < CHANNELS;++c) | |
1578 | { | |
1579 | char ch; | |
1580 | int u; | |
1581 | int r; | |
1582 | do | |
1583 | r = read(chanfdin[c],&ch,1); | |
1584 | while ((r == -1) && (errno == error_intr)); | |
1585 | if (r < 1) | |
1586 | { log1("alert: cannot start: hath the daemon spawn no fire?\n"); _exit(111); } | |
1587 | u = (unsigned int) (unsigned char) ch; | |
1588 | if (concurrency[c] > u) concurrency[c] = u; | |
1589 | numjobs += concurrency[c]; | |
1590 | } | |
1591 | ||
1592 | log1("running\n"); | |
1593 | ||
1594 | fnmake_init(); | |
1595 | ||
1596 | for (c = 0;c < CHANNELS;++c) | |
1597 | if (!concurrency[c]) | |
1598 | log1(channodelmsg[c]); | |
1599 | ||
1600 | comm_init(); | |
1601 | ||
1602 | pqstart(); | |
1603 | job_init(); | |
1604 | del_init(); | |
1605 | pass_init(); | |
1606 | todo_init(); | |
1607 | cleanup_init(); | |
1608 | ||
1609 | while (!flagexitasap || !del_canexit()) | |
1610 | { | |
1611 | if (flagexitasap) del_saywhynoexit(); | |
1612 | ||
1613 | recent = now(); | |
1614 | ||
1615 | if (flagrunasap) { flagrunasap = 0; pqrun(); } | |
1616 | if (flagreadasap) { flagreadasap = 0; reread(); } | |
1617 | ||
1618 | wakeup = recent + SLEEP_FOREVER; | |
1619 | FD_ZERO(&rfds); | |
1620 | FD_ZERO(&wfds); | |
1621 | nfds = 1; | |
1622 | ||
1623 | comm_selprep(&nfds,&wfds); | |
1624 | del_selprep(&nfds,&rfds); | |
1625 | pass_selprep(&wakeup); | |
1626 | todo_selprep(&nfds,&rfds,&wakeup); | |
1627 | cleanup_selprep(&wakeup); | |
1628 | ||
1629 | if (wakeup <= recent) tv.tv_sec = 0; | |
1630 | else tv.tv_sec = wakeup - recent + SLEEP_FUZZ; | |
1631 | tv.tv_usec = 0; | |
1632 | ||
1633 | if (select(nfds,&rfds,&wfds,(fd_set *) 0,&tv) == -1) | |
1634 | if (errno == error_intr) | |
1635 | ; | |
1636 | else | |
1637 | log1("warning: trouble in select\n"); | |
1638 | else | |
1639 | { | |
1640 | recent = now(); | |
1641 | ||
1642 | comm_do(&wfds); | |
1643 | del_do(&rfds); | |
1644 | todo_do(&rfds); | |
1645 | pass_do(); | |
1646 | cleanup_do(); | |
1647 | } | |
1648 | } | |
1649 | pqfinish(); | |
1650 | log1("exiting\n"); | |
1651 | _exit(0); | |
1652 | } |