masqmail: d04894d0fc64 src/deliver.c

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

386 }

387 if (ret) {

388 deliver_finish(msgout);

389 }

390 }

391 }

392 return ok;

393 }

394

395

396 if (route->wrapper) {

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

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

399 psb->remote_host = host;

400 }

401

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

403

404 #ifdef ENABLE_AUTH

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

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

407 }

408 #endif

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

410 /* smtp_out_init() failed */

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

412 smtp_out_quit(psb);

413

414 foreach(msgout_list, msgout_node) {

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

416 smtp_out_mark_rcpts(psb, msgout->rcpt_list);

417

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

419 deliver_finish(msgout);

420 }

421 }

422 }

423 destroy_smtpbase(psb);

424 return ok;

425 }

426

427 if (!route->do_pipelining) {

428 psb->use_pipelining = FALSE;

429 }

430

431 foreach(msgout_list, msgout_node) {

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

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

434 message *msg = msgout->msg;

435

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

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

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

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

440 break;

441 }

442

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

444

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

446

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

448 /* connection lost */

449 break;

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

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

452 break;

453 }

454 }

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

456

457 if (flag) {

458 msg_free_data(msg);

459 }

460 if (ok_msg) {

461 ok = TRUE;

462 }

463 if (ok_msg || ok_fail) {

464 deliver_finish(msgout);

465 }

466 }

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

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

469 smtp_out_quit(psb);

470 }

471 destroy_smtpbase(psb);

472 return ok;

473 }

474

475 gboolean

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

477 {

478 DEBUG(5) debugf("protocol = %s\n", route->protocol);

479

480 if (strcmp(route->protocol, "pipe") == 0) {

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

482 } else {

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

484 }

485 }

486

487 /*

488 delivers messages in msgout_list using route

489 */

490 gboolean

491 deliver_route_msgout_list(connect_route * route, GList * msgout_list)

492 {

493 gboolean ok = FALSE;

494 GList *mo_ph_list;

495 GList *mo_ph_node;

496

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

498

499 if (route->mail_host) {

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

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

502 }

503

504 /* this is not easy... */

505

506 mo_ph_list = route_msgout_list(route, msgout_list);

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

508 if (!mo_ph_list) {

509 return FALSE;

510 }

511

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

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

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

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

516 */

517 foreach(mo_ph_list, mo_ph_node) {

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

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

520 ok = TRUE;

521 }

522 destroy_msgout_perhost(mo_ph);

523 }

524 g_list_free(mo_ph_list);

525 return ok;

526 }

527

528 /*

529 calls route_prepare_msg()

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

531 */

532 gboolean

533 deliver_route_msg_list(connect_route * route, GList * msgout_list)

534 {

535 GList *msgout_list_deliver = NULL;

536 GList *msgout_node;

537 gboolean ok = TRUE;

538

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

540

541 foreach(msgout_list, msgout_node) {

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

543 msg_out *msgout_cloned = clone_msg_out(msgout);

544 GList *rcpt_list_non_delivered = NULL;

545 GList *rcpt_node;

546

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

548 previous route may have delivered to it */

549 foreach(msgout_cloned->rcpt_list, rcpt_node) {

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

551 /* failed addresses already have been bounced;

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

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

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

555 rcpt_list_non_delivered = g_list_append(rcpt_list_non_delivered, rcpt);

556 }

557 }

558 g_list_free(msgout_cloned->rcpt_list);

559 msgout_cloned->rcpt_list = rcpt_list_non_delivered;

560

561 if (!msgout_cloned->rcpt_list) {

562 destroy_msg_out(msgout_cloned);

563 continue;

564 }

565

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

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

568 destroy_msg_out(msgout_cloned);

569 continue;

570 }

571

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

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

574

575 if (!rcpt_list_allowed) {

576 destroy_msg_out(msgout_cloned);

577 continue;

578 }

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

580

581 g_list_free(msgout_cloned->rcpt_list);

582 msgout_cloned->rcpt_list = rcpt_list_allowed;

583

584 if (route->last_route) {

585 GList *rcpt_node;

586 foreach(msgout_cloned->rcpt_list, rcpt_node) {

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

588 rcpt->flags |= ADDR_FLAG_LAST_ROUTE;

589 }

590 }

591

592 route_prepare_msgout(route, msgout_cloned);

593 msgout_list_deliver = g_list_append(msgout_list_deliver, msgout_cloned);

594 }

595

596 if (msgout_list_deliver) {

597 if (deliver_route_msgout_list(route, msgout_list_deliver)) {

598 ok = TRUE;

599 }

600 destroy_msg_out_list(msgout_list_deliver);

601 }

602 return ok;

603 }

604

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

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

607 */

608 void

609 update_non_rcpt_list(msg_out * msgout)

610 {

611 GList *rcpt_node;

612 message *msg = msgout->msg;

613

614 foreach(msgout->rcpt_list, rcpt_node) {

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

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

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

618 }

619 }

620 }

621

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

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

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

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

626

627 returns TRUE if all went well.

628 */

629 gboolean

630 deliver_finish(msg_out * msgout)

631 {

632 GList *rcpt_node;

633 message *msg = msgout->msg;

634 gboolean finished = TRUE;

635

636 update_non_rcpt_list(msgout);

637

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

639 were always set on the original address structs */

640 foreach(msg->rcpt_list, rcpt_node) {

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

642 if (!addr_is_finished_children(rcpt)) {

643 finished = FALSE;

644 } else {

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

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

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

648 as well.

649 */

650 if (addr_is_delivered_children(rcpt)) {

651 addr_mark_delivered(rcpt);

652 } else {

653 addr_mark_failed(rcpt);

654 }

655 }

656 }

657

658 if (finished) {

659 if (spool_delete_all(msg)) {

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

661 return TRUE;

662 }

663 return FALSE;

664 }

665

666 /* one not delivered address was found */

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

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

669 return FALSE;

670 }

671

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

673 return TRUE;

674 }

675

676 gboolean

677 deliver_finish_list(GList * msgout_list)

678 {

679 gboolean ok = TRUE;

680 GList *msgout_node;

681 foreach(msgout_list, msgout_node) {

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

683 if (!deliver_finish(msgout)) {

684 ok = FALSE;

685 }

686 }

687 return ok;

688 }

689

690 gboolean

691 deliver_msgout_list_online(GList * msgout_list)

692 {

693 GList *rf_list = NULL;

694 gchar *connect_name = NULL;

695 gboolean ok = FALSE;

696

697 connect_name = detect_online();

698 if (!connect_name) {

699 return FALSE;

700 }

701

702 /* we are online! */

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

704

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

706 if (!rf_list) {

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

708 return FALSE;

709 }

710

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

712 if (!route_list) {

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

714 return FALSE;

715 }

716

717 GList *route_node;

718 foreach(route_list, route_node) {

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

720 /* TODO: ok gets overwritten */

721 ok = deliver_route_msg_list(route, msgout_list);

722 }

723 destroy_route_list(route_list);

724 return ok;

725 }

726

727 gboolean

728 deliver_msg_list(GList * msg_list, guint flags)

729 {

730 GList *msgout_list = create_msg_out_list(msg_list);

731 GList *local_msgout_list = NULL;

732 GList *localnet_msgout_list = NULL;

733 GList *other_msgout_list = NULL;

734 GList *msgout_node;

735 GList *alias_table = NULL;

736 gboolean ok = TRUE;

737

738 if (conf.alias_file) {

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

740 }

741

742 /* sort messages for different deliveries */

743 foreach(msgout_list, msgout_node) {

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

745 GList *rcpt_list;

746 GList *local_rcpt_list = NULL;

747 GList *localnet_rcpt_list = NULL;

748 GList *other_rcpt_list = NULL;

749

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

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

752 continue;

753 }

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

755

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

757 if (conf.log_user) {

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

759 if (addr) {

760 rcpt_list = g_list_prepend(rcpt_list, addr);

761 } else {

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

763 }

764 }

765 if (alias_table) {

766 GList *aliased_rcpt_list;

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

768 g_list_free(rcpt_list);

769 rcpt_list = aliased_rcpt_list;

770 }

771

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

773 g_list_free(rcpt_list);

774

775 /* local recipients */

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

777 msg_out *local_msgout = clone_msg_out(msgout);

778 local_msgout->rcpt_list = local_rcpt_list;

779 local_msgout_list = g_list_append(local_msgout_list, local_msgout);

780 }

781

782 /* local net recipients */

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

784 msg_out *localnet_msgout = clone_msg_out(msgout);

785 localnet_msgout->rcpt_list = localnet_rcpt_list;

786 localnet_msgout_list = g_list_append(localnet_msgout_list, localnet_msgout);

787 }

788

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

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

791 msg_out *other_msgout = clone_msg_out(msgout);

792 other_msgout->rcpt_list = other_rcpt_list;

793 other_msgout_list = g_list_append(other_msgout_list, other_msgout);

794 }

795 }

796

797 if (alias_table) {

798 destroy_table(alias_table);

799 }

800

801 /* actual delivery */

802

803 if (local_msgout_list) {

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

805 foreach(local_msgout_list, msgout_node) {

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

807 if (!deliver_local(msgout)) {

808 ok = FALSE;

809 }

810 }

811 destroy_msg_out_list(local_msgout_list);

812 }

813

814 if (localnet_msgout_list) {

815 GList *route_list = NULL;

816 GList *route_node;

817

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

819 if (conf.local_net_routes) {

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

821 } else {

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

823 }

824

825 foreach(route_list, route_node) {

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

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

828 ok = FALSE;

829 }

830 }

831 destroy_msg_out_list(localnet_msgout_list);

832 destroy_route_list(route_list);

833 }

834

835 if (other_msgout_list) {

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

837 if (!deliver_msgout_list_online(other_msgout_list)) {

838 ok = FALSE;

839 }

840 destroy_msg_out_list(other_msgout_list);

841 }

842

843 foreach(msgout_list, msgout_node) {

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

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

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

847 } else {

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

849 }

850

851 }

852

853 destroy_msg_out_list(msgout_list);

854

855 return ok;

856 }

857

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

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

860 which are reachable only when online are treated specially

861 in another function.

862

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

864 be delivered immediately.

865 */

866 gboolean

867 deliver(message * msg)

868 {

869 gboolean ok;

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

871

872 ok = deliver_msg_list(msg_list, DLVR_ALL);

873 g_list_free(msg_list);

874

875 return ok;

876 }