masqmail: 0410c8aabac2 src/deliver.c

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

384 }

385 if (ret) {

386 deliver_finish(msgout);

387 }

388 }

389 }

390 return ok;

391 }

392

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

394

395 #ifdef ENABLE_AUTH

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

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

398 }

399 #endif

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

401 /* smtp_out_init() failed */

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

403 smtp_out_quit(psb);

404

405 foreach(msgout_list, msgout_node) {

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

407 smtp_out_mark_rcpts(psb, msgout->rcpt_list);

408

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

410 deliver_finish(msgout);

411 }

412 }

413 }

414 destroy_smtpbase(psb);

415 return ok;

416 }

417

418 if (!route->do_pipelining) {

419 psb->use_pipelining = FALSE;

420 }

421

422 foreach(msgout_list, msgout_node) {

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

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

425 message *msg = msgout->msg;

426

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

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

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

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

431 break;

432 }

433

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

435

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

437

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

439 /* connection lost */

440 break;

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

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

443 break;

444 }

445 }

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

447

448 if (flag) {

449 msg_free_data(msg);

450 }

451 if (ok_msg) {

452 ok = TRUE;

453 }

454 if (ok_msg || ok_fail) {

455 deliver_finish(msgout);

456 }

457 }

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

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

460 smtp_out_quit(psb);

461 }

462 destroy_smtpbase(psb);

463 return ok;

464 }

465

466 gboolean

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

468 {

469

470 if (route->pipe) {

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

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

473 } else {

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

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

476 }

477 }

478

479 /*

480 delivers messages in msgout_list using route

481 */

482 gboolean

483 deliver_route_msgout_list(connect_route * route, GList * msgout_list)

484 {

485 gboolean ok = FALSE;

486 GList *mo_ph_list;

487 GList *mo_ph_node;

488

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

490

491 if (route->mail_host) {

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

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

494 }

495

496 /* this is not easy... */

497

498 mo_ph_list = route_msgout_list(route, msgout_list);

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

500 if (!mo_ph_list) {

501 return FALSE;

502 }

503

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

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

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

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

508 */

509 foreach(mo_ph_list, mo_ph_node) {

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

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

512 ok = TRUE;

513 }

514 destroy_msgout_perhost(mo_ph);

515 }

516 g_list_free(mo_ph_list);

517 return ok;

518 }

519

520 /*

521 calls route_prepare_msg()

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

523 */

524 gboolean

525 deliver_route_msg_list(connect_route * route, GList * msgout_list)

526 {

527 GList *msgout_list_deliver = NULL;

528 GList *msgout_node;

529 gboolean ok = TRUE;

530

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

532

533 foreach(msgout_list, msgout_node) {

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

535 msg_out *msgout_cloned = clone_msg_out(msgout);

536 GList *rcpt_list_non_delivered = NULL;

537 GList *rcpt_node;

538

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

540 previous route may have delivered to it */

541 foreach(msgout_cloned->rcpt_list, rcpt_node) {

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

543 /* failed addresses already have been bounced;

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

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

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

547 rcpt_list_non_delivered = g_list_append(rcpt_list_non_delivered, rcpt);

548 }

549 }

550 g_list_free(msgout_cloned->rcpt_list);

551 msgout_cloned->rcpt_list = rcpt_list_non_delivered;

552

553 if (!msgout_cloned->rcpt_list) {

554 destroy_msg_out(msgout_cloned);

555 continue;

556 }

557

558 /* filter by allowed envelope sender */

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

560 destroy_msg_out(msgout_cloned);

561 continue;

562 }

563

564 /* filter by allowed envelope rcpts */

565 GList* rcpt_list_allowed = NULL;

566 GList* rcpt_list_notallowed = NULL;

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

568 if (!rcpt_list_allowed) {

569 destroy_msg_out(msgout_cloned);

570 continue;

571 }

572

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

574

575 g_list_free(msgout_cloned->rcpt_list);

576 msgout_cloned->rcpt_list = rcpt_list_allowed;

577

578 if (route->last_route) {

579 GList *rcpt_node;

580 foreach(msgout_cloned->rcpt_list, rcpt_node) {

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

582 rcpt->flags |= ADDR_FLAG_LAST_ROUTE;

583 }

584 }

585

586 route_prepare_msgout(route, msgout_cloned);

587 msgout_list_deliver = g_list_append(msgout_list_deliver, msgout_cloned);

588 }

589

590 if (msgout_list_deliver) {

591 if (deliver_route_msgout_list(route, msgout_list_deliver)) {

592 ok = TRUE;

593 }

594 destroy_msg_out_list(msgout_list_deliver);

595 }

596 return ok;

597 }

598

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

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

601 */

602 void

603 update_non_rcpt_list(msg_out * msgout)

604 {

605 GList *rcpt_node;

606 message *msg = msgout->msg;

607

608 foreach(msgout->rcpt_list, rcpt_node) {

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

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

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

612 }

613 }

614 }

615

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

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

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

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

620

621 returns TRUE if all went well.

622 */

623 gboolean

624 deliver_finish(msg_out * msgout)

625 {

626 GList *rcpt_node;

627 message *msg = msgout->msg;

628 gboolean finished = TRUE;

629

630 update_non_rcpt_list(msgout);

631

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

633 were always set on the original address structs */

634 foreach(msg->rcpt_list, rcpt_node) {

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

636 if (!addr_is_finished_children(rcpt)) {

637 finished = FALSE;

638 } else {

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

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

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

642 as well.

643 */

644 if (addr_is_delivered_children(rcpt)) {

645 addr_mark_delivered(rcpt);

646 } else {

647 addr_mark_failed(rcpt);

648 }

649 }

650 }

651

652 if (finished) {

653 if (spool_delete_all(msg)) {

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

655 return TRUE;

656 }

657 return FALSE;

658 }

659

660 /* one not delivered address was found */

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

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

663 return FALSE;

664 }

665

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

667 return TRUE;

668 }

669

670 gboolean

671 deliver_finish_list(GList * msgout_list)

672 {

673 gboolean ok = TRUE;

674 GList *msgout_node;

675 foreach(msgout_list, msgout_node) {

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

677 if (!deliver_finish(msgout)) {

678 ok = FALSE;

679 }

680 }

681 return ok;

682 }

683

684 gboolean

685 deliver_msgout_list_online(GList * msgout_list)

686 {

687 GList *rf_list = NULL;

688 gchar *connect_name = NULL;

689 gboolean ok = FALSE;

690 GList *route_node;

691 GList *route_list;

692

693 connect_name = online_query();

694 if (!connect_name) {

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

696 return FALSE;

697 }

698

699 /* we are online! */

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

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

702

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

704 if (!rf_list) {

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

706 return FALSE;

707 }

708

709 route_list = read_route_list(rf_list, FALSE);

710 if (!route_list) {

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

712 return FALSE;

713 }

714

715 foreach(route_list, route_node) {

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

717 /* TODO: ok gets overwritten */

718 ok = deliver_route_msg_list(route, msgout_list);

719 }

720 destroy_route_list(route_list);

721

722 return ok;

723 }

724

725 /*

726 This function searches in the list of rcpt addresses

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

728 which are reachable only when online are treated specially

729 in another function.

730 */

731 gboolean

732 deliver_msg_list(GList * msg_list, guint flags)

733 {

734 GList *msgout_list = NULL;

735 GList *msg_node;

736 GList *local_msgout_list = NULL;

737 GList *localnet_msgout_list = NULL;

738 GList *other_msgout_list = NULL;

739 GList *msgout_node;

740 GList *alias_table = NULL;

741 gboolean ok = TRUE;

742

743 /* create msgout_list */

744 foreach(msg_list, msg_node) {

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

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

747 }

748

749

750 if (conf.alias_file) {

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

752 }

753

754 /* sort messages for different deliveries */

755 foreach(msgout_list, msgout_node) {

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

757 GList *rcpt_list;

758 GList *local_rcpt_list = NULL;

759 GList *localnet_rcpt_list = NULL;

760 GList *other_rcpt_list = NULL;

761

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

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

764 continue;

765 }

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

767

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

769 if (conf.log_user) {

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

771 if (addr) {

772 rcpt_list = g_list_prepend(rcpt_list, addr);

773 } else {

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

775 }

776 }

777 if (alias_table) {

778 GList *aliased_rcpt_list;

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

780 g_list_free(rcpt_list);

781 rcpt_list = aliased_rcpt_list;

782 }

783

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

785 g_list_free(rcpt_list);

786

787 /* local recipients */

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

789 msg_out *local_msgout = clone_msg_out(msgout);

790 local_msgout->rcpt_list = local_rcpt_list;

791 local_msgout_list = g_list_append(local_msgout_list, local_msgout);

792 }

793

794 /* local net recipients */

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

796 msg_out *localnet_msgout = clone_msg_out(msgout);

797 localnet_msgout->rcpt_list = localnet_rcpt_list;

798 localnet_msgout_list = g_list_append(localnet_msgout_list, localnet_msgout);

799 }

800

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

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

803 msg_out *other_msgout = clone_msg_out(msgout);

804 other_msgout->rcpt_list = other_rcpt_list;

805 other_msgout_list = g_list_append(other_msgout_list, other_msgout);

806 }

807 }

808

809 if (alias_table) {

810 destroy_table(alias_table);

811 }

812

813 /* actual delivery */

814

815 if (local_msgout_list) {

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

817 foreach(local_msgout_list, msgout_node) {

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

819 if (!deliver_local(msgout)) {

820 ok = FALSE;

821 }

822 }

823 destroy_msg_out_list(local_msgout_list);

824 }

825

826 if (localnet_msgout_list) {

827 GList *route_list = NULL;

828 GList *route_node;

829

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

831 if (conf.local_net_routes) {

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

833 } else {

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

835 }

836

837 foreach(route_list, route_node) {

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

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

840 ok = FALSE;

841 }

842 }

843 destroy_msg_out_list(localnet_msgout_list);

844 destroy_route_list(route_list);

845 }

846

847 if (other_msgout_list) {

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

849 if (!deliver_msgout_list_online(other_msgout_list)) {

850 ok = FALSE;

851 }

852 destroy_msg_out_list(other_msgout_list);

853 }

854

855 /* unlock spool files */

856 foreach(msgout_list, msgout_node) {

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

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

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

860 } else {

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

862 }

863 }

864 destroy_msg_out_list(msgout_list);

865

866 return ok;

867 }

868

869 /*

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

871 (mode_accept and smtp_in) and should be delivered immediately

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

873 deliver then.

874 */

875 gboolean

876 deliver(message * msg)

877 {

878 gboolean ok;

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

880

881 ok = deliver_msg_list(msg_list, DLVR_ALL);

882 g_list_free(msg_list);

883

884 return ok;

885 }