masqmail-0.2

view src/pop3_in.c @ 171:349518b940db

find changesets by author, revision, files, or words in the commit message
added support for STARTTLS wrappers added the route config option `instant_helo' which causes masqmail, as SMTP client, not to wait for the server's 220 greeting. Instead if says EHLO right at once. You'll need this for STARTTLS wrappers that usually eat the greeting line.
author meillo@marmaro.de
date Thu, 22 Jul 2010 23:30:05 +0200
parents 2685e59f6f43
children
line source
1 /* pop3_in.c, Copyright (C) 2000 by Oliver Kurth,
2 *
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2 of the License, or
6 * (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
16 */
17
18 /* see RFC 1725 */
19
20 #include <sys/wait.h>
21 #include <sys/stat.h>
22
23 #include "masqmail.h"
24 #include "pop3_in.h"
25 #include "readsock.h"
26
27 #ifdef USE_LIB_CRYPTO
28 #include <openssl/md5.h>
29 #else
30 #include "md5/md5.h"
31 #endif
32
33 #ifdef ENABLE_POP3
34
35 /* experimental feature */
36 #define DO_WRITE_UIDL_EARLY 1
37
38 static gchar*
39 MD5String(char *string)
40 {
41 MD5_CTX context;
42 unsigned char digest[16];
43 char str_digest[33];
44 int i;
45
46 #ifdef USE_LIB_CRYPTO
47 MD5(string, strlen(string), digest);
48 #else
49 MD5_Init(&context);
50 MD5_Update(&context, string, strlen(string));
51 MD5_Final(digest, &context);
52 #endif
53 for (i = 0; i < 16; i++)
54 sprintf(str_digest + 2 * i, "%02x", digest[i]);
55
56 return g_strdup(str_digest);
57 }
58
59 static pop3_base*
60 create_pop3base(gint sock, guint flags)
61 {
62 gint dup_sock;
63
64 pop3_base *popb = (pop3_base *) g_malloc(sizeof(pop3_base));
65 if (popb) {
66 memset(popb, 0, sizeof(pop3_base));
67
68 popb->error = pop3_ok;
69
70 popb->buffer = (gchar *) g_malloc(POP3_BUF_LEN);
71
72 dup_sock = dup(sock);
73 popb->out = fdopen(sock, "w");
74 popb->in = fdopen(dup_sock, "r");
75
76 popb->flags = flags;
77 }
78 return popb;
79 }
80
81 static void
82 pop3_printf(FILE * out, gchar * fmt, ...)
83 {
84 va_list args;
85 va_start(args, fmt);
86
87 DEBUG(4) {
88 gchar buf[256];
89 va_list args_copy;
90
91 va_copy(args_copy, args);
92 vsnprintf(buf, 255, fmt, args_copy);
93 va_end(args_copy);
94
95 debugf(">>>%s", buf);
96 }
97
98 vfprintf(out, fmt, args);
99 fflush(out);
100
101 va_end(args);
102 }
103
104 static gboolean
105 find_uid(pop3_base * popb, gchar * str)
106 {
107 GList *node, *node_next;
108
109 for (node = popb->list_uid_old; node; node = node_next) {
110 gchar *uid = (gchar *) (node->data);
111 node_next = node->next;
112 if (strcmp(uid, str) == 0) {
113 #if 1
114 popb->list_uid_old = g_list_remove_link(popb->list_uid_old, node);
115 g_list_free_1(node);
116 g_free(uid);
117 #endif
118 return TRUE;
119 }
120 }
121 return FALSE;
122 }
123
124 static gboolean
125 write_uidl(pop3_base * popb, gchar * user)
126 {
127 gboolean ok = FALSE;
128 GList *node;
129 gchar *filename = g_strdup_printf("%s/popuidl/%s@%s", conf.spool_dir, user, popb->remote_host);
130 gchar *tmpname = g_strdup_printf("%s.tmp", filename);
131 FILE *fptr = fopen(tmpname, "wt");
132
133 if (fptr) {
134 foreach(popb->drop_list, node) {
135 msg_info *info = (msg_info *) (node->data);
136 if (info->is_fetched || info->is_in_uidl)
137 fprintf(fptr, "%s\n", info->uid);
138 }
139 fclose(fptr);
140 ok = (rename(tmpname, filename) != -1);
141 }
142
143 g_free(tmpname);
144 g_free(filename);
145 return ok;
146 }
147
148 static gboolean
149 read_uidl_fname(pop3_base * popb, gchar * filename)
150 {
151 gboolean ok = FALSE;
152 FILE *fptr = fopen(filename, "rt");
153 gchar buf[256];
154
155 if (fptr) {
156 popb->list_uid_old = NULL;
157 while (fgets(buf, 255, fptr)) {
158 if (buf[strlen(buf) - 1] == '\n') {
159 g_strchomp(buf);
160 popb->list_uid_old = g_list_append(popb->list_uid_old, g_strdup(buf));
161 } else {
162 logwrite(LOG_ALERT, "broken uid: %s\n", buf);
163 break;
164 }
165 }
166 fclose(fptr);
167 ok = TRUE;
168 } else
169 logwrite(LOG_ALERT, "opening of %s failed: %s", filename, strerror(errno));
170 return ok;
171 }
172
173 static gboolean
174 read_uidl(pop3_base * popb, gchar * user)
175 {
176 gboolean ok = FALSE;
177 struct stat statbuf;
178 gchar *filename = g_strdup_printf("%s/popuidl/%s@%s", conf.spool_dir, user, popb->remote_host);
179
180 if (stat(filename, &statbuf) == 0) {
181 ok = read_uidl_fname(popb, filename);
182 if (ok) {
183 GList *drop_node;
184 foreach(popb->drop_list, drop_node) {
185 msg_info *info = (msg_info *) (drop_node->data);
186 if (find_uid(popb, info->uid)) {
187 DEBUG(5) debugf("msg with uid '%s' already known\n", info->uid);
188 info->is_in_uidl = TRUE;
189 popb->uidl_known_cnt++;
190 } else
191 DEBUG(5) debugf("msg with uid '%s' not known\n", info->uid);
192 }
193 }
194 } else {
195 logwrite(LOG_DEBUG, "no uidl file '%s' found\n", filename);
196 ok = TRUE;
197 }
198
199 g_free(filename);
200 return ok; /* return code is irrelevant, do not check... */
201 }
202
203 static gboolean
204 read_response(pop3_base * popb, int timeout)
205 {
206 gint len;
207
208 len = read_sockline(popb->in, popb->buffer, POP3_BUF_LEN, timeout, READSOCKL_CHUG);
209
210 if (len == -3) {
211 popb->error = pop3_timeout;
212 return FALSE;
213 } else if (len == -2) {
214 popb->error = pop3_syntax;
215 return FALSE;
216 } else if (len == -1) {
217 popb->error = pop3_eof;
218 return FALSE;
219 }
220
221 return TRUE;
222 }
223
224 static gboolean
225 check_response(pop3_base * popb)
226 {
227 char c = popb->buffer[0];
228
229 if (c == '+') {
230 popb->error = pop3_ok;
231 return TRUE;
232 } else if (c == '-')
233 popb->error = pop3_fail;
234 else
235 popb->error = pop3_syntax;
236 return FALSE;
237 }
238
239 static gboolean
240 strtoi(gchar * p, gchar ** pend, gint * val)
241 {
242 gchar buf[12];
243 gint i = 0;
244
245 while (*p && isspace(*p))
246 p++;
247 if (*p) {
248 while ((i < 11) && isdigit(*p))
249 buf[i++] = *(p++);
250 buf[i] = 0;
251 *val = atoi(buf);
252 *pend = p;
253 return TRUE;
254 }
255 return FALSE;
256 }
257
258 static gboolean
259 check_response_int_int(pop3_base * popb, gint * arg0, gint * arg1)
260 {
261 if (check_response(popb)) {
262 gchar *p = &(popb->buffer[3]);
263 gchar *pe;
264
265 if (strtoi(p, &pe, arg0)) {
266 DEBUG(5) debugf("arg0 = %d\n", *arg0);
267 p = pe;
268 if (strtoi(p, &pe, arg1))
269 DEBUG(5) debugf("arg1 = %d\n", *arg1);
270 return TRUE;
271 /* FIXME: Paolo's code has the return stmt
272 inside the if block right above it. What
273 is correct? */
274 }
275 popb->error = pop3_syntax;
276 }
277 return FALSE;
278 }
279
280 static gboolean
281 get_drop_listing(pop3_base * popb)
282 {
283 gchar buf[64];
284
285 DEBUG(5) debugf("get_drop_listing() entered\n");
286
287 while (1) {
288 gint len = read_sockline(popb->in, buf, 64, POP3_CMD_TIMEOUT, READSOCKL_CHUG);
289 if (len > 0) {
290 if (buf[0] == '.')
291 return TRUE;
292 else {
293 gint number, msg_size;
294 gchar *p = buf, *pe;
295 if (strtoi(p, &pe, &number)) {
296 p = pe;
297 if (strtoi(p, &pe, &msg_size)) {
298 msg_info *info = g_malloc(sizeof(msg_info));
299 info->number = number;
300 info->size = msg_size;
301
302 DEBUG(5) debugf ("get_drop_listing(), number = %d, msg_size = %d\n", number, msg_size);
303
304 info->uid = NULL;
305 info->is_fetched = FALSE;
306 info->is_in_uidl = FALSE;
307 popb->drop_list = g_list_append(popb->drop_list, info);
308 } else {
309 popb->error = pop3_syntax;
310 break;
311 }
312 } else {
313 popb->error = pop3_syntax;
314 break;
315 }
316 }
317 } else {
318 popb->error = (len == -1) ? pop3_eof : pop3_timeout;
319 return FALSE;
320 }
321 }
322 return FALSE;
323 }
324
325 static gboolean
326 get_uid_listing(pop3_base * popb)
327 {
328 gchar buf[64];
329
330 while (1) {
331 gint len = read_sockline(popb->in, buf, 64, POP3_CMD_TIMEOUT, READSOCKL_CHUG);
332 if (len > 0) {
333 if (buf[0] == '.')
334 return TRUE;
335 else {
336 gint number;
337 gchar *p = buf, *pe;
338 if (strtoi(p, &pe, &number)) {
339 msg_info *info = NULL;
340 GList *drop_node;
341
342 p = pe;
343 while (*p && isspace(*p))
344 p++;
345
346 foreach(popb->drop_list, drop_node) {
347 msg_info *curr_info = (msg_info *) (drop_node->data);
348 if (curr_info->number == number) {
349 info = curr_info;
350 break;
351 }
352 }
353 if (info) {
354 info->uid = g_strdup(p);
355 g_strchomp(info->uid);
356 }
357
358 } else {
359 popb->error = pop3_syntax;
360 break;
361 }
362 }
363 }
364 }
365 return FALSE;
366 }
367
368 static gboolean
369 check_init_response(pop3_base * popb)
370 {
371 if (check_response(popb)) {
372 gchar buf[256];
373 gchar *p = popb->buffer;
374 gint i = 0;
375 if (*p) {
376 while (*p && (*p != '<'))
377 p++;
378 while (*p && (*p != '>') && (i < 254))
379 buf[i++] = *(p++);
380 buf[i++] = '>';
381 buf[i] = '\0';
382
383 popb->timestamp = g_strdup(buf);
384
385 return TRUE;
386 }
387 }
388 return FALSE;
389 }
390
391 void
392 pop3_in_close(pop3_base * popb)
393 {
394 GList *node;
395
396 fclose(popb->in);
397 fclose(popb->out);
398
399 close(popb->sock);
400
401 foreach(popb->list_uid_old, node) {
402 gchar *uid = (gchar *) (node->data);
403 g_free(uid);
404 }
405 g_list_free(popb->list_uid_old);
406
407 foreach(popb->drop_list, node) {
408 msg_info *info = (msg_info *) (node->data);
409 if (info->uid)
410 g_free(info->uid);
411 g_free(info);
412 }
413 g_list_free(popb->drop_list);
414
415 if (popb->buffer)
416 g_free(popb->buffer);
417 if (popb->timestamp)
418 g_free(popb->timestamp);
419 }
420
421 pop3_base*
422 pop3_in_open(gchar * host, gint port, GList * resolve_list, guint flags)
423 {
424 pop3_base *popb;
425 gint sock;
426 mxip_addr *addr;
427
428 DEBUG(5) debugf("pop3_in_open entered, host = %s\n", host);
429
430 if ((addr = connect_resolvelist(&sock, host, port, resolve_list))) {
431 /* create structure to hold status data: */
432 popb = create_pop3base(sock, flags);
433 popb->remote_host = addr->name;
434
435 DEBUG(5) {
436 struct sockaddr_in name;
437 int len;
438 getsockname(sock, (struct sockaddr *) (&name), &len);
439 debugf("socket: name.sin_addr = %s\n", inet_ntoa(name.sin_addr));
440 }
441 return popb;
442 }
443 return NULL;
444 }
445
446 pop3_base*
447 pop3_in_open_child(gchar * cmd, guint flags)
448 {
449 pop3_base *popb;
450 gint sock;
451
452 DEBUG(5) debugf("pop3_in_open_child entered, cmd = %s\n", cmd);
453 sock = child(cmd);
454 if (sock > 0) {
455 popb = create_pop3base(sock, flags);
456 popb->remote_host = NULL;
457 return popb;
458 }
459 logwrite(LOG_ALERT, "child failed (sock = %d): %s\n", sock, strerror(errno));
460
461 return NULL;
462 }
463
464 gboolean
465 pop3_in_init(pop3_base * popb)
466 {
467 gboolean ok;
468
469 if ((ok = read_response(popb, POP3_INITIAL_TIMEOUT))) {
470 ok = check_init_response(popb);
471 }
472 if (!ok)
473 /* pop3_in_log_failure(popb, NULL); */
474 logwrite(LOG_ALERT, "pop3 failed\n");
475 return ok;
476 }
477
478 gboolean
479 pop3_in_login(pop3_base * popb, gchar * user, gchar * pass)
480 {
481 if (popb->flags & POP3_FLAG_APOP) {
482
483 gchar *string = g_strdup_printf("%s%s", popb->timestamp, pass);
484 gchar *digest = MD5String(string);
485 pop3_printf(popb->out, "APOP %s %s\r\n", user, digest);
486 g_free(string);
487 g_free(digest);
488 if (read_response(popb, POP3_CMD_TIMEOUT)) {
489 if (check_response(popb))
490 return TRUE;
491 else
492 popb->error = pop3_login_failure;
493 }
494
495 } else {
496
497 pop3_printf(popb->out, "USER %s\r\n", user);
498 if (read_response(popb, POP3_CMD_TIMEOUT)) {
499 if (check_response(popb)) {
500 pop3_printf(popb->out, "PASS %s\r\n", pass);
501 if (read_response(popb, POP3_CMD_TIMEOUT)) {
502 if (check_response(popb))
503 return TRUE;
504 else
505 popb->error = pop3_login_failure;
506 }
507 } else {
508 popb->error = pop3_login_failure;
509 }
510 }
511 }
512 return FALSE;
513 }
514
515 gboolean
516 pop3_in_stat(pop3_base * popb)
517 {
518 pop3_printf(popb->out, "STAT\r\n");
519 if (read_response(popb, POP3_CMD_TIMEOUT)) {
520 gint msg_cnt, mbox_size;
521 if (check_response_int_int(popb, &msg_cnt, &mbox_size)) {
522 popb->msg_cnt = msg_cnt;
523 popb->mbox_size = mbox_size;
524
525 return TRUE;
526 }
527 }
528 return FALSE;
529 }
530
531 gboolean
532 pop3_in_list(pop3_base * popb)
533 {
534 pop3_printf(popb->out, "LIST\r\n");
535 if (read_response(popb, POP3_CMD_TIMEOUT)) {
536 if (get_drop_listing(popb)) {
537 return TRUE;
538 }
539 }
540 return FALSE;
541 }
542
543 gboolean
544 pop3_in_dele(pop3_base * popb, gint number)
545 {
546 pop3_printf(popb->out, "DELE %d\r\n", number);
547 if (read_response(popb, POP3_CMD_TIMEOUT)) {
548 return TRUE;
549 }
550 return FALSE;
551 }
552
553 message*
554 pop3_in_retr(pop3_base * popb, gint number, address * rcpt)
555 {
556 accept_error err;
557
558 pop3_printf(popb->out, "RETR %d\r\n", number);
559 if (read_response(popb, POP3_CMD_TIMEOUT)) {
560 message *msg = create_message();
561 msg->received_host = popb->remote_host;
562 msg->received_prot = (popb->flags & POP3_FLAG_APOP) ? PROT_APOP : PROT_POP3;
563 msg->transfer_id = (popb->next_id)++;
564 msg->rcpt_list = g_list_append(NULL, copy_address(rcpt));
565
566 if ((err = accept_message(popb->in, msg, ACC_MAIL_FROM_HEAD
567 | (conf.do_save_envelope_to ? ACC_SAVE_ENVELOPE_TO : 0)))
568 == AERR_OK)
569 return msg;
570
571 destroy_message(msg);
572 }
573 return NULL;
574 }
575
576 gboolean
577 pop3_in_uidl(pop3_base * popb)
578 {
579 pop3_printf(popb->out, "UIDL\r\n");
580 if (read_response(popb, POP3_CMD_TIMEOUT)) {
581 if (get_uid_listing(popb)) {
582 return TRUE;
583 }
584 }
585 return FALSE;
586 }
587
588 gboolean
589 pop3_in_quit(pop3_base * popb)
590 {
591 pop3_printf(popb->out, "QUIT\r\n");
592 DEBUG(4) debugf("QUIT\n");
593 signal(SIGALRM, SIG_DFL);
594 return TRUE;
595 }
596
597 /* Send a DELE command for each message in (the old) uid listing.
598 This is to prevent mail from to be kept on server, if a previous
599 transaction was interupted. */
600 gboolean
601 pop3_in_uidl_dele(pop3_base * popb)
602 {
603 GList *drop_node;
604
605 foreach(popb->drop_list, drop_node) {
606 msg_info *info = (msg_info *) (drop_node->data);
607 /* if(find_uid(popb, info->uid)){ */
608 if (info->is_in_uidl) {
609 if (!pop3_in_dele(popb, info->number))
610 return FALSE;
611 /* TODO: it probably makes sense to also delete this uid from the listing */
612 }
613 }
614 return TRUE;
615 }
616
617 gboolean
618 pop3_get(pop3_base * popb, gchar * user, gchar * pass, address * rcpt, address * return_path,
619 gint max_count, gint max_size, gboolean max_size_delete)
620 {
621 gboolean ok = FALSE;
622 gint num_children = 0;
623
624 DEBUG(5) debugf("rcpt = %s@%s\n", rcpt->local_part, rcpt->domain);
625
626 signal(SIGCHLD, SIG_DFL);
627
628 if (pop3_in_init(popb)) {
629 if (pop3_in_login(popb, user, pass)) {
630 if (pop3_in_stat(popb)) {
631 if (popb->msg_cnt > 0) {
632
633 logwrite(LOG_NOTICE | LOG_VERBOSE, "%d message(s) for user %s at %s\n",
634 popb->msg_cnt, user, popb->remote_host);
635
636 if (pop3_in_list(popb)) {
637 gboolean do_get = !(popb->flags & POP3_FLAG_UIDL);
638 if (!do_get)
639 do_get = pop3_in_uidl(popb);
640 if (do_get) {
641 gint count = 0;
642 GList *drop_node;
643
644 if (popb->flags & POP3_FLAG_UIDL) {
645 read_uidl(popb, user);
646 logwrite(LOG_VERBOSE | LOG_NOTICE, "%d message(s) already in uidl.\n", popb->uidl_known_cnt);
647 }
648 if ((popb->flags & POP3_FLAG_UIDL) && (popb->flags & POP3_FLAG_UIDL_DELE))
649 pop3_in_uidl_dele(popb);
650
651 foreach(popb->drop_list, drop_node) {
652
653 msg_info *info = (msg_info *) (drop_node->data);
654 gboolean do_get_this = !(popb->flags & POP3_FLAG_UIDL);
655 /* if(!do_get_this) do_get_this = !find_uid(popb, info->uid); */
656 if (!do_get_this)
657 do_get_this = !(info->is_in_uidl);
658 if (do_get_this) {
659
660 if ((info->size < max_size) || (max_size == 0)) {
661 message *msg;
662
663 logwrite(LOG_VERBOSE | LOG_NOTICE, "receiving message %d\n", info->number);
664 msg = pop3_in_retr(popb, info->number, rcpt);
665
666 if (msg) {
667 if (return_path)
668 msg->return_path = copy_address(return_path);
669 if (spool_write(msg, TRUE)) {
670 pid_t pid;
671 logwrite(LOG_NOTICE, "%s <= %s host=%s with %s\n", msg->uid,
672 addr_string(msg->return_path), popb->remote_host,
673 (popb->flags & POP3_FLAG_APOP) ? prot_names [PROT_APOP] : prot_names [PROT_POP3]);
674 info->is_fetched = TRUE;
675 count++;
676 #if DO_WRITE_UIDL_EARLY
677 if (popb->flags & POP3_FLAG_UIDL)
678 write_uidl(popb, user);
679 #endif
680 if (!conf.do_queue) {
681
682 /* wait for child processes. If there are too many, we wait blocking, before we fork another one */
683 while (num_children > 0) {
684 int status, options = WNOHANG;
685 pid_t pid;
686
687 if (num_children >= POP3_MAX_CHILDREN) {
688 logwrite(LOG_NOTICE, "too many children - waiting\n");
689 options = 0;
690 }
691 if ((pid = waitpid(0, &status, options)) > 0) {
692 num_children--;
693 if (WEXITSTATUS(status) != EXIT_SUCCESS)
694 logwrite(LOG_WARNING, "delivery process with pid %d returned %d\n", pid, WEXITSTATUS (status));
695 if (WIFSIGNALED(status))
696 logwrite(LOG_WARNING, "delivery process with pid %d got signal: %d\n", pid, WTERMSIG (status));
697 } else if (pid < 0) {
698 logwrite(LOG_WARNING, "wait got error: %s\n", strerror(errno));
699 }
700 }
701
702 if ((pid = fork()) == 0) {
703 deliver(msg);
704 _exit(EXIT_SUCCESS);
705 } else if (pid < 0) {
706 logwrite(LOG_ALERT | LOG_VERBOSE, "could not fork for delivery, id = %s: %s\n", msg->uid, strerror(errno));
707 } else
708 num_children++;
709 } else {
710 DEBUG(1) debugf("queuing forced by configuration or option.\n");
711 }
712 if (popb->flags & POP3_FLAG_DELETE)
713 pop3_in_dele(popb, info->number);
714
715 destroy_message(msg);
716 } /* if(spool_write(msg, TRUE)) */
717 } else {
718 logwrite(LOG_ALERT, "retrieving of message %d failed: %d\n", info->number, popb->error);
719 }
720 } else {
721 /* info->size > max_size */
722 logwrite(LOG_NOTICE | LOG_VERBOSE, "size of message #%d (%d) > max_size (%d)\n", info->number, info->size, max_size);
723 if (max_size_delete)
724 if (popb->flags & POP3_FLAG_DELETE)
725 pop3_in_dele(popb, info->number);
726 }
727 } /* if(do_get_this) ... */
728 else {
729 if (popb->flags & POP3_FLAG_UIDL) {
730 info->is_fetched = TRUE; /* obsolete? */
731 logwrite(LOG_VERBOSE, "message %d already known\n", info->number);
732 DEBUG(1) debugf("message %d (uid = %s) not fetched\n", info->number, info->uid);
733 #if 0
734 #if DO_WRITE_UIDL_EARLY
735 write_uidl(popb, user); /* obsolete? */
736 #endif
737 #endif
738 }
739 }
740 if ((max_count != 0) && (count >= max_count))
741 break;
742 } /* foreach() */
743 #if DO_WRITE_UIDL_EARLY
744 #else
745 if (popb->flags & POP3_FLAG_UIDL)
746 write_uidl(popb, user);
747 #endif
748 } /* if(pop3_in_uidl(popb) ... */
749 } /* if(pop3_in_list(popb)) */
750 } /* if(popb->msg_cnt > 0) */
751 else {
752 logwrite(LOG_NOTICE | LOG_VERBOSE, "no messages for user %s at %s\n", user, popb->remote_host);
753 }
754 ok = TRUE;
755 }
756 pop3_in_quit(popb);
757 } else {
758 logwrite(LOG_ALERT | LOG_VERBOSE, "pop3 login failed for user %s, host = %s\n", user, popb->remote_host);
759 }
760 }
761 if (!ok) {
762 logwrite(LOG_ALERT | LOG_VERBOSE, "pop3 failed, error = %d\n", popb->error);
763 }
764
765 while (num_children > 0) {
766 int status;
767 pid_t pid;
768 if ((pid = wait(&status)) > 0) {
769 num_children--;
770 if (WEXITSTATUS(status) != EXIT_SUCCESS)
771 logwrite(LOG_WARNING, "delivery process with pid %d returned %d\n", pid, WEXITSTATUS(status));
772 if (WIFSIGNALED(status))
773 logwrite(LOG_WARNING, "delivery process with pid %d got signal: %d\n", pid, WTERMSIG(status));
774 } else {
775 logwrite(LOG_WARNING, "wait got error: %s\n", strerror(errno));
776 }
777 }
778
779 return ok;
780 }
781
782 /* function just to log into a pop server,
783 for pop_before_smtp (or is it smtp_after_pop?)
784 */
785
786 gboolean
787 pop3_login(gchar * host, gint port, GList * resolve_list, gchar * user, gchar * pass, guint flags)
788 {
789 gboolean ok = FALSE;
790 pop3_base *popb;
791
792 signal(SIGCHLD, SIG_IGN);
793
794 if ((popb = pop3_in_open(host, port, resolve_list, flags))) {
795 if (pop3_in_init(popb)) {
796 if (pop3_in_login(popb, user, pass))
797 ok = TRUE;
798 else
799 logwrite(LOG_ALERT | LOG_VERBOSE, "pop3 login failed for user %s, host = %s\n", user, host);
800 }
801 pop3_in_close(popb);
802 }
803 return ok;
804 }
805
806 #endif