masqmail: 653aef34b225 src/pop3

masqmail

view src/pop3_in.c @ 2:653aef34b225

removed distribution specific data

author	meillo@marmaro.de
date	Fri, 26 Sep 2008 21:26:36 +0200
parents
children	26e34ae9a3e3

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 "masqmail.h"

21 #include "pop3_in.h"

22 #include "readsock.h"

24 #include <sys/wait.h>

25 #include <sys/stat.h>

27 #ifdef USE_LIB_CRYPTO

28 #include <openssl/md5.h>

29 #else

30 #include "md5/global.h"

31 #include "md5/md5.h"

32 #endif

34 #ifdef ENABLE_POP3

36 /* experimental feature */

37 #define DO_WRITE_UIDL_EARLY 1

39 static

40 gchar *MD5String (char *string)

41 {

42 MD5_CTX context;

43 unsigned char digest[16];

44 char str_digest[33];

45 int i;

47 #ifdef USE_LIB_CRYPTO

48 MD5(string, strlen(string), digest);

49 #else

50 MD5Init(&context);

51 MD5Update(&context, string, strlen(string));

52 MD5Final(digest, &context);

53 #endif

54 for (i = 0; i < 16; i++)

55 sprintf(str_digest+2*i, "%02x", digest[i]);

57 return g_strdup(str_digest);

58 }

60 static

61 pop3_base *create_pop3base(gint sock, guint flags)

62 {

63 gint dup_sock;

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

66 if(popb){

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

69 popb->error = pop3_ok;

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

73 dup_sock = dup(sock);

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

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

77 popb->flags = flags;

78 }

79 return popb;

80 }

82 static

83 void pop3_printf(FILE *out, gchar *fmt, ...)

84 {

85 va_list args;

86 va_start(args, fmt);

88 DEBUG(4){

89 gchar buf[256];

90 va_list args_copy;

92 va_copy(args_copy, args);

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

94 va_end(args_copy);

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

97 }

99 vfprintf(out, fmt, args); fflush(out);

100

101 va_end(args);

102 }

103

104 static

105 gboolean 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

125 gboolean 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",

130 conf.spool_dir,

131 user, popb->remote_host);

132 gchar *tmpname = g_strdup_printf("%s.tmp", filename);

133 FILE *fptr = fopen(tmpname, "wt");

134

135 if(fptr){

136 foreach(popb->drop_list, node){

137 msg_info *info = (msg_info *)(node->data);

138 if(info->is_fetched || info->is_in_uidl)

139 fprintf(fptr, "%s\n", info->uid);

140 }

141 fclose(fptr);

142 ok = (rename(tmpname, filename) != -1);

143 }

144

145 g_free(tmpname);

146 g_free(filename);

147 return ok;

148 }

149

150 static

151 gboolean read_uidl_fname(pop3_base *popb, gchar *filename)

152 {

153 gboolean ok = FALSE;

154 FILE *fptr = fopen(filename, "rt");

155 gchar buf[256];

156

157 if(fptr){

158 popb->list_uid_old = NULL;

159 while(fgets(buf, 255, fptr)){

160 if(buf[strlen(buf)-1] == '\n'){

161 g_strchomp(buf);

162 popb->list_uid_old =

163 g_list_append(popb->list_uid_old, g_strdup(buf));

164 }else{

165 logwrite(LOG_ALERT, "broken uid: %s\n", buf);

166 break;

167 }

168 }

169 fclose(fptr);

170 ok = TRUE;

171 }else

172 logwrite(LOG_ALERT, "opening of %s failed: %s", filename, strerror(errno));

173 return ok;

174 }

175

176 static

177 gboolean read_uidl(pop3_base *popb, gchar *user)

178 {

179 gboolean ok = FALSE;

180 struct stat statbuf;

181 gchar *filename = g_strdup_printf("%s/popuidl/%s@%s",

182 conf.spool_dir,

183 user, popb->remote_host);

184

185 if(stat(filename, &statbuf) == 0){

186 ok = read_uidl_fname(popb, filename);

187 if(ok){

188 GList *drop_node;

189 foreach(popb->drop_list, drop_node){

190 msg_info *info = (msg_info *)(drop_node->data);

191 if(find_uid(popb, info->uid)){

192 DEBUG(5) debugf("msg with uid '%s' already known\n", info->uid);

193 info->is_in_uidl = TRUE;

194 popb->uidl_known_cnt++;

195 }else

196 DEBUG(5) debugf("msg with uid '%s' not known\n", info->uid);

197 }

198 }

199 }else{

200 logwrite(LOG_DEBUG, "no uidl file '%s' found\n", filename);

201 ok = TRUE;

202 }

203

204 g_free(filename);

205 return ok; /* return code is irrelevant, do not check... */

206 }

207

208 static

209 gboolean read_response(pop3_base *popb, int timeout)

210 {

211 gint len;

212

213 len = read_sockline(popb->in, popb->buffer, POP3_BUF_LEN, timeout, READSOCKL_CHUG);

214

215 if(len == -3){

216 popb->error = pop3_timeout;

217 return FALSE;

218 }

219 else if(len == -2){

220 popb->error = pop3_syntax;

221 return FALSE;

222 }

223 else if(len == -1){

224 popb->error = pop3_eof;

225 return FALSE;

226 }

227

228 return TRUE;

229 }

230

231 static

232 gboolean check_response(pop3_base *popb)

233 {

234 char c = popb->buffer[0];

235

236 if(c == '+'){

237 popb->error = pop3_ok;

238 return TRUE;

239 }else if(c == '-')

240 popb->error = pop3_fail;

241 else

242 popb->error = pop3_syntax;

243 return FALSE;

244 }

245

246 static

247 gboolean strtoi(gchar *p, gchar **pend, gint *val)

248 {

249 gchar buf[12];

250 gint i = 0;

251

252 while(*p && isspace(*p)) p++;

253 if(*p){

254 while((i < 11) && isdigit(*p))

255 buf[i++] = *(p++);

256 buf[i] = 0;

257 *val = atoi(buf);

258 *pend = p;

259 return TRUE;

260 }

261 return FALSE;

262 }

263

264 static

265 gboolean check_response_int_int(pop3_base *popb, gint *arg0, gint *arg1)

266 {

267 if(check_response(popb)){

268 gchar *p = &(popb->buffer[3]);

269 gchar *pe;

270

271 if(strtoi(p, &pe, arg0)){

272 DEBUG(5) debugf("arg0 = %d\n", *arg0);

273 p = pe;

274 if(strtoi(p, &pe, arg1))

275 DEBUG(5) debugf("arg1 = %d\n", *arg1);

276 return TRUE;

277 }

278 popb->error = pop3_syntax;

279 }

280 return FALSE;

281 }

282

283 static

284 gboolean get_drop_listing(pop3_base *popb)

285 {

286 gchar buf[64];

287

288 DEBUG(5) debugf("get_drop_listing() entered\n");

289

290 while(1){

291 gint len = read_sockline(popb->in, buf, 64, POP3_CMD_TIMEOUT, READSOCKL_CHUG);

292 if(len > 0){

293 if(buf[0] == '.')

294 return TRUE;

295 else{

296 gint number, msg_size;

297 gchar *p = buf, *pe;

298 if(strtoi(p, &pe, &number)){

299 p = pe;

300 if(strtoi(p, &pe, &msg_size)){

301 msg_info *info = g_malloc(sizeof(msg_info));

302 info->number = number;

303 info->size = msg_size;

304

305 DEBUG(5) debugf("get_drop_listing(), number = %d, msg_size = %d\n", number, msg_size);

306

307 info->uid = NULL;

308 info->is_fetched = FALSE;

309 info->is_in_uidl = FALSE;

310 popb->drop_list = g_list_append(popb->drop_list, info);

311 }else{

312 popb->error = pop3_syntax;

313 break;

314 }

315 }else{

316 popb->error = pop3_syntax;

317 break;

318 }

319 }

320 }else{

321 popb->error = (len == -1) ? pop3_eof : pop3_timeout;

322 return FALSE;

323 }

324 }

325 return FALSE;

326 }

327

328 static

329 gboolean get_uid_listing(pop3_base *popb)

330 {

331 gchar buf[64];

332

333 while(1){

334 gint len = read_sockline(popb->in, buf, 64, POP3_CMD_TIMEOUT, READSOCKL_CHUG);

335 if(len > 0){

336 if(buf[0] == '.')

337 return TRUE;

338 else{

339 gint number;

340 gchar *p = buf, *pe;

341 if(strtoi(p, &pe, &number)){

342 msg_info *info = NULL;

343 GList *drop_node;

344

345 p = pe;

346 while(*p && isspace(*p)) p++;

347

348 foreach(popb->drop_list, drop_node){

349 msg_info *curr_info = (msg_info *)(drop_node->data);

350 if(curr_info->number == number){

351 info = curr_info;

352 break;

353 }

354 }

355 if(info){

356 info->uid = g_strdup(p);

357 g_strchomp(info->uid);

358 }

359

360 }else{

361 popb->error = pop3_syntax;

362 break;

363 }

364 }

365 }

366 }

367 return FALSE;

368 }

369

370 static

371 gboolean check_init_response(pop3_base *popb)

372 {

373 if(check_response(popb)){

374 gchar buf[256];

375 gchar *p = popb->buffer;

376 gint i = 0;

377 if(*p){

378 while(*p && (*p != '<')) p++;

379 while(*p && (*p != '>') && (i < 254))

380 buf[i++] = *(p++);

381 buf[i++] = '>';

382 buf[i] = 0;

383

384 popb->timestamp = g_strdup(buf);

385

386 return TRUE;

387 }

388 }

389 return FALSE;

390 }

391

392 void 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) g_free(info->uid);

410 g_free(info);

411 }

412 g_list_free(popb->drop_list);

413

414 if(popb->buffer) g_free(popb->buffer);

415 if(popb->timestamp) g_free(popb->timestamp);

416 }

417

418 pop3_base *pop3_in_open(gchar *host, gint port, GList *resolve_list, guint flags)

419 {

420 pop3_base *popb;

421 gint sock;

422 mxip_addr *addr;

423

424 DEBUG(5) debugf("pop3_in_open entered, host = %s\n", host);

425

426 if((addr = connect_resolvelist(&sock, host, port, resolve_list))){

427 /* create structure to hold status data: */

428 popb = create_pop3base(sock, flags);

429 popb->remote_host = addr->name;

430

431 DEBUG(5){

432 struct sockaddr_in name;

433 int len;

434 getsockname(sock, (struct sockaddr *)(&name), &len);

435 debugf("socket: name.sin_addr = %s\n", inet_ntoa(name.sin_addr));

436 }

437 return popb;

438 }

439 return NULL;

440 }

441

442 pop3_base *pop3_in_open_child(gchar *cmd, guint flags)

443 {

444 pop3_base *popb;

445 gint sock;

446

447 DEBUG(5) debugf("pop3_in_open_child entered, cmd = %s\n", cmd);

448

449 sock = child(cmd);

450

451 if(sock > 0){

452

453 popb = create_pop3base(sock, flags);

454 popb->remote_host = NULL;

455

456 return popb;

457 }

458 logwrite(LOG_ALERT, "child failed (sock = %d): %s\n", sock, strerror(errno));

459

460 return NULL;

461 }

462

463 gboolean pop3_in_init(pop3_base *popb)

464 {

465 gboolean ok;

466

467 if((ok = read_response(popb, POP3_INITIAL_TIMEOUT))){

468 ok = check_init_response(popb);

469 }

470 if(!ok)

471 /* pop3_in_log_failure(popb, NULL);*/

472 logwrite(LOG_ALERT, "pop3 failed\n");

473 return ok;

474 }

475

476 gboolean pop3_in_login(pop3_base *popb, gchar *user, gchar *pass)

477 {

478 if(popb->flags & POP3_FLAG_APOP){

479

480 gchar *string = g_strdup_printf("%s%s", popb->timestamp, pass);

481 gchar *digest = MD5String(string);

482 pop3_printf(popb->out, "APOP %s %s\r\n", user, digest);

483 g_free(string);

484 g_free(digest);

485 if(read_response(popb, POP3_CMD_TIMEOUT)){

486 if(check_response(popb))

487 return TRUE;

488 else

489 popb->error = pop3_login_failure;

490 }

491

492 }else{

493

494 pop3_printf(popb->out, "USER %s\r\n", user);

495 if(read_response(popb, POP3_CMD_TIMEOUT)){

496 if(check_response(popb)){

497 pop3_printf(popb->out, "PASS %s\r\n", pass);

498 if(read_response(popb, POP3_CMD_TIMEOUT)){

499 if(check_response(popb))

500 return TRUE;

501 else

502 popb->error = pop3_login_failure;

503 }

504 }else{

505 popb->error = pop3_login_failure;

506 }

507 }

508 }

509 return FALSE;

510 }

511

512 gboolean pop3_in_stat(pop3_base *popb)

513 {

514 pop3_printf(popb->out, "STAT\r\n");

515 if(read_response(popb, POP3_CMD_TIMEOUT)){

516 gint msg_cnt, mbox_size;

517 if(check_response_int_int(popb, &msg_cnt, &mbox_size)){

518 popb->msg_cnt = msg_cnt;

519 popb->mbox_size = mbox_size;

520

521 return TRUE;

522 }

523 }

524 return FALSE;

525 }

526

527 gboolean pop3_in_list(pop3_base *popb)

528 {

529 pop3_printf(popb->out, "LIST\r\n");

530 if(read_response(popb, POP3_CMD_TIMEOUT)){

531 if(get_drop_listing(popb)){

532 return TRUE;

533 }

534 }

535 return FALSE;

536 }

537

538 gboolean pop3_in_dele(pop3_base *popb, gint number)

539 {

540 pop3_printf(popb->out, "DELE %d\r\n", number);

541 if(read_response(popb, POP3_CMD_TIMEOUT)){

542 return TRUE;

543 }

544 return FALSE;

545 }

546

547 message *pop3_in_retr(pop3_base *popb, gint number, address *rcpt)

548 {

549 accept_error err;

550

551 pop3_printf(popb->out, "RETR %d\r\n", number);

552 if(read_response(popb, POP3_CMD_TIMEOUT)){

553 message *msg = create_message();

554 msg->received_host = popb->remote_host;

555 msg->received_prot = (popb->flags & POP3_FLAG_APOP) ? PROT_APOP : PROT_POP3;

556 msg->transfer_id = (popb->next_id)++;

557 msg->rcpt_list = g_list_append(NULL, copy_address(rcpt));

558

559 if((err = accept_message(popb->in, msg,

560 ACC_MAIL_FROM_HEAD|(conf.do_save_envelope_to ? ACC_SAVE_ENVELOPE_TO : 0)))

561 == AERR_OK)

562 return msg;

563

564 destroy_message(msg);

565 }

566 return NULL;

567 }

568

569 gboolean pop3_in_uidl(pop3_base *popb)

570 {

571 pop3_printf(popb->out, "UIDL\r\n");

572 if(read_response(popb, POP3_CMD_TIMEOUT)){

573 if(get_uid_listing(popb)){

574 return TRUE;

575 }

576 }

577 return FALSE;

578 }

579

580 gboolean pop3_in_quit(pop3_base *popb)

581 {

582 pop3_printf(popb->out, "QUIT\r\n");

583

584 DEBUG(4) debugf("QUIT\n");

585

586 signal(SIGALRM, SIG_DFL);

587

588 return TRUE;

589 }

590

591 /* Send a DELE command for each message in (the old) uid listing.

592 This is to prevent mail from to be kept on server, if a previous

593 transaction was interupted. */

594 gboolean pop3_in_uidl_dele(pop3_base *popb)

595 {

596 GList *drop_node;

597

598 foreach(popb->drop_list, drop_node){

599 msg_info *info = (msg_info *)(drop_node->data);

600 /* if(find_uid(popb, info->uid)){*/

601 if(info->is_in_uidl){

602 if(!pop3_in_dele(popb, info->number))

603 return FALSE;

604 /* TODO: it probably makes sense to also

605 delete this uid from the listing */

606 }

607 }

608 return TRUE;

609 }

610

611 gboolean pop3_get(pop3_base *popb,

612 gchar *user, gchar *pass, address *rcpt, address *return_path,

613 gint max_count, gint max_size, gboolean max_size_delete)

614 {

615 gboolean ok = FALSE;

616 gint num_children = 0;

617

618 DEBUG(5) debugf("rcpt = %s@%s\n", rcpt->local_part, rcpt->domain);

619

620 signal(SIGCHLD, SIG_DFL);

621

622 if(pop3_in_init(popb)){

623 if(pop3_in_login(popb, user, pass)){

624 if(pop3_in_stat(popb)){

625 if(popb->msg_cnt > 0){

626

627 logwrite(LOG_NOTICE|LOG_VERBOSE, "%d message(s) for user %s at %s\n",

628 popb->msg_cnt, user, popb->remote_host);

629

630 if(pop3_in_list(popb)){

631 gboolean do_get = !(popb->flags & POP3_FLAG_UIDL);

632 if(!do_get) do_get = pop3_in_uidl(popb);

633 if(do_get){

634 gint count = 0;

635 GList *drop_node;

636

637 if(popb->flags & POP3_FLAG_UIDL){

638 read_uidl(popb, user);

639 logwrite(LOG_VERBOSE|LOG_NOTICE, "%d message(s) already in uidl.\n",

640 popb->uidl_known_cnt);

641 }

642 if((popb->flags & POP3_FLAG_UIDL) && (popb->flags & POP3_FLAG_UIDL_DELE))

643 pop3_in_uidl_dele(popb);

644

645 foreach(popb->drop_list, drop_node){

646

647 msg_info *info = (msg_info *)(drop_node->data);

648 gboolean do_get_this = !(popb->flags & POP3_FLAG_UIDL);

649 /* if(!do_get_this) do_get_this = !find_uid(popb, info->uid);*/

650 if(!do_get_this) do_get_this = !(info->is_in_uidl);

651 if(do_get_this){

652

653 if((info->size < max_size) || (max_size == 0)){

654 message *msg;

655

656 logwrite(LOG_VERBOSE|LOG_NOTICE, "receiving message %d\n", info->number);

657 msg = pop3_in_retr(popb, info->number, rcpt);

658

659 if(msg){

660 if(return_path)

661 msg->return_path = copy_address(return_path);

662 if(spool_write(msg, TRUE)){

663 pid_t pid;

664 logwrite(LOG_NOTICE, "%s <= %s host=%s with %s\n",

665 msg->uid,

666 addr_string(msg->return_path),

667 popb->remote_host,

668 (popb->flags & POP3_FLAG_APOP) ?

669 prot_names[PROT_APOP] : prot_names[PROT_POP3]

670 );

671 info->is_fetched = TRUE;

672 count++;

673 #if DO_WRITE_UIDL_EARLY

674 if(popb->flags & POP3_FLAG_UIDL) write_uidl(popb, user);

675 #endif

676 if(!conf.do_queue){

677

678 /* wait for child processes. If there are too many,

679 we wait blocking, before we fork another one */

680 while(num_children > 0){

681 int status, options = WNOHANG;

682 pid_t pid;

683

684 if(num_children >= POP3_MAX_CHILDREN){

685 logwrite(LOG_NOTICE, "too many children - waiting\n");

686 options = 0;

687 }

688 if((pid = waitpid(0, &status, options)) > 0){

689 num_children--;

690 if(WEXITSTATUS(status) != EXIT_SUCCESS)

691 logwrite(LOG_WARNING,

692 "delivery process with pid %d returned %d\n",

693 pid, WEXITSTATUS(status));

694 if(WIFSIGNALED(status))

695 logwrite(LOG_WARNING,

696 "delivery process with pid %d got signal: %d\n",

697 pid, WTERMSIG(status));

698 }else if(pid < 0){

699 logwrite(LOG_WARNING, "wait got error: %s\n", strerror(errno));

700 }

701 }

702

703 if((pid = fork()) == 0){

704 deliver(msg);

705 _exit(EXIT_SUCCESS);

706 }else if(pid < 0){

707 logwrite(LOG_ALERT|LOG_VERBOSE,

708 "could not fork for delivery, id = %s: %s\n",

709 msg->uid, strerror(errno));

710 }else

711 num_children++;

712 }else{

713 DEBUG(1) debugf("queuing forced by configuration or option.\n");

714 }

715 if(popb->flags & POP3_FLAG_DELETE)

716 pop3_in_dele(popb, info->number);

717

718 destroy_message(msg);

719 }/* if(spool_write(msg, TRUE)) */

720 }else{

721 logwrite(LOG_ALERT,

722 "retrieving of message %d failed: %d\n",

723 info->number, popb->error);

724 }

725 }/* if((info->size > max_size) ... */

726 else{

727 logwrite(LOG_NOTICE|LOG_VERBOSE, "size of message #%d (%d) > max_size (%d)\n",

728 info->number, info->size, max_size);

729 if(max_size_delete)

730 if(popb->flags & POP3_FLAG_DELETE)

731 pop3_in_dele(popb, info->number);

732 }

733 }/* if(do_get_this) ... */

734 else{

735 if(popb->flags & POP3_FLAG_UIDL){

736 info->is_fetched = TRUE; /* obsolete? */

737 logwrite(LOG_VERBOSE, "message %d already known\n",

738 info->number);

739 DEBUG(1) debugf("message %d (uid = %s) not fetched\n",

740 info->number, info->uid);

741 #if 0

742 #if DO_WRITE_UIDL_EARLY

743 write_uidl(popb, user); /* obsolete? */

744 #endif

745 #endif

746 }

747 }

748 if((max_count != 0) && (count >= max_count))

749 break;

750 }/* foreach() */

751 #if DO_WRITE_UIDL_EARLY

752 #else

753 if(popb->flags & POP3_FLAG_UIDL) write_uidl(popb, user);

754 #endif

755 }/* if(pop3_in_uidl(popb) ... */

756 }/* if(pop3_in_list(popb)) */

757 }/* if(popb->msg_cnt > 0) */

758 else{

759 logwrite(LOG_NOTICE|LOG_VERBOSE,

760 "no messages for user %s at %s\n", user, popb->remote_host);

761 }

762 ok = TRUE;

763 }

764 pop3_in_quit(popb);

765 }else{

766 logwrite(LOG_ALERT|LOG_VERBOSE,

767 "pop3 login failed for user %s, host = %s\n", user, popb->remote_host);

768 }

769 }

770 if(!ok){

771 logwrite(LOG_ALERT|LOG_VERBOSE, "pop3 failed, error = %d\n", popb->error);

772 }

773

774 while(num_children > 0){

775 int status;

776 pid_t pid;

777 if((pid = wait(&status)) > 0){

778 num_children--;

779 if(WEXITSTATUS(status) != EXIT_SUCCESS)

780 logwrite(LOG_WARNING,

781 "delivery process with pid %d returned %d\n",

782 pid, WEXITSTATUS(status));

783 if(WIFSIGNALED(status))

784 logwrite(LOG_WARNING,

785 "delivery process with pid %d got signal: %d\n",

786 pid, WTERMSIG(status));

787 }else{

788 logwrite(LOG_WARNING, "wait got error: %s\n", strerror(errno));

789 }

790 }

791

792 return ok;

793 }

794

795 /* function just to log into a pop server,

796 for pop_before_smtp (or is it smtp_after_pop?)

797 */

798

799 gboolean pop3_login(gchar *host, gint port, GList *resolve_list,

800 gchar *user, gchar *pass, guint flags)

801 {

802 gboolean ok = FALSE;

803 pop3_base *popb;

804

805 signal(SIGCHLD, SIG_IGN);

806

807 if((popb = pop3_in_open(host, port, resolve_list, flags))){

808 if(pop3_in_init(popb)){

809 if(pop3_in_login(popb, user, pass))

810 ok = TRUE;

811 else

812 logwrite(LOG_ALERT|LOG_VERBOSE,

813 "pop3 login failed for user %s, host = %s\n", user, host);

814 }

815 pop3_in_close(popb);

816 }

817 return ok;

818 }

819

820 #endif