masqmail-0.2: ca99aa7f052a src/pop3

masqmail-0.2

view src/pop3_in.c @ 165:ca99aa7f052a

improved hmactest added the test vectors that are included in the RFC plus improved the output

author	meillo@marmaro.de
date	Sun, 18 Jul 2010 22:24:51 +0200
parents	2685e59f6f43
children

line source

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 */

18 /* see RFC 1725 */

20 #include <sys/wait.h>

21 #include <sys/stat.h>

23 #include "masqmail.h"

24 #include "pop3_in.h"

25 #include "readsock.h"

27 #ifdef USE_LIB_CRYPTO

28 #include <openssl/md5.h>

29 #else

30 #include "md5/md5.h"

31 #endif

33 #ifdef ENABLE_POP3

35 /* experimental feature */

36 #define DO_WRITE_UIDL_EARLY 1

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;

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]);

56 return g_strdup(str_digest);

57 }

59 static pop3_base*

60 create_pop3base(gint sock, guint flags)

61 {

62 gint dup_sock;

64 pop3_base *popb = (pop3_base *) g_malloc(sizeof(pop3_base));

65 if (popb) {

66 memset(popb, 0, sizeof(pop3_base));

68 popb->error = pop3_ok;

70 popb->buffer = (gchar *) g_malloc(POP3_BUF_LEN);

72 dup_sock = dup(sock);

73 popb->out = fdopen(sock, "w");

74 popb->in = fdopen(dup_sock, "r");

76 popb->flags = flags;

77 }

78 return popb;

79 }

81 static void

82 pop3_printf(FILE * out, gchar * fmt, ...)

83 {

84 va_list args;

85 va_start(args, fmt);

87 DEBUG(4) {

88 gchar buf[256];

89 va_list args_copy;

91 va_copy(args_copy, args);

92 vsnprintf(buf, 255, fmt, args_copy);

93 va_end(args_copy);

95 debugf(">>>%s", buf);

96 }

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