masqmail: e74ee75453db src/deliver.c

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

381 }

382 if (ret) {

383 deliver_finish(msgout);

384 }

385 }

386 }

387 return ok;

388 }

389

390

391 if (route->wrapper) {

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

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

394 psb->remote_host = host;

395 }

396

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

398

399 #ifdef ENABLE_AUTH

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

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

402 }

403 #endif

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

405 /* smtp_out_init() failed */

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

407 smtp_out_quit(psb);

408

409 foreach(msgout_list, msgout_node) {

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

411 smtp_out_mark_rcpts(psb, msgout->rcpt_list);

412

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

414 deliver_finish(msgout);

415 }

416 }

417 }

418 destroy_smtpbase(psb);

419 return ok;

420 }

421

422 if (!route->do_pipelining) {

423 psb->use_pipelining = FALSE;

424 }

425

426 foreach(msgout_list, msgout_node) {

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

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

429 message *msg = msgout->msg;

430

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

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

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

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

435 break;

436 }

437

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

439

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

441

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

443 /* connection lost */

444 break;

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

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

447 break;

448 }

449 }

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

451

452 if (flag) {

453 msg_free_data(msg);

454 }

455 if (ok_msg) {

456 ok = TRUE;

457 }

458 if (ok_msg || ok_fail) {

459 deliver_finish(msgout);

460 }

461 }

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

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

464 smtp_out_quit(psb);

465 }

466 destroy_smtpbase(psb);

467 return ok;

468 }

469

470 gboolean

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

472 {

473

474 if (route->pipe) {

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

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

477 } else {

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

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

480 }

481 }

482

483 /*

484 delivers messages in msgout_list using route

485 */

486 gboolean

487 deliver_route_msgout_list(connect_route * route, GList * msgout_list)

488 {

489 gboolean ok = FALSE;

490 GList *mo_ph_list;

491 GList *mo_ph_node;

492

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

494

495 if (route->mail_host) {

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

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

498 }

499

500 /* this is not easy... */

501

502 mo_ph_list = route_msgout_list(route, msgout_list);

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

504 if (!mo_ph_list) {

505 return FALSE;

506 }

507

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

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

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

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

512 */

513 foreach(mo_ph_list, mo_ph_node) {

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

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

516 ok = TRUE;

517 }

518 destroy_msgout_perhost(mo_ph);

519 }

520 g_list_free(mo_ph_list);

521 return ok;

522 }

523

524 /*

525 calls route_prepare_msg()

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

527 */

528 gboolean

529 deliver_route_msg_list(connect_route * route, GList * msgout_list)

530 {

531 GList *msgout_list_deliver = NULL;

532 GList *msgout_node;

533 gboolean ok = TRUE;

534

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

536

537 foreach(msgout_list, msgout_node) {

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

539 msg_out *msgout_cloned = clone_msg_out(msgout);

540 GList *rcpt_list_non_delivered = NULL;

541 GList *rcpt_node;

542

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

544 previous route may have delivered to it */

545 foreach(msgout_cloned->rcpt_list, rcpt_node) {

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

547 /* failed addresses already have been bounced;

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

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

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

551 rcpt_list_non_delivered = g_list_append(rcpt_list_non_delivered, rcpt);

552 }

553 }

554 g_list_free(msgout_cloned->rcpt_list);

555 msgout_cloned->rcpt_list = rcpt_list_non_delivered;

556

557 if (!msgout_cloned->rcpt_list) {

558 destroy_msg_out(msgout_cloned);

559 continue;

560 }

561

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

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

564 destroy_msg_out(msgout_cloned);

565 continue;

566 }

567

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

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

570

571 if (!rcpt_list_allowed) {

572 destroy_msg_out(msgout_cloned);

573 continue;

574 }

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

576

577 g_list_free(msgout_cloned->rcpt_list);

578 msgout_cloned->rcpt_list = rcpt_list_allowed;

579

580 if (route->last_route) {

581 GList *rcpt_node;

582 foreach(msgout_cloned->rcpt_list, rcpt_node) {

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

584 rcpt->flags |= ADDR_FLAG_LAST_ROUTE;

585 }

586 }

587

588 route_prepare_msgout(route, msgout_cloned);

589 msgout_list_deliver = g_list_append(msgout_list_deliver, msgout_cloned);

590 }

591

592 if (msgout_list_deliver) {

593 if (deliver_route_msgout_list(route, msgout_list_deliver)) {

594 ok = TRUE;

595 }

596 destroy_msg_out_list(msgout_list_deliver);

597 }

598 return ok;

599 }

600

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

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

603 */

604 void

605 update_non_rcpt_list(msg_out * msgout)

606 {

607 GList *rcpt_node;

608 message *msg = msgout->msg;

609

610 foreach(msgout->rcpt_list, rcpt_node) {

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

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

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

614 }

615 }

616 }

617

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

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

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

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

622

623 returns TRUE if all went well.

624 */

625 gboolean

626 deliver_finish(msg_out * msgout)

627 {

628 GList *rcpt_node;

629 message *msg = msgout->msg;

630 gboolean finished = TRUE;

631

632 update_non_rcpt_list(msgout);

633

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

635 were always set on the original address structs */

636 foreach(msg->rcpt_list, rcpt_node) {

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

638 if (!addr_is_finished_children(rcpt)) {

639 finished = FALSE;

640 } else {

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

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

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

644 as well.

645 */

646 if (addr_is_delivered_children(rcpt)) {

647 addr_mark_delivered(rcpt);

648 } else {

649 addr_mark_failed(rcpt);

650 }

651 }

652 }

653

654 if (finished) {

655 if (spool_delete_all(msg)) {

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

657 return TRUE;

658 }

659 return FALSE;

660 }

661

662 /* one not delivered address was found */

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

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

665 return FALSE;

666 }

667

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

669 return TRUE;

670 }

671

672 gboolean

673 deliver_finish_list(GList * msgout_list)

674 {

675 gboolean ok = TRUE;

676 GList *msgout_node;

677 foreach(msgout_list, msgout_node) {

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

679 if (!deliver_finish(msgout)) {

680 ok = FALSE;

681 }

682 }

683 return ok;

684 }

685

686 gboolean

687 deliver_msgout_list_online(GList * msgout_list)

688 {

689 GList *rf_list = NULL;

690 gchar *connect_name = NULL;

691 gboolean ok = FALSE;

692

693 connect_name = online_query();

694 if (!connect_name) {

695 return FALSE;

696 }

697

698 /* we are online! */

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

700

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

702 if (!rf_list) {

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

704 return FALSE;

705 }

706

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

708 if (!route_list) {

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

710 return FALSE;

711 }

712

713 GList *route_node;

714 foreach(route_list, route_node) {

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

716 /* TODO: ok gets overwritten */

717 ok = deliver_route_msg_list(route, msgout_list);

718 }

719 destroy_route_list(route_list);

720 return ok;

721 }

722

723 gboolean

724 deliver_msg_list(GList * msg_list, guint flags)

725 {

726 GList *msgout_list = create_msg_out_list(msg_list);

727 GList *local_msgout_list = NULL;

728 GList *localnet_msgout_list = NULL;

729 GList *other_msgout_list = NULL;

730 GList *msgout_node;

731 GList *alias_table = NULL;

732 gboolean ok = TRUE;

733

734 if (conf.alias_file) {

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

736 }

737

738 /* sort messages for different deliveries */

739 foreach(msgout_list, msgout_node) {

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

741 GList *rcpt_list;

742 GList *local_rcpt_list = NULL;

743 GList *localnet_rcpt_list = NULL;

744 GList *other_rcpt_list = NULL;

745

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

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

748 continue;

749 }

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

751

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

753 if (conf.log_user) {

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

755 if (addr) {

756 rcpt_list = g_list_prepend(rcpt_list, addr);

757 } else {

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

759 }

760 }

761 if (alias_table) {

762 GList *aliased_rcpt_list;

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

764 g_list_free(rcpt_list);

765 rcpt_list = aliased_rcpt_list;

766 }

767

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

769 g_list_free(rcpt_list);

770

771 /* local recipients */

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

773 msg_out *local_msgout = clone_msg_out(msgout);

774 local_msgout->rcpt_list = local_rcpt_list;

775 local_msgout_list = g_list_append(local_msgout_list, local_msgout);

776 }

777

778 /* local net recipients */

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

780 msg_out *localnet_msgout = clone_msg_out(msgout);

781 localnet_msgout->rcpt_list = localnet_rcpt_list;

782 localnet_msgout_list = g_list_append(localnet_msgout_list, localnet_msgout);

783 }

784

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

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

787 msg_out *other_msgout = clone_msg_out(msgout);

788 other_msgout->rcpt_list = other_rcpt_list;

789 other_msgout_list = g_list_append(other_msgout_list, other_msgout);

790 }

791 }

792

793 if (alias_table) {

794 destroy_table(alias_table);

795 }

796

797 /* actual delivery */

798

799 if (local_msgout_list) {

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

801 foreach(local_msgout_list, msgout_node) {

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

803 if (!deliver_local(msgout)) {

804 ok = FALSE;

805 }

806 }

807 destroy_msg_out_list(local_msgout_list);

808 }

809

810 if (localnet_msgout_list) {

811 GList *route_list = NULL;

812 GList *route_node;

813

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

815 if (conf.local_net_routes) {

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

817 } else {

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

819 }

820

821 foreach(route_list, route_node) {

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

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

824 ok = FALSE;

825 }

826 }

827 destroy_msg_out_list(localnet_msgout_list);

828 destroy_route_list(route_list);

829 }

830

831 if (other_msgout_list) {

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

833 if (!deliver_msgout_list_online(other_msgout_list)) {

834 ok = FALSE;

835 }

836 destroy_msg_out_list(other_msgout_list);

837 }

838

839 foreach(msgout_list, msgout_node) {

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

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

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

843 } else {

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

845 }

846

847 }

848

849 destroy_msg_out_list(msgout_list);

850

851 return ok;

852 }

853

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

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

856 which are reachable only when online are treated specially

857 in another function.

858

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

860 be delivered immediately.

861 */

862 gboolean

863 deliver(message * msg)

864 {

865 gboolean ok;

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

867

868 ok = deliver_msg_list(msg_list, DLVR_ALL);

869 g_list_free(msg_list);

870

871 return ok;

872 }