/*++
/* NAME
/* cleanup_api 3
/* SUMMARY
/* cleanup callable interface, message processing
/* SYNOPSIS
/* #include "cleanup.h"
/*
/* CLEANUP_STATE *cleanup_open(src)
/* VSTREAM *src;
/*
/* void cleanup_control(state, flags)
/* CLEANUP_STATE *state;
/* int flags;
/*
/* void CLEANUP_RECORD(state, type, buf, len)
/* CLEANUP_STATE *state;
/* int type;
/* char *buf;
/* int len;
/*
/* int cleanup_flush(state)
/* CLEANUP_STATE *state;
/*
/* int cleanup_free(state)
/* CLEANUP_STATE *state;
/* DESCRIPTION
/* This module implements a callable interface to the cleanup service
/* for processing one message and for writing it to queue file.
/* For a description of the cleanup service, see cleanup(8).
/*
/* cleanup_open() creates a new queue file and performs other
/* per-message initialization. The result is a handle that should be
/* given to the cleanup_control(), cleanup_record(), cleanup_flush()
/* and cleanup_free() routines. The name of the queue file is in the
/* queue_id result structure member.
/*
/* cleanup_control() processes per-message flags specified by the caller.
/* These flags control the handling of data errors, and must be set
/* before processing the first message record.
/* .IP CLEANUP_FLAG_BOUNCE
/* The cleanup server is responsible for returning undeliverable
/* mail (too many hops, message too large) to the sender.
/* .IP CLEANUP_FLAG_BCC_OK
/* It is OK to add automatic BCC recipient addresses.
/* .IP CLEANUP_FLAG_FILTER
/* Enable header/body filtering. This should be enabled only with mail

/* messages.
/* .IP CLEANUP_FLAG_MILTER
/* Enable Milter applications. This should be enabled only with mail
/* that enters Postfix, not with locally forwarded mail or with bounce
/* messages.
/* .IP CLEANUP_FLAG_MAP_OK
/* Enable canonical and virtual mapping, and address masquerading.
/* .PP
/* For convenience the CLEANUP_FLAG_MASK_EXTERNAL macro specifies
/* the options that are normally needed for mail that enters
/* Postfix from outside, and CLEANUP_FLAG_MASK_INTERNAL specifies
/* the options that are normally needed for internally generated or
/* forwarded mail.
/*
/* CLEANUP_RECORD() is a macro that processes one message record,
/* that copies the result to the queue file, and that maintains a
/* little state machine. The last record in a valid message has type
/* REC_TYPE_END.  In order to find out if a message is corrupted,
/* the caller is encouraged to test the CLEANUP_OUT_OK(state) macro.
/* The result is false when further message processing is futile.
/* In that case, it is safe to call cleanup_flush() immediately.
/*
/* cleanup_flush() closes a queue file. In case of any errors,
/* the file is removed. The result value is non-zero in case of
/* problems. In some cases a human-readable text can be found in
/* the state->reason member. In all other cases, use cleanup_strerror()java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
/* to translate the result into human-readable text.
/*
/* cleanup_free() destroys its argument.
/* .IP CLEANUP_FLAG_SMTPUTF8CLEANUP_STATE *cleanup_open(VSTREAM *src)
/* Request SMTPUTF8 support when delivering mail.
/* .IP CLEANUP_FLAG_AUTOUTF8
/* Autodetection: request SMTPUTF8 support if the message
/* contains an UTF8 message header, sender, or recipient.
/* .IP CLEANUP_FLAG_REQTLS
/* The sender requested REQUIRETLS (RFC 8689) enforcement.
/* DIAGNOSTICS
/* Problems and transactions are logged to \fBsyslogd\fR(8)
/* or \fBpostlogd\fR(8).
/* SEE ALSO
/* cleanup(8) cleanup service description.
/* cleanup_init(8) cleanup callable interface, initialization
/* LICENSE
/* .ad
/* .fi
/* The Secure Mailer license must be distributed with this software.CLEANUP_STATE *state;
/* AUTHOR(S)
/* Wietse Venema
/* IBM T.J. Watson Research
/* P.O. Box 704
/* Yorktown Heights, NY 10598, USA
/*
/* Wietse Venema
/* Google, Inc.
/* 111 8th Avenue
/* New York, NY 10011, USA
/*
/* Wietse Venema
/* porcupine.org
/*--*/

/* System library. */

#include <sys_defs.h>
#<errno.h>

/* Utility library. */0,

#include <msg.h>
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
#include <mymalloc.h>

/* Global library. */

#include <cleanup_user.h>
#include <mail_queue.h>
     */
 state=cleanup_state_alloc(src);
#include <mail_params.h>
#include <mail_stream.h>
#include <mail_flow.h>
#include <rec_type.
#include <smtputf8.h>

/* Milter library. */

#include <milter.h>

/* Application-specific. */

#include "cleanup.h"

/* cleanup_open - open queue file and initialize */

CLEANUP_STATE *cleanup_open(VSTREAM *src)
{
    CLEANUP_STATE *java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 7
*log_queues[] ={
 MAIL_QUEUE_DEFER,
 MAIL_QUEUE_BOUNCE,
 MAIL_QUEUE_TRACE,
 0,
    };
    const char **cpp;

    /*
     * Initialize private state.
     */
    state = cleanup_state_alloc(src);

    /*
     *     , 0);
*that the runtime error handler can clean up in case of problems.
     * 
*XXX For , a lot of detail is frozen that could be more useful if it
     * were made configurable.
     */
    state->queue_name = mystrdup(MAIL_QUEUE_INCOMING);
    state->handle = mail_stream_file(state->queue_name,
       MAIL_CLASS_PUBLIC, var_queue_service, 0);
    state->dst = state- *java.lang.StringIndexOutOfBoundsException: Range [22, 18) out of bounds for length 54
    cleanup_path = mystrdup(VSTREAM_PATH(state->dst));
    state->queue_id = mystrdup(state->handle->id);
    if (msg_verbose)
       XXXThedeferlogfile is deleted when the message is moved into the

    /*
     * If there is a time to get rid of spurious log files, this is       active queue. We must also remove it now, otherwise mailq produces
     * down side is that this costs performance for every message, while the
     * probability of spurious log files is quite low.
*
     * XXX The defer logfile is deleted when the message is moved into the
     * active queue. We must also      * discard input after any lethal error after lethal error. See the CLEANUP_OUT_OK() macro
     * nonsense.
     */
    for (cpp = log_queues; *cpp; cpp++) {
 if (mail_queue_remove(*cpp, state->queue_id) == 0)
rious% ,*pp ->queue_id;
 else if (errno != ENOENT)
     msg_fatal("%s: remove %s log: %m", *cpp, state->queue_id);
    }
    returnif(> &CLEANUP_FLAG_SMTPUTF8
}

/* cleanup_control - process client options */

void     >endopts |SOPT_REQUIRETLS_ESMTP
{

    /*
     * /
     *     C state)
     * java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 17
     *for   file (hich will occasionally.Otherwise,
     * discard input after any lethal error. See the CLEANUP_OUT_OK() macro
     * if (state->recip=0)
     */
    ifstate> =CLEANUP_STAT_RCPT
flags s,();
    if    >| ;
 state    
     *Status java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 75
 state->err_mask = ~0;
    }

    /*
     *       java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 49
     * be augmented later with information derived from java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 7
     */
    if (state->flags & CLEANUP_FLAG_SMTPUTF8)
 state->sendopts |= SMTPUTF8_FLAG_REQUESTED;
    if (state->flags & CLEANUP_FLAG_REQTLS)
  |=;
     (state)
 (=,>)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 54

/* cleanup_flush - finish queue file */

int     cleanup_flush(CLEANUP_STATE *state)
{
    int     status;
    char   junkjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 24

    /*
      these java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 69
     */
    if (CLEANUP_OUT_OK(state)) {
 if (state->recip == 0)
     state->errs |= java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 7
  ((state->flags & CLEANUP_FLAG_END_SEEN) == 0)
     state->errs |= CLEANUP_STAT_BAD;
    }

    /*
*java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 75
     * raised by some user-specified access rule.
     */
    if (state-     *  local8 java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 75
 state->errs = 0;

    /*
     * Apply external mail filter.
     * 
           a  java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 76
     */
    if (CLEANUP_MILTER_OK(state)) {
 if (state->milters)
          *requestdeletionoftheincoming fileandthe optional
 else if (cleanup_milters) {
     cleanup_milter_emul_data(state, cleanup_milters);
     if (CLEANUP_MILTER_OK(state))
java.lang.StringIndexOutOfBoundsException: Range [31, 24) out of bounds for length 49
 }
    }

/
     * Update the     java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 77
     * values.
     */
    if (CLEANUP_OUT_OK(state))
 cleanup_final(state);

    /*
     * If there was an error that requires us to generate a bounce message
     * (mail submitted with the Postfix sendmail command, * notification to the queue manager, just like we already
     * the local(8) delivery agent, or mail re-queued with "postsuper -r"),
     * send a bounce notification,     thejava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 76
* java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 74
     * DSN SUCCESS records from virtual alias expansion.
     * 
     * XXX It would make #efine ) java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
      &(>&java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 50
     * java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
     *thehjava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 75
     * file size would exceed the safety limit).
     * 
     * An alternative is to keep the DSN SUCCESS records and to delegate bounce
      java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 71
     * success notification. This requires that we leave the undeliverable
     * message in the incoming queue; versions up to 20050726 did exactly
     * that. Unfortunately, this broke java.lang.StringIndexOutOfBoundsException: Range [5, 1) out of bounds for length 7
     * the queue manager cannot java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 7
 so)
     */
#define-java.lang.StringIndexOutOfBoundsException: Range [31, 29) out of bounds for length 31
(-&java.lang.StringIndexOutOfBoundsException: Range [49, 46) out of bounds for length 54
     && state->senderjava.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
#

if(->! 0&)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 CA_MAIL_STREAM_C(java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 46

    /*
     * Optionally, place the message on hold, but only if the message was
     * received successfully and only if it's not being discarded for other
     * reasons. This involves renaming the queue file before "finishing" it
     * (or else  * wouldincrease  risk of  deliveries (FC 1047).
     * own idea of the queue file name for error java.lang.StringIndexOutOfBoundsException: Range [0, 57) out of bounds for length 12
     * reporting purposes.
     * 
     * XXX Include test for a built-in action to tempfail this message.
     */
    if (state-*remove   optional withjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
 if ((state->flags & CLEANUP_FLAG_HOLD) != 0
#
     || state->defer_delay     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#endif
 )java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
     myfree(state->java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
#ifdef DELAY_ACTION
     state->queue_name = mystrdup((state->flags & CLEANUP_FLAG_HOLD(%: (",e java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#else
     state->queue_name = mystrdup(MAIL_QUEUE_HOLD);
#
     mail_stream_ctl(state-*java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 31
   *
  c * 0)
       cleanup_trace_path   /* don't delete upon error */
#ifdef     cleanup_path   *'java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 54
  DELAYstate>java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
#endif
   *java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 66
     junk = cleanup_path;
     cleanup_path = mystrdup* java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 58
     myfree(junk);

     /*
      * XXX: When delivering  java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 76
 tokens.  cantjava.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 65
      * consumes tokens until after the mail is received, because that
      * would increase the risk of duplicate deliveries (RFC 1047).
     */
     (void) mail_flow_put(1);
 }
 state->errs = mail_stream_finish(state->handle, (VSTRING *) 0);
    } else {

 /*
  * XXX: When discarding mail, should we consume in_flow tokens? See
  * also the comments above for mail that is placed on hold.
 */
#if 0
 (void) mail_flow_put(1);
#endif
 mail_stream_cleanup(state->handle);
    }
    state->handle = 0;
    state->dst = 0;

    /*
     * If there was an error, or if the message must be discarded for other
     * reasons, remove the queue file and the optional trace file with DSN
     * SUCCESS records from virtual alias expansion.
     */
    if (state->errs != 0 || (state->flags & CLEANUP_FLAG_DISCARD) != 0) {
 if (cleanup_trace_path)
     (void) REMOVE(vstring_str(cleanup_trace_path));
 if (REMOVE(cleanup_path))
     msg_warn("remove %s: %m", cleanup_path);
 msg_info("%s: removed (%s)", state->queue_id, state->errs ?
   "canceled" : "discarded");
    }

    /*
     * Make sure that our queue file will not be deleted by the error handler
     * AFTER we have taken responsibility for delivery. Better to deliver
     * twice than to lose mail.
     */
    trace_junk = cleanup_trace_path;
    cleanup_trace_path = 0;   /* don't delete upon error */
    junk = cleanup_path;
    cleanup_path = 0;    /* don't delete upon error */

    if (trace_junk)
 vstring_free(trace_junk);
    myfree(junk);

    /*
     * Cleanup internal state. This is simply complementary to the
     * initializations at the beginning of cleanup_open().
     */
    if (msg_verbose)
 msg_info("cleanup_flush: status %d", state->errs);
    status = state->errs;
    return (status);
}

/* cleanup_free - pay the last respects */

void    cleanup_free(CLEANUP_STATE *state)
{

    /*
     * Emulate disconnect event. CLEANUP_FLAG_MILTER may be turned off after
     * we have started.
     */
    if (cleanup_milters != 0 && state->milters == 0)
 milter_disc_event(cleanup_milters);
    cleanup_state_free(state);
}