masqmail: 01d2f7a17bf0 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 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 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 /* TODO: Should we stop if the mail was delivered? Dig deeper! */

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 /*

724 This function searches in the list of rcpt addresses

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

726 which are reachable only when online are treated specially

727 in another function.

728 */

729 gboolean

730 deliver_msg_list(GList * msg_list, guint flags)

731 {

732 GList *msgout_list = create_msg_out_list(msg_list);

733 GList *local_msgout_list = NULL;

734 GList *localnet_msgout_list = NULL;

735 GList *other_msgout_list = NULL;

736 GList *msgout_node;

737 GList *alias_table = NULL;

738 gboolean ok = TRUE;

739

740 if (conf.alias_file) {

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

742 }

743

744 /* sort messages for different deliveries */

745 foreach(msgout_list, msgout_node) {

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

747 GList *rcpt_list;

748 GList *local_rcpt_list = NULL;

749 GList *localnet_rcpt_list = NULL;

750 GList *other_rcpt_list = NULL;

751

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

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

754 continue;

755 }

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

757

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

759 if (conf.log_user) {

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

761 if (addr) {

762 rcpt_list = g_list_prepend(rcpt_list, addr);

763 } else {

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

765 }

766 }

767 if (alias_table) {

768 GList *aliased_rcpt_list;

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

770 g_list_free(rcpt_list);

771 rcpt_list = aliased_rcpt_list;

772 }

773

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

775 g_list_free(rcpt_list);

776

777 /* local recipients */

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

779 msg_out *local_msgout = clone_msg_out(msgout);

780 local_msgout->rcpt_list = local_rcpt_list;

781 local_msgout_list = g_list_append(local_msgout_list, local_msgout);

782 }

783

784 /* local net recipients */

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

786 msg_out *localnet_msgout = clone_msg_out(msgout);

787 localnet_msgout->rcpt_list = localnet_rcpt_list;

788 localnet_msgout_list = g_list_append(localnet_msgout_list, localnet_msgout);

789 }

790

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

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

793 msg_out *other_msgout = clone_msg_out(msgout);

794 other_msgout->rcpt_list = other_rcpt_list;

795 other_msgout_list = g_list_append(other_msgout_list, other_msgout);

796 }

797 }

798

799 if (alias_table) {

800 destroy_table(alias_table);

801 }

802

803 /* actual delivery */

804

805 if (local_msgout_list) {

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

807 foreach(local_msgout_list, msgout_node) {

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

809 if (!deliver_local(msgout)) {

810 ok = FALSE;

811 }

812 }

813 destroy_msg_out_list(local_msgout_list);

814 }

815

816 if (localnet_msgout_list) {

817 GList *route_list = NULL;

818 GList *route_node;

819

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

821 if (conf.local_net_routes) {

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

823 } else {

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

825 }

826

827 foreach(route_list, route_node) {

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

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

830 ok = FALSE;

831 }

832 }

833 destroy_msg_out_list(localnet_msgout_list);

834 destroy_route_list(route_list);

835 }

836

837 if (other_msgout_list) {

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

839 if (!deliver_msgout_list_online(other_msgout_list)) {

840 ok = FALSE;

841 }

842 destroy_msg_out_list(other_msgout_list);

843 }

844

845 foreach(msgout_list, msgout_node) {

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

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

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

849 } else {

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

851 }

852

853 }

854

855 destroy_msg_out_list(msgout_list);

856

857 return ok;

858 }

859

860 /*

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

862 be delivered immediately.

863 */

864 gboolean

865 deliver(message * msg)

866 {

867 gboolean ok;

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

869

870 ok = deliver_msg_list(msg_list, DLVR_ALL);

871 g_list_free(msg_list);

872

873 return ok;

874 }