masqmail: b27f66555ba8 src/deliver.c

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

397 }

398 if (ret) {

399 deliver_finish(msgout);

400 }

401 }

402 }

403 return ok;

404 }

405

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

407

408 #ifdef ENABLE_AUTH

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

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

411 }

412 #endif

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

414 /* smtp_out_init() failed */

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

416 smtp_out_quit(psb);

417

418 foreach(msgout_list, msgout_node) {

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

420 smtp_out_mark_rcpts(psb, msgout->rcpt_list);

421

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

423 deliver_finish(msgout);

424 }

425 }

426 }

427 destroy_smtpbase(psb);

428 return ok;

429 }

430

431 if (!route->do_pipelining) {

432 psb->use_pipelining = FALSE;

433 }

434

435 foreach(msgout_list, msgout_node) {

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

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

438 message *msg = msgout->msg;

439

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

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

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

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

444 break;

445 }

446

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

448

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

450

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

452 /* connection lost */

453 break;

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

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

456 break;

457 }

458 }

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

460

461 if (flag) {

462 msg_free_data(msg);

463 }

464 if (ok_msg) {

465 ok = TRUE;

466 }

467 if (ok_msg || ok_fail) {

468 deliver_finish(msgout);

469 }

470 }

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

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

473 smtp_out_quit(psb);

474 }

475 destroy_smtpbase(psb);

476 return ok;

477 }

478

479 gboolean

480 deliver_msglist_host(connect_route *route, GList *msgout_list, gchar *host, GList *res_list)

481 {

482

483 if (route->pipe) {

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

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

486 } else {

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

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

489 }

490 }

491

492 /*

493 ** delivers messages in msgout_list using route

494 */

495 gboolean

496 deliver_route_msgout_list(connect_route *route, GList *msgout_list)

497 {

498 gboolean ok = FALSE;

499 GList *mo_ph_list;

500 GList *mo_ph_node;

501

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

503

504 if (route->mail_host) {

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

506 return deliver_msglist_host(route, msgout_list, NULL, route->resolve_list);

507 }

508

509 /* this is not easy... */

510

511 mo_ph_list = route_msgout_list(route, msgout_list);

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

513 if (!mo_ph_list) {

514 return FALSE;

515 }

516

517 /*

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

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

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

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

522 */

523 foreach(mo_ph_list, mo_ph_node) {

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

525 if (deliver_msglist_host(route, mo_ph->msgout_list, mo_ph->host, route->resolve_list)) {

526 ok = TRUE;

527 }

528 destroy_msgout_perhost(mo_ph);

529 }

530 g_list_free(mo_ph_list);

531 return ok;

532 }

533

534 /*

535 ** calls route_prepare_msg()

536 ** delivers messages in msg_list using route by calling

537 ** deliver_route_msgout_list()

538 */

539 gboolean

540 deliver_route_msg_list(connect_route *route, GList *msgout_list)

541 {

542 GList *msgout_list_deliver = NULL;

543 GList *msgout_node;

544 gboolean ok = TRUE;

545

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

547

548 foreach(msgout_list, msgout_node) {

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

550 msg_out *msgout_cloned = clone_msg_out(msgout);

551 GList *rcpt_list_non_delivered = NULL;

552 GList *rcpt_node;

553

554 /*

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

556 ** previous route may have delivered to it

557 */

558 foreach(msgout_cloned->rcpt_list, rcpt_node) {

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

560 /*

561 ** failed addresses already have been bounced;

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

563 */

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

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

566 rcpt_list_non_delivered = g_list_append(rcpt_list_non_delivered, rcpt);

567 }

568 }

569 g_list_free(msgout_cloned->rcpt_list);

570 msgout_cloned->rcpt_list = rcpt_list_non_delivered;

571

572 if (!msgout_cloned->rcpt_list) {

573 destroy_msg_out(msgout_cloned);

574 continue;

575 }

576

577 /* filter by allowed envelope sender */

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

579 destroy_msg_out(msgout_cloned);

580 continue;

581 }

582

583 /* filter by allowed envelope rcpts */

584 GList *rcpt_list_allowed = NULL;

585 GList *rcpt_list_notallowed = NULL;

586 route_split_rcpts(route, msgout_cloned->rcpt_list, &rcpt_list_allowed, &rcpt_list_notallowed);

587 if (!rcpt_list_allowed) {

588 destroy_msg_out(msgout_cloned);

589 continue;

590 }

591

592 logwrite(LOG_NOTICE, "%s using '%s'\n", msgout->msg->uid, route->name);

593

594 g_list_free(msgout_cloned->rcpt_list);

595 msgout_cloned->rcpt_list = rcpt_list_allowed;

596

597 if (route->last_route) {

598 GList *rcpt_node;

599 foreach(msgout_cloned->rcpt_list, rcpt_node) {

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

601 rcpt->flags |= ADDR_FLAG_LAST_ROUTE;

602 }

603 }

604

605 route_prepare_msgout(route, msgout_cloned);

606 msgout_list_deliver = g_list_append(msgout_list_deliver, msgout_cloned);

607 }

608

609 if (msgout_list_deliver) {

610 if (deliver_route_msgout_list(route, msgout_list_deliver)) {

611 ok = TRUE;

612 }

613 destroy_msg_out_list(msgout_list_deliver);

614 }

615 return ok;

616 }

617

618 /*

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

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

621 */

622 void

623 update_non_rcpt_list(msg_out *msgout)

624 {

625 GList *rcpt_node;

626 message *msg = msgout->msg;

627

628 foreach(msgout->rcpt_list, rcpt_node) {

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

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

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

632 }

633 }

634 }

635

636 /*

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

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

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

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

641 **

642 ** returns TRUE if all went well.

643 */

644 gboolean

645 deliver_finish(msg_out *msgout)

646 {

647 GList *rcpt_node;

648 message *msg = msgout->msg;

649 gboolean finished = TRUE;

650

651 update_non_rcpt_list(msgout);

652

653 /*

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

655 ** were always set on the original address structs

656 */

657 foreach(msg->rcpt_list, rcpt_node) {

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

659 if (!addr_is_finished_children(rcpt)) {

660 finished = FALSE;

661 } else {

662 /*

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

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

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

666 ** as well.

667 */

668 if (addr_is_delivered_children(rcpt)) {

669 addr_mark_delivered(rcpt);

670 } else {

671 addr_mark_failed(rcpt);

672 }

673 }

674 }

675

676 if (finished) {

677 if (spool_delete_all(msg)) {

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

679 return TRUE;

680 }

681 return FALSE;

682 }

683

684 /* one not delivered address was found */

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

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

687 return FALSE;

688 }

689

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

691 return TRUE;

692 }

693

694 int

695 deliver_remote(GList *remote_msgout_list)

696 {

697 int ok = TRUE;

698 GList *route_list = NULL;

699 GList *route_node;

700 GList *rf_list = NULL;

701 gchar *connect_name = NULL;

702

703 if (!remote_msgout_list) {

704 return FALSE;

705 }

706

707 /* perma routes */

708 if (conf.perma_routes) {

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

710

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

712 foreach(route_list, route_node) {

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

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

715 ok = FALSE;

716 }

717 }

718 destroy_route_list(route_list);

719 }

720

721 /* query routes */

722 connect_name = online_query();

723 if (!connect_name) {

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

725 return FALSE;

726 }

727

728 /* we are online! */

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

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

731

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

733 if (!rf_list) {

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

735 return FALSE;

736 }

737

738 route_list = read_route_list(rf_list, FALSE);

739 if (!route_list) {

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

741 return FALSE;

742 }

743

744 foreach(route_list, route_node) {

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

746 /* TODO: ok gets overwritten */

747 ok = deliver_route_msg_list(route, remote_msgout_list);

748 }

749 destroy_route_list(route_list);

750

751 return ok;

752 }

753

754 /*

755 ** This function splits the list of rcpt addresses

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

757 */

758 gboolean

759 deliver_msg_list(GList *msg_list, guint flags)

760 {

761 GList *msgout_list = NULL;

762 GList *msg_node;

763 GList *local_msgout_list = NULL;

764 GList *remote_msgout_list = NULL;

765 GList *msgout_node;

766 GList *alias_table = NULL;

767 gboolean ok = TRUE;

768

769 /* create msgout_list */

770 foreach(msg_list, msg_node) {

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

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

773 }

774

775 if (conf.alias_file) {

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

777 }

778

779 /* sort messages for different deliveries */

780 foreach(msgout_list, msgout_node) {

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

782 GList *rcpt_list;

783 GList *local_rcpt_list = NULL;

784 GList *other_rcpt_list = NULL;

785

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

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

788 continue;

789 }

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

791

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

793 if (conf.log_user) {

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

795 if (addr) {

796 rcpt_list = g_list_prepend(rcpt_list, addr);

797 } else {

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

799 }

800 }

801 if (alias_table) {

802 GList *aliased_rcpt_list;

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

804 g_list_free(rcpt_list);

805 rcpt_list = aliased_rcpt_list;

806 }

807

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

809 local_rcpt_list = local_rcpts(rcpt_list);

810 other_rcpt_list = remote_rcpts(rcpt_list);

811 g_list_free(rcpt_list);

812

813 /* local recipients */

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

815 msg_out *local_msgout = clone_msg_out(msgout);

816 local_msgout->rcpt_list = local_rcpt_list;

817 local_msgout_list = g_list_append(local_msgout_list, local_msgout);

818 }

819

820 /* remote recipients, requires online delivery */

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

822 msg_out *remote_msgout = clone_msg_out(msgout);

823 remote_msgout->rcpt_list = other_rcpt_list;

824 remote_msgout_list = g_list_append(remote_msgout_list, remote_msgout);

825 }

826 }

827

828 if (alias_table) {

829 destroy_table(alias_table);

830 }

831

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

833

834 if (local_msgout_list) {

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

836 foreach(local_msgout_list, msgout_node) {

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

838 if (!deliver_local(msgout)) {

839 ok = FALSE;

840 }

841 }

842 destroy_msg_out_list(local_msgout_list);

843 }

844

845 if (remote_msgout_list) {

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

847 deliver_remote(remote_msgout_list);

848 destroy_msg_out_list(remote_msgout_list);

849 }

850

851 /* unlock spool files */

852 foreach(msgout_list, msgout_node) {

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

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

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

856 } else {

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

858 }

859 }

860 destroy_msg_out_list(msgout_list);

861

862 return ok;

863 }

864

865 /*

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

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

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

869 ** deliver then.

870 */

871 gboolean

872 deliver(message *msg)

873 {

874 gboolean ok;

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

876

877 ok = deliver_msg_list(msg_list, DLVR_ALL);

878 g_list_free(msg_list);

879

880 return ok;

881 }