masqmail: d86d7b4b8995 src/deliver.c

397 ret = delivery_failures(msgout->msg, msgout->rcpt_list, "could not open connection to %s:%d :\n\t%s", host, port, h_errno != 0 ? hstrerror(h_errno) : strerror(errno));

398 }

399 if (ret) {

400 deliver_finish(msgout);

401 }

402 }

403 }

404 return ok;

405 }

406

407 set_heloname(psb, route->helo_name ? route->helo_name : conf.host_name, route->do_correct_helo);

408

409 #ifdef ENABLE_AUTH

410 if (route->auth_name && route->auth_login && route->auth_secret) {

411 set_auth(psb, route->auth_name, route->auth_login, route->auth_secret);

412 }

413 #endif

414 if (!smtp_out_init(psb, route->instant_helo)) {

415 /* smtp_out_init() failed */

416 if ((psb->error==smtp_fail) || (psb->error==smtp_trylater) || (psb->error==smtp_syntax)) {

417 smtp_out_quit(psb);

418

419 foreach(msgout_list, msgout_node) {

420 msg_out *msgout = (msg_out *) (msgout_node->data);

421 smtp_out_mark_rcpts(psb, msgout->rcpt_list);

422

423 if (delivery_failures(msgout->msg, msgout->rcpt_list, "while connected with %s, the server replied\n\t%s", host, psb->buffer)) {

424 deliver_finish(msgout);

425 }

426 }

427 }

428 destroy_smtpbase(psb);

429 return ok;

430 }

431

432 if (!route->do_pipelining) {

433 psb->use_pipelining = FALSE;

434 }

435

436 foreach(msgout_list, msgout_node) {

437 msg_out *msgout = (msg_out *) (msgout_node->data);

438 gboolean flag, ok_msg = FALSE, ok_fail = FALSE;

439 message *msg = msgout->msg;

440

441 /* we may have to read the data at this point and remember if we did */

442 flag = (msg->data_list == NULL);

443 if (flag && !spool_read_data(msg)) {

444 logwrite(LOG_ALERT, "could not open data spool file %s\n", msg->uid);

445 break;

446 }

447

448 smtp_out_msg(psb, msg, msgout->return_path, msgout->rcpt_list, msgout->hdr_list);

449

450 ok_fail = delivery_failures(msg, msgout->rcpt_list, "while connected with %s, the server replied\n\t%s", host, psb->buffer);

451

452 if ((psb->error == smtp_eof) || (psb->error == smtp_timeout)) {

453 /* connection lost */

454 break;

455 } else if (psb->error != smtp_ok) {

456 if (g_list_next(msgout_node) && !smtp_out_rset(psb)) {

457 break;

458 }

459 }

460 ok_msg = (psb->error == smtp_ok);

461

462 if (flag) {

463 msg_free_data(msg);

464 }

465 if (ok_msg) {

466 ok = TRUE;

467 }

468 if (ok_msg || ok_fail) {

469 deliver_finish(msgout);

470 }

471 }

472 if (psb->error == smtp_ok || (psb->error == smtp_fail)

473 || (psb->error == smtp_trylater) || (psb->error == smtp_syntax)) {

474 smtp_out_quit(psb);

475 }

476 destroy_smtpbase(psb);

477 return ok;

478 }

479

480 gboolean

481 deliver_msglist_host(connect_route *route, GList *msgout_list, gchar *host,

482 GList *res_list)

483 {

484

485 if (route->pipe) {

486 DEBUG(5) debugf("with pipe\n");

487 return deliver_msglist_host_pipe(route, msgout_list, host, res_list);

488 } else {

489 DEBUG(5) debugf("with smtp\n");

490 return deliver_msglist_host_smtp(route, msgout_list, host, res_list);

491 }

492 }

493

494 /*

495 ** delivers messages in msgout_list using route

496 */

497 gboolean

498 deliver_route_msgout_list(connect_route *route, GList *msgout_list)

499 {

500 gboolean ok = FALSE;

501 GList *mo_ph_list;

502 GList *mo_ph_node;

503

504 DEBUG(5) debugf("deliver_route_msgout_list entered, route->name = %s\n", route->name);

505

506 if (route->mail_host) {

507 /* this is easy... deliver everything to a smart host for relay */

508 return deliver_msglist_host(route, msgout_list, NULL,

509 route->resolve_list);

510 }

511

512 /* this is not easy... */

513

514 mo_ph_list = route_msgout_list(route, msgout_list);

515 /* okay, now we have ordered our messages by the hosts. */

516 if (!mo_ph_list) {

517 return FALSE;

518 }

519

520 /*

521 ** TODO: It would be nice to be able to fork for each host.

522 ** We cannot do that yet because of complications with finishing the

523 ** messages. Threads could be a solution because they use the same

524 ** memory. But we are not thread safe yet...

525 */

526 foreach(mo_ph_list, mo_ph_node) {

527 msgout_perhost *mo_ph = (msgout_perhost *) (mo_ph_node->data);

528 if (deliver_msglist_host(route, mo_ph->msgout_list,

529 mo_ph->host, route->resolve_list)) {

530 ok = TRUE;

531 }

532 destroy_msgout_perhost(mo_ph);

533 }

534 g_list_free(mo_ph_list);

535 return ok;

536 }

537

538 /*

539 ** calls route_prepare_msg()

540 ** delivers messages in msg_list using route by calling

541 ** deliver_route_msgout_list()

542 */

543 gboolean

544 deliver_route_msg_list(connect_route *route, GList *msgout_list)

545 {

546 GList *msgout_list_deliver = NULL;

547 GList *msgout_node;

548 gboolean ok = TRUE;

549

550 DEBUG(6) debugf("deliver_route_msg_list()\n");

551

552 foreach(msgout_list, msgout_node) {

553 msg_out *msgout = (msg_out *) (msgout_node->data);

554 msg_out *msgout_cloned = clone_msg_out(msgout);

555 GList *rcpt_list_non_delivered = NULL;

556 GList *rcpt_node;

557

558 /*

559 ** we have to delete already delivered rcpt's because a

560 ** previous route may have delivered to it

561 */

562 foreach(msgout_cloned->rcpt_list, rcpt_node) {

563 address *rcpt = (address *) (rcpt_node->data);

564 /*

565 ** failed addresses already have been bounced;

566 ** there should be a better way to handle those.

567 */

568 if (!addr_is_delivered(rcpt) && !addr_is_failed(rcpt)

569 && !(rcpt->flags & ADDR_FLAG_LAST_ROUTE)) {

570 rcpt_list_non_delivered = g_list_append(rcpt_list_non_delivered, rcpt);

571 }

572 }

573 g_list_free(msgout_cloned->rcpt_list);

574 msgout_cloned->rcpt_list = rcpt_list_non_delivered;

575

576 if (!msgout_cloned->rcpt_list) {

577 destroy_msg_out(msgout_cloned);

578 continue;

579 }

580

581 /* filter by allowed envelope sender */

582 if (!route_sender_is_allowed(route, msgout->msg->return_path)) {

583 destroy_msg_out(msgout_cloned);

584 continue;

585 }

586

587 /* filter by allowed envelope rcpts */

588 GList *rcpt_list_allowed = NULL;

589 GList *rcpt_list_notallowed = NULL;

590 route_split_rcpts(route, msgout_cloned->rcpt_list,

591 &rcpt_list_allowed, &rcpt_list_notallowed);

592 if (!rcpt_list_allowed) {

593 destroy_msg_out(msgout_cloned);

594 continue;

595 }

596

597 logwrite(LOG_NOTICE, "%s using '%s'\n", msgout->msg->uid,

598 route->name);

599

600 g_list_free(msgout_cloned->rcpt_list);

601 msgout_cloned->rcpt_list = rcpt_list_allowed;

602

603 if (route->last_route) {

604 GList *rcpt_node;

605 foreach(msgout_cloned->rcpt_list, rcpt_node) {

606 address *rcpt = (address *) (rcpt_node->data);

607 rcpt->flags |= ADDR_FLAG_LAST_ROUTE;

608 }

609 }

610

611 route_prepare_msgout(route, msgout_cloned);

612 msgout_list_deliver = g_list_append(msgout_list_deliver, msgout_cloned);

613 }

614

615 if (msgout_list_deliver) {

616 if (deliver_route_msgout_list(route, msgout_list_deliver)) {

617 ok = TRUE;

618 }

619 destroy_msg_out_list(msgout_list_deliver);

620 }

621 return ok;

622 }

623

624 /*

625 ** copy pointers of delivered addresses to the msg's non_rcpt_list,

626 ** to make sure that they will not be delivered again.

627 */

628 void

629 update_non_rcpt_list(msg_out *msgout)

630 {

631 GList *rcpt_node;

632 message *msg = msgout->msg;

633

634 foreach(msgout->rcpt_list, rcpt_node) {

635 address *rcpt = (address *) (rcpt_node->data);

636 if (addr_is_delivered(rcpt) || addr_is_failed(rcpt)) {

637 msg->non_rcpt_list = g_list_append(msg->non_rcpt_list, rcpt);

638 }

639 }

640 }

641

642 /*

643 ** after delivery attempts, we check if there are any rcpt addresses left in

644 ** the message. If all addresses have been completed, the spool files will be

645 ** deleted, otherwise the header spool will be written back. We never changed

646 ** the data spool, so there is no need to write that back.

647 **

648 ** returns TRUE if all went well.

649 */

650 gboolean

651 deliver_finish(msg_out *msgout)

652 {

653 GList *rcpt_node;

654 message *msg = msgout->msg;

655 gboolean finished = TRUE;

656

657 update_non_rcpt_list(msgout);

658

659 /*

660 ** we NEVER made copies of the addresses, flags affecting addresses

661 ** were always set on the original address structs

662 */

663 foreach(msg->rcpt_list, rcpt_node) {

664 address *rcpt = (address *) (rcpt_node->data);

665 if (!addr_is_finished_children(rcpt)) {

666 finished = FALSE;

667 } else {

668 /*

669 ** if ALL children have been delivered, mark parent as

670 ** delivered. if there is one or more not delivered,

671 ** it must have failed, we mark the parent as failed

672 ** as well.

673 */

674 if (addr_is_delivered_children(rcpt)) {

675 addr_mark_delivered(rcpt);

676 } else {

677 addr_mark_failed(rcpt);

678 }

679 }

680 }

681

682 if (finished) {

683 if (spool_delete_all(msg)) {

684 logwrite(LOG_NOTICE, "%s completed.\n", msg->uid);

685 return TRUE;

686 }

687 return FALSE;

688 }

689

690 /* one not delivered address was found */

691 if (!spool_write(msg, FALSE)) {

692 logwrite(LOG_ALERT, "could not write back spool header for %s\n", msg->uid);

693 return FALSE;

694 }

695

696 DEBUG(2) debugf("spool header for %s written back.\n", msg->uid);

697 return TRUE;

698 }

699

700 int

701 deliver_remote(GList *remote_msgout_list)

702 {

703 int ok = TRUE;

704 GList *route_list = NULL;

705 GList *route_node;

706 GList *rf_list = NULL;

707 gchar *connect_name = NULL;

708

709 if (!remote_msgout_list) {

710 return FALSE;

711 }

712

713 /* perma routes */

714 if (conf.perma_routes) {

715 DEBUG(5) debugf("processing perma_routes\n");

716

717 route_list = read_route_list(conf.perma_routes, TRUE);

718 foreach(route_list, route_node) {

719 connect_route *route = (connect_route *) (route_node->data);

720 if (!deliver_route_msg_list(route, remote_msgout_list)) {

721 ok = FALSE;

722 }

723 }

724 destroy_route_list(route_list);

725 }

726

727 /* query routes */

728 connect_name = online_query();

729 if (!connect_name) {

730 DEBUG(5) debugf("online query returned false\n");

731 return FALSE;

732 }

733

734 /* we are online! */

735 DEBUG(5) debugf("processing query_routes\n");

736 logwrite(LOG_NOTICE, "detected online configuration `%s'\n", connect_name);

737

738 rf_list = (GList *) table_find(conf.query_routes, connect_name);

739 if (!rf_list) {

740 logwrite(LOG_ALERT, "route list with name '%s' not found.\n", connect_name);

741 return FALSE;

742 }

743

744 route_list = read_route_list(rf_list, FALSE);

745 if (!route_list) {

746 logwrite(LOG_ALERT, "could not read route list '%s'\n", connect_name);

747 return FALSE;

748 }

749

750 foreach(route_list, route_node) {

751 connect_route *route = (connect_route *) (route_node->data);

752 /* TODO: ok gets overwritten */

753 ok = deliver_route_msg_list(route, remote_msgout_list);

754 }

755 destroy_route_list(route_list);

756

757 return ok;

758 }

759

760 /*

761 ** This function splits the list of rcpt addresses

762 ** into local and remote addresses and processes them accordingly.

763 */

764 gboolean

765 deliver_msg_list(GList *msg_list, guint flags)

766 {

767 GList *msgout_list = NULL;

768 GList *msg_node;

769 GList *local_msgout_list = NULL;

770 GList *remote_msgout_list = NULL;

771 GList *msgout_node;

772 GList *alias_table = NULL;

773 gboolean ok = TRUE;

774

775 /* create msgout_list */

776 foreach(msg_list, msg_node) {

777 message *msg = (message *) msg_node->data;

778 msgout_list = g_list_append(msgout_list, create_msg_out(msg));

779 }

780

781 if (conf.alias_file) {

782 alias_table = table_read(conf.alias_file, ':');

783 }

784

785 /* sort messages for different deliveries */

786 foreach(msgout_list, msgout_node) {

787 msg_out *msgout = (msg_out *) (msgout_node->data);

788 GList *rcpt_list;

789 GList *local_rcpt_list = NULL;

790 GList *other_rcpt_list = NULL;

791

792 if (!spool_lock(msgout->msg->uid)) {

793 DEBUG(5) debugf("spool_lock(%s) failed.\n", msgout->msg->uid);

794 continue;

795 }

796 DEBUG(5) debugf("spool_lock(%s)\n", msgout->msg->uid);

797

798 rcpt_list = g_list_copy(msgout->msg->rcpt_list);

799 if (conf.log_user) {

800 address *addr = create_address_qualified(conf.log_user, TRUE, conf.host_name);

801 if (addr) {

802 rcpt_list = g_list_prepend(rcpt_list, addr);

803 } else {

804 logwrite(LOG_ALERT, "invalid log_user address `%s', ignoring\n", conf.log_user);

805 }

806 }

807 if (alias_table) {

808 GList *aliased_rcpt_list;

809 aliased_rcpt_list = alias_expand(alias_table, rcpt_list, msgout->msg->non_rcpt_list);

810 g_list_free(rcpt_list);

811 rcpt_list = aliased_rcpt_list;

812 }

813

814 /* split_rcpts(rcpt_list, NULL, &local_rcpt_list, NULL, &other_rcpt_list); */

815 local_rcpt_list = local_rcpts(rcpt_list);

816 other_rcpt_list = remote_rcpts(rcpt_list);

817 g_list_free(rcpt_list);

818

819 /* local recipients */

820 if ((flags & DLVR_LOCAL) && local_rcpt_list) {

821 msg_out *local_msgout = clone_msg_out(msgout);

822 local_msgout->rcpt_list = local_rcpt_list;

823 local_msgout_list = g_list_append(local_msgout_list, local_msgout);

824 }

825

826 /* remote recipients, requires online delivery */

827 if ((flags & DLVR_ONLINE) && other_rcpt_list) {

828 msg_out *remote_msgout = clone_msg_out(msgout);

829 remote_msgout->rcpt_list = other_rcpt_list;

830 remote_msgout_list = g_list_append(remote_msgout_list, remote_msgout);

831 }

832 }

833

834 if (alias_table) {

835 destroy_table(alias_table);

836 }

837

838 /* process local/remote msgout lists -> delivery */

839

840 if (local_msgout_list) {

841 DEBUG(5) debugf("local_msgout_list\n");

842 foreach(local_msgout_list, msgout_node) {

843 msg_out *msgout = (msg_out *) (msgout_node->data);

844 if (!deliver_local(msgout)) {

845 ok = FALSE;

846 }

847 }

848 destroy_msg_out_list(local_msgout_list);

849 }

850

851 if (remote_msgout_list) {

852 DEBUG(5) debugf("remote_msgout_list\n");

853 deliver_remote(remote_msgout_list);

854 destroy_msg_out_list(remote_msgout_list);

855 }

856

857 /* unlock spool files */

858 foreach(msgout_list, msgout_node) {

859 msg_out *msgout = (msg_out *) (msgout_node->data);

860 if (spool_unlock(msgout->msg->uid)) {

861 DEBUG(5) debugf("spool_unlock(%s)\n", msgout->msg->uid);

862 } else {

863 DEBUG(5) debugf("spool_unlock(%s) failed.\n", msgout->msg->uid);

864 }

865 }

866 destroy_msg_out_list(msgout_list);

867

868 return ok;

869 }

870

871 /*

872 ** deliver() is called when a message has just been received

873 ** (mode_accept and smtp_in) and should be delivered immediately

874 ** (neither -odq nor do_queue). Only this one message will be tried to

875 ** deliver then.

876 */

877 gboolean

878 deliver(message *msg)

879 {

880 gboolean ok;

881 GList *msg_list = g_list_append(NULL, msg);

882

883 ok = deliver_msg_list(msg_list, DLVR_ALL);

884 g_list_free(msg_list);

885

886 return ok;

887 }