masqmail: 7a8d706f0ff1 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 int

671 deliver_remote(GList* remote_msgout_list)

672 {

673 int ok = TRUE;

674 GList *route_list = NULL;

675 GList *route_node;

676 GList *rf_list = NULL;

677 gchar *connect_name = NULL;

678

679 if (!remote_msgout_list) {

680 return FALSE;

681 }

682

683 /* perma routes */

684 if (conf.perma_routes) {

685 DEBUG(5) debugf("processing perma_routes\n");

686

687 route_list = read_route_list(conf.perma_routes, TRUE);

688 foreach(route_list, route_node) {

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

690 if (!deliver_route_msg_list(route, remote_msgout_list)) {

691 ok = FALSE;

692 }

693 }

694 destroy_route_list(route_list);

695 }

696

697 /* query routes */

698 connect_name = online_query();

699 if (!connect_name) {

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

701 return FALSE;

702 }

703

704 /* we are online! */

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

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

707

708 rf_list = (GList *) table_find(conf.query_routes, connect_name);

709 if (!rf_list) {

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

711 return FALSE;

712 }

713

714 route_list = read_route_list(rf_list, FALSE);

715 if (!route_list) {

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

717 return FALSE;

718 }

719

720 foreach(route_list, route_node) {

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

722 /* TODO: ok gets overwritten */

723 ok = deliver_route_msg_list(route, remote_msgout_list);

724 }

725 destroy_route_list(route_list);

726

727 return ok;

728 }

729

730 /*

731 This function splits the list of rcpt addresses

732 into local and remote addresses and processes them accordingly.

733 */

734 gboolean

735 deliver_msg_list(GList * msg_list, guint flags)

736 {

737 GList *msgout_list = NULL;

738 GList *msg_node;

739 GList *local_msgout_list = NULL;

740 GList *remote_msgout_list = NULL;

741 GList *msgout_node;

742 GList *alias_table = NULL;

743 gboolean ok = TRUE;

744

745 /* create msgout_list */

746 foreach(msg_list, msg_node) {

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

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

749 }

750

751 if (conf.alias_file) {

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

753 }

754

755 /* sort messages for different deliveries */

756 foreach(msgout_list, msgout_node) {

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

758 GList *rcpt_list;

759 GList *local_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, NULL, &local_rcpt_list, * NULL, &other_rcpt_list); */

785 local_rcpt_list = local_rcpts(rcpt_list);

786 other_rcpt_list = remote_rcpts(rcpt_list);

787 g_list_free(rcpt_list);

788

789 /* local recipients */

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

791 msg_out *local_msgout = clone_msg_out(msgout);

792 local_msgout->rcpt_list = local_rcpt_list;

793 local_msgout_list = g_list_append(local_msgout_list, local_msgout);

794 }

795

796 /* remote recipients, requires online delivery */

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

798 msg_out *remote_msgout = clone_msg_out(msgout);

799 remote_msgout->rcpt_list = other_rcpt_list;

800 remote_msgout_list = g_list_append(remote_msgout_list, remote_msgout);

801 }

802 }

803

804 if (alias_table) {

805 destroy_table(alias_table);

806 }

807

808 /* process local/remote msgout lists -> delivery */

809

810 if (local_msgout_list) {

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

812 foreach(local_msgout_list, msgout_node) {

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

814 if (!deliver_local(msgout)) {

815 ok = FALSE;

816 }

817 }

818 destroy_msg_out_list(local_msgout_list);

819 }

820

821 if (remote_msgout_list) {

822 DEBUG(5) debugf("remote_msgout_list\n");

823 deliver_remote(remote_msgout_list);

824 destroy_msg_out_list(remote_msgout_list);

825 }

826

827 /* unlock spool files */

828 foreach(msgout_list, msgout_node) {

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

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

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

832 } else {

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

834 }

835 }

836 destroy_msg_out_list(msgout_list);

837

838 return ok;

839 }

840

841 /*

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

843 (mode_accept and smtp_in) and should be delivered immediately

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

845 deliver then.

846 */

847 gboolean

848 deliver(message * msg)

849 {

850 gboolean ok;

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

852

853 ok = deliver_msg_list(msg_list, DLVR_ALL);

854 g_list_free(msg_list);

855

856 return ok;

857 }