masqmail: c98aa884d2cb src/deliver.c

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

382 }

383 if (ret) {

384 deliver_finish(msgout);

385 }

386 }

387 }

388 return ok;

389 }

390

391

392 if (route->wrapper) {

393 /* it seems as if the remote_host is only set for logging

394 /* XXX: this could probably be moved into smtp_out_open_child() */

395 psb->remote_host = host;

396 }

397

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

399

400 #ifdef ENABLE_AUTH

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

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

403 }

404 #endif

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

406 /* smtp_out_init() failed */

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

408 smtp_out_quit(psb);

409

410 foreach(msgout_list, msgout_node) {

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

412 smtp_out_mark_rcpts(psb, msgout->rcpt_list);

413

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

415 deliver_finish(msgout);

416 }

417 }

418 }

419 destroy_smtpbase(psb);

420 return ok;

421 }

422

423 if (!route->do_pipelining) {

424 psb->use_pipelining = FALSE;

425 }

426

427 foreach(msgout_list, msgout_node) {

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

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

430 message *msg = msgout->msg;

431

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

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

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

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

436 break;

437 }

438

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

440

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

442

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

444 /* connection lost */

445 break;

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

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

448 break;

449 }

450 }

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

452

453 if (flag) {

454 msg_free_data(msg);

455 }

456 if (ok_msg) {

457 ok = TRUE;

458 }

459 if (ok_msg || ok_fail) {

460 deliver_finish(msgout);

461 }

462 }

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

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

465 smtp_out_quit(psb);

466 }

467 destroy_smtpbase(psb);

468 return ok;

469 }

470

471 gboolean

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

473 {

474

475 if (route->pipe) {

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

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

478 } else {

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

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

481 }

482 }

483

484 /*

485 delivers messages in msgout_list using route

486 */

487 gboolean

488 deliver_route_msgout_list(connect_route * route, GList * msgout_list)

489 {

490 gboolean ok = FALSE;

491 GList *mo_ph_list;

492 GList *mo_ph_node;

493

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

495

496 if (route->mail_host) {

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

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

499 }

500

501 /* this is not easy... */

502

503 mo_ph_list = route_msgout_list(route, msgout_list);

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

505 if (!mo_ph_list) {

506 return FALSE;

507 }

508

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

510 We cannot do that yet because of complications with finishing the

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

512 memory. But we are not thread safe yet...

513 */

514 foreach(mo_ph_list, mo_ph_node) {

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

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

517 ok = TRUE;

518 }

519 destroy_msgout_perhost(mo_ph);

520 }

521 g_list_free(mo_ph_list);

522 return ok;

523 }

524

525 /*

526 calls route_prepare_msg()

527 delivers messages in msg_list using route by calling deliver_route_msgout_list()

528 */

529 gboolean

530 deliver_route_msg_list(connect_route * route, GList * msgout_list)

531 {

532 GList *msgout_list_deliver = NULL;

533 GList *msgout_node;

534 gboolean ok = TRUE;

535

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

537

538 foreach(msgout_list, msgout_node) {

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

540 msg_out *msgout_cloned = clone_msg_out(msgout);

541 GList *rcpt_list_non_delivered = NULL;

542 GList *rcpt_node;

543

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

545 previous route may have delivered to it */

546 foreach(msgout_cloned->rcpt_list, rcpt_node) {

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

548 /* failed addresses already have been bounced;

549 there should be a better way to handle those. */

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

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

552 rcpt_list_non_delivered = g_list_append(rcpt_list_non_delivered, rcpt);

553 }

554 }

555 g_list_free(msgout_cloned->rcpt_list);

556 msgout_cloned->rcpt_list = rcpt_list_non_delivered;

557

558 if (!msgout_cloned->rcpt_list) {

559 destroy_msg_out(msgout_cloned);

560 continue;

561 }

562

563 /* filter by allowed return paths (= envelope sender) */

564 if (!route_is_allowed_mail_local(route, msgout->msg->return_path)

565 || !route_is_allowed_return_path(route, msgout->msg->return_path)) {

566 destroy_msg_out(msgout_cloned);

567 continue;

568 }

569

570 /* filter by allowed rcpt addrs (= envelope rcpts) */

571 GList *rcpt_list_allowed = NULL, *rcpt_list_notallowed = NULL;

572 msg_rcptlist_route(route, msgout_cloned->rcpt_list, &rcpt_list_allowed, &rcpt_list_notallowed);

573

574 if (!rcpt_list_allowed) {

575 destroy_msg_out(msgout_cloned);

576 continue;

577 }

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

579

580 g_list_free(msgout_cloned->rcpt_list);

581 msgout_cloned->rcpt_list = rcpt_list_allowed;

582

583 if (route->last_route) {

584 GList *rcpt_node;

585 foreach(msgout_cloned->rcpt_list, rcpt_node) {

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

587 rcpt->flags |= ADDR_FLAG_LAST_ROUTE;

588 }

589 }

590

591 route_prepare_msgout(route, msgout_cloned);

592 msgout_list_deliver = g_list_append(msgout_list_deliver, msgout_cloned);

593 }

594

595 if (msgout_list_deliver) {

596 if (deliver_route_msgout_list(route, msgout_list_deliver)) {

597 ok = TRUE;

598 }

599 destroy_msg_out_list(msgout_list_deliver);

600 }

601 return ok;

602 }

603

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

605 to make sure that they will not be delivered again.

606 */

607 void

608 update_non_rcpt_list(msg_out * msgout)

609 {

610 GList *rcpt_node;

611 message *msg = msgout->msg;

612

613 foreach(msgout->rcpt_list, rcpt_node) {

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

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

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

617 }

618 }

619 }

620

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

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

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

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

625

626 returns TRUE if all went well.

627 */

628 gboolean

629 deliver_finish(msg_out * msgout)

630 {

631 GList *rcpt_node;

632 message *msg = msgout->msg;

633 gboolean finished = TRUE;

634

635 update_non_rcpt_list(msgout);

636

637 /* we NEVER made copies of the addresses, flags affecting addresses

638 were always set on the original address structs */

639 foreach(msg->rcpt_list, rcpt_node) {

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

641 if (!addr_is_finished_children(rcpt)) {

642 finished = FALSE;

643 } else {

644 /* if ALL children have been delivered, mark parent as

645 delivered. if there is one or more not delivered,

646 it must have failed, we mark the parent as failed

647 as well.

648 */

649 if (addr_is_delivered_children(rcpt)) {

650 addr_mark_delivered(rcpt);

651 } else {

652 addr_mark_failed(rcpt);

653 }

654 }

655 }

656

657 if (finished) {

658 if (spool_delete_all(msg)) {

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

660 return TRUE;

661 }

662 return FALSE;

663 }

664

665 /* one not delivered address was found */

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

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

668 return FALSE;

669 }

670

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

672 return TRUE;

673 }

674

675 gboolean

676 deliver_finish_list(GList * msgout_list)

677 {

678 gboolean ok = TRUE;

679 GList *msgout_node;

680 foreach(msgout_list, msgout_node) {

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

682 if (!deliver_finish(msgout)) {

683 ok = FALSE;

684 }

685 }

686 return ok;

687 }

688

689 gboolean

690 deliver_msgout_list_online(GList * msgout_list)

691 {

692 GList *rf_list = NULL;

693 gchar *connect_name = NULL;

694 gboolean ok = FALSE;

695

696 connect_name = online_query();

697 if (!connect_name) {

698 return FALSE;

699 }

700

701 /* we are online! */

702 logwrite(LOG_NOTICE, "detected online configuration %s\n", connect_name);

703

704 rf_list = (GList *) table_find(conf.connect_routes, connect_name);

705 if (!rf_list) {

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

707 return FALSE;

708 }

709

710 GList *route_list = read_route_list(rf_list, FALSE);

711 if (!route_list) {

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

713 return FALSE;

714 }

715

716 GList *route_node;

717 foreach(route_list, route_node) {

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

719 /* TODO: ok gets overwritten */

720 ok = deliver_route_msg_list(route, msgout_list);

721 }

722 destroy_route_list(route_list);

723 return ok;

724 }

725

726 gboolean

727 deliver_msg_list(GList * msg_list, guint flags)

728 {

729 GList *msgout_list = create_msg_out_list(msg_list);

730 GList *local_msgout_list = NULL;

731 GList *localnet_msgout_list = NULL;

732 GList *other_msgout_list = NULL;

733 GList *msgout_node;

734 GList *alias_table = NULL;

735 gboolean ok = TRUE;

736

737 if (conf.alias_file) {

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

739 }

740

741 /* sort messages for different deliveries */

742 foreach(msgout_list, msgout_node) {

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

744 GList *rcpt_list;

745 GList *local_rcpt_list = NULL;

746 GList *localnet_rcpt_list = NULL;

747 GList *other_rcpt_list = NULL;

748

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

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

751 continue;

752 }

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

754

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

756 if (conf.log_user) {

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

758 if (addr) {

759 rcpt_list = g_list_prepend(rcpt_list, addr);

760 } else {

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

762 }

763 }

764 if (alias_table) {

765 GList *aliased_rcpt_list;

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

767 g_list_free(rcpt_list);

768 rcpt_list = aliased_rcpt_list;

769 }

770

771 split_rcpts(rcpt_list, conf.local_nets, &local_rcpt_list, &localnet_rcpt_list, &other_rcpt_list);

772 g_list_free(rcpt_list);

773

774 /* local recipients */

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

776 msg_out *local_msgout = clone_msg_out(msgout);

777 local_msgout->rcpt_list = local_rcpt_list;

778 local_msgout_list = g_list_append(local_msgout_list, local_msgout);

779 }

780

781 /* local net recipients */

782 if ((flags & DLVR_LAN) && localnet_rcpt_list) {

783 msg_out *localnet_msgout = clone_msg_out(msgout);

784 localnet_msgout->rcpt_list = localnet_rcpt_list;

785 localnet_msgout_list = g_list_append(localnet_msgout_list, localnet_msgout);

786 }

787

788 /* remote recipients (the rest), requires online delivery */

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

790 msg_out *other_msgout = clone_msg_out(msgout);

791 other_msgout->rcpt_list = other_rcpt_list;

792 other_msgout_list = g_list_append(other_msgout_list, other_msgout);

793 }

794 }

795

796 if (alias_table) {

797 destroy_table(alias_table);

798 }

799

800 /* actual delivery */

801

802 if (local_msgout_list) {

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

804 foreach(local_msgout_list, msgout_node) {

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

806 if (!deliver_local(msgout)) {

807 ok = FALSE;

808 }

809 }

810 destroy_msg_out_list(local_msgout_list);

811 }

812

813 if (localnet_msgout_list) {

814 GList *route_list = NULL;

815 GList *route_node;

816

817 DEBUG(5) debugf("localnet_msgout_list\n");

818 if (conf.local_net_routes) {

819 route_list = read_route_list(conf.local_net_routes, TRUE);

820 } else {

821 route_list = g_list_append(NULL, create_local_route());

822 }

823

824 foreach(route_list, route_node) {

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

826 if (!deliver_route_msg_list(route, localnet_msgout_list)) {

827 ok = FALSE;

828 }

829 }

830 destroy_msg_out_list(localnet_msgout_list);

831 destroy_route_list(route_list);

832 }

833

834 if (other_msgout_list) {

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

836 if (!deliver_msgout_list_online(other_msgout_list)) {

837 ok = FALSE;

838 }

839 destroy_msg_out_list(other_msgout_list);

840 }

841

842 foreach(msgout_list, msgout_node) {

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

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

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

846 } else {

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

848 }

849

850 }

851

852 destroy_msg_out_list(msgout_list);

853

854 return ok;

855 }

856

857 /* This function searches in the list of rcpt addresses

858 for local and 'local net' addresses. Remote addresses

859 which are reachable only when online are treated specially

860 in another function.

861

862 deliver() is called when a message has just been received and should

863 be delivered immediately.

864 */

865 gboolean

866 deliver(message * msg)

867 {

868 gboolean ok;

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

870

871 ok = deliver_msg_list(msg_list, DLVR_ALL);

872 g_list_free(msg_list);

873

874 return ok;

875 }