masqmail: 4905a1d9e6a7 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_msgout_list_online(GList * msgout_list)

672 {

673 GList *rf_list = NULL;

674 gchar *connect_name = NULL;

675 gboolean ok = FALSE;

676 GList *route_node;

677 GList *route_list;

678

679 connect_name = online_query();

680 if (!connect_name) {

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

682 return FALSE;

683 }

684

685 /* we are online! */

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

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

688

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

690 if (!rf_list) {

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

692 return FALSE;

693 }

694

695 route_list = read_route_list(rf_list, FALSE);

696 if (!route_list) {

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

698 return FALSE;

699 }

700

701 foreach(route_list, route_node) {

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

703 /* TODO: ok gets overwritten */

704 ok = deliver_route_msg_list(route, msgout_list);

705 }

706 destroy_route_list(route_list);

707

708 return ok;

709 }

710

711 /*

712 This function searches in the list of rcpt addresses

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

714 which are reachable only when online are treated specially

715 in another function.

716 */

717 gboolean

718 deliver_msg_list(GList * msg_list, guint flags)

719 {

720 GList *msgout_list = NULL;

721 GList *msg_node;

722 GList *local_msgout_list = NULL;

723 GList *localnet_msgout_list = NULL;

724 GList *other_msgout_list = NULL;

725 GList *msgout_node;

726 GList *alias_table = NULL;

727 gboolean ok = TRUE;

728

729 /* create msgout_list */

730 foreach(msg_list, msg_node) {

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

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

733 }

734

735

736 if (conf.alias_file) {

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

738 }

739

740 /* sort messages for different deliveries */

741 foreach(msgout_list, msgout_node) {

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

743 GList *rcpt_list;

744 GList *local_rcpt_list = NULL;

745 GList *localnet_rcpt_list = NULL;

746 GList *other_rcpt_list = NULL;

747

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

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

750 continue;

751 }

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

753

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

755 if (conf.log_user) {

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

757 if (addr) {

758 rcpt_list = g_list_prepend(rcpt_list, addr);

759 } else {

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

761 }

762 }

763 if (alias_table) {

764 GList *aliased_rcpt_list;

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

766 g_list_free(rcpt_list);

767 rcpt_list = aliased_rcpt_list;

768 }

769

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

771 g_list_free(rcpt_list);

772

773 /* local recipients */

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

775 msg_out *local_msgout = clone_msg_out(msgout);

776 local_msgout->rcpt_list = local_rcpt_list;

777 local_msgout_list = g_list_append(local_msgout_list, local_msgout);

778 }

779

780 /* local net recipients */

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

782 msg_out *localnet_msgout = clone_msg_out(msgout);

783 localnet_msgout->rcpt_list = localnet_rcpt_list;

784 localnet_msgout_list = g_list_append(localnet_msgout_list, localnet_msgout);

785 }

786

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

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

789 msg_out *other_msgout = clone_msg_out(msgout);

790 other_msgout->rcpt_list = other_rcpt_list;

791 other_msgout_list = g_list_append(other_msgout_list, other_msgout);

792 }

793 }

794

795 if (alias_table) {

796 destroy_table(alias_table);

797 }

798

799 /* actual delivery */

800

801 if (local_msgout_list) {

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

803 foreach(local_msgout_list, msgout_node) {

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

805 if (!deliver_local(msgout)) {

806 ok = FALSE;

807 }

808 }

809 destroy_msg_out_list(local_msgout_list);

810 }

811

812 if (localnet_msgout_list) {

813 GList *route_list = NULL;

814 GList *route_node;

815

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

817 if (conf.local_net_routes) {

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

819 } else {

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

821 }

822

823 foreach(route_list, route_node) {

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

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

826 ok = FALSE;

827 }

828 }

829 destroy_msg_out_list(localnet_msgout_list);

830 destroy_route_list(route_list);

831 }

832

833 if (other_msgout_list) {

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

835 if (!deliver_msgout_list_online(other_msgout_list)) {

836 ok = FALSE;

837 }

838 destroy_msg_out_list(other_msgout_list);

839 }

840

841 /* unlock spool files */

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 destroy_msg_out_list(msgout_list);

851

852 return ok;

853 }

854

855 /*

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

857 (mode_accept and smtp_in) and should be delivered immediately

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

859 deliver then.

860 */

861 gboolean

862 deliver(message * msg)

863 {

864 gboolean ok;

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

866

867 ok = deliver_msg_list(msg_list, DLVR_ALL);

868 g_list_free(msg_list);

869

870 return ok;

871 }