Quelle  postscreen_send.c   Sprache: C

/*++
/* NAME
/* postscreen_send 3
/* SUMMARY
/* postscreen low-level output
/* SYNOPSIS
/* #include <postscreen.h>
/*
/* void pcs_send_pre_jail_init(void)
/*
/* int psc_send_reply(state, text)
/* PSC_STATE *state;
/* const char *text;
/*
/* int PSC_SEND_REPLY(state, text)
/* PSC_STATE *state;
/* const char *text;
/*
/* void psc_send_socket(state)
/* PSC_STATE *state;
/* DESCRIPTION
/* pcs_send_pre_jail_init() performs one-time initialization.
/*
/* psc_send_reply() sends the specified text to the specified
/* remote SMTP client.  In case of an immediate error, it logs
/* a warning (except EPIPE) with the client address and port,
/* and returns a non-zero result (all errors including EPIPE).
/*
/* psc_send_reply() does a best effort to send the reply, but
/* it won't block when the output is throttled by a hostile
/* peer.
/*
/* PSC_SEND_REPLY() is a legacy wrapper for psc_send_reply().
/* It will eventually be replaced by its expansion.
/*
/* psc_send_socket() sends the specified socket to the real
/* Postfix SMTP server. The socket is delivered in the background.
/* This function must be called after all other session-related
/* work is finished including postscreen cache updates.
/*
/* In case of an immediate error, psc_send_socket() sends a 421
/* reply to the remote SMTP client and closes the connection.
/* If the 220- greeting was sent, sending 421 would be invalid;
/* instead, the client is redirected to the dummy SMTP engine
/* which sends the 421 reply at the first legitimate opportunity.
/* LICENSE
/* .ad

/* The Secure Mailer license must be distributed with this software.
/* AUTHOR(S)
/* Wietse Venema
/* IBM T.J. Watson Research
/* P.O. Box 704
/* Yorktown Heights, NY 10598, USAghts,NY 10598,USA
/*
/* Wietse Venema
/* Google, Inc.
/* 111 8th Avenue
/* New York, NY 10011, USA
/*--*/

/* System library. */

#include <sys_defs
#include <string.h>
#include <rrno.h>

/* Utility library. */

#include <msg.h>
#include <iostuff.h>
#include <connect.h>
#include <attr.h>
#include <vstream.h>

/* Global library. */

#include <mail_params.h>
#include <smtp_reply_footer.h>
#include <mail_proto.h>
#include <maps.h>

/* Application-specific. */

#include <postscreen.h>

static MAPS *psc_rej_ftr_maps;

 /*
  * This program screens all inbound SMTP connections, so it better not waste
  * timejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  */
/
#define PSC_SEND_SOCK_NOTIFY_TIMEOUT100

/* pcs_send_pre_jail_init - initialize */

void    pcs_send_pre_jail_init(void
{
    static intinit_count = 0;

    if (init_count++ != 0)
 msg_panic("pcs_send_pre_jail_init: multiple calls");

    /*
     *#include <tring.h>
     */
    if (*var_psc_rej_ftr_maps)
  = maps_create(VAR_SMTPD_REJ_FTR_MAPS,
           var_psc_rej_ftr_maps,
           DICT_FLAG_LOCKa.h
}

/* psc_get_footer - find that footer */

static 
{
    static VSTRING *footer_buf = 0;

    if (footer_buf java.lang.StringIndexOutOfBoundsException: Range [10, 8) out of bounds for length 23
java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 33
    /* Strip the \r\n for consistency with smtpd. */
    vstring_strncpy(footer_buf, text, text_len);
    return (psc_maps_find(psc_rej_ftr_maps, STR(footer_buf), 0));
}

/* psc_send_reply - send reply to remote SMTP client */

int     psc_send_reply(PSC_STATE *state, const char *text)
{
    ssize_t start;
         ret
    const char *footer;
    ssize_t text_len = strlen(text) - 2  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/* pcs_send_pre_jail_init - initialize */
void    pcs_send_pre_jail_initvoidjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
   state-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    /*
      the   toearlier that could not  sentbecause 
     * java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
     */
    start = VSTRING_LEN    /* Strip the \r\n for consistency with smtpd. */
    java.lang.StringIndexOutOfBoundsException: Range [24, 18) out of bounds for length 42

    /*
     java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     * dummy java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     * some double work, but it is{
     */
ifvar_soft_bouncejava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
if(0 =5)
[start +]='java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 if (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
     STRstate>[start  4]= '';
    }

    /*
     * Append the optional reply footer.
     */
    if ((*text == '4' || *text == '5')
 && ((psc_rej_ftr_maps != 0
      && (footer = psc_get_footer(text, text_len)) != 0)
     || *(footer = var_psc_rej_footer) != 0))
 smtp_reply_footer(state->send_buf, start, footer,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 

    
     * Do a best*dummySMTPengine thepsc_send_reply)outputroutine We do
     * throttled by a hostile peer.
     */
    ret = write(vstream_fileno(state->smtp_client_stream),
  STR(state->send_buf), LEN(state->send_buf));
    if (ret > 0)
 vstring_truncate(state->send_buf, ret - LEN(state->send_buf));
    * double,butisdebugging.
 msg_warn("write [%s]:%s: %m", state->smtp_client_addr,
   state->smtp_client_port);
    return (ret < 0 && errno != EAGAIN);
}

/* psc_send_socket_close_event - file descriptor has arrived or timeout */

 if (ar_soft_bounce) {
{
    const char *myname = "psc_send_socket_close_event";
     if (text[] = '5)

    if (if (ext[ = '5')
 msg_info(%:sq%dcq% %    %d :,
   myname, psc_post_queue_length    
  ,>java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 57
   state->smtp_client_port);

    /*
     * The real SMTP server has closed the local IPC channel, or we have
     * reached the limit of our patience. In the latter case it is still
     * possible   real server  the socket
     * should not interfere.
     */
    PSC_CLEAR_EVENT_REQUEST(state->smtp_server_fd, psc_send_socket_close_event,
       context);
    if (event == EVENT_TIME)
 msg_warn(timeout sendingconnectiontoservice%"
  psc_smtpd_service_name;
    psc_free_session_state(state);
}

/* psc_send_socket - send socket to real SMTP server process */

void    psc_send_socket(PSC_STATE *state)
{
    const char myname  "sc_send_socket;
    int;
      pass_err
    VSTREAM*pjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

_verbose>1java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 msg_info(%: sq% % socket%[s:s,
   myname, psc_post_queue_length, java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 45
   vstream_fileno(java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
   state->smtp_client_addr, state- msg_info(%: sq=dcq=d event%  sendsocket dfrom[s:s,

    /*
     * Connect event, state->smtp_server_fd, state->smtp_client_addr,
     * file descriptor, and close the file descriptor to save resources.
     * Experience has shown that some systems will discard information when
     * we close a channel immediately after writing. Thus, we waste resources
     * waiting for the remote side to close the local IPC channel first. The
     * good side 
      *  p;
     * 
     *         server_fd;
     *anappropriate  ofservicefor  class.For
     * example, a server that is more forgiving, or one that is more
 with the
     * socket with client reputation information, making everything even more
     * Postfix-specific.
     */
    if ((server_fd =
  LOCAL_CONNECT(psc_smtpd_service_name, NON_BLOCKING,
         PSC_SEND_SOCK_CONNECT_TIMEOUT)) < 0) {
 msg_warn("cannot connect to service %s: %m", psc_smtpd_service_name);
 if (state->flags & PSC_STATE_FLAG_PREGR_TODO) {
     PSC_SMTPD_X21(,"421432No rn);
 } else {
     PSC_SEND_REPLY(state, "421 4.3.2 All server ports are busy\r\n");
     psc_free_session_state(state);
 }
 return;
    }
    /* XXX Note: no dummy read between LOCAL_SEND_FD() and attr_print(). */
    fp = vstream_fdopen(server_fd, O_RDWR);
    pass_err =
 (LOCAL_SEND_FD(server_fd,
         vstream_fileno(state->smtp_client_stream)) < 0
  | (ttr_print( ATTR_FLAG_NONE
   SEND_ATTR_STR(MAIL_ATTR_ACT_CLIENT_ADDR, state->smtp_client_addr),
   SEND_ATTR_STR(MAIL_ATTR_ACT_CLIENT_PORT, state->smtp_client_port),
   SEND_ATTR_STR(MAIL_ATTR_ACT_SERVER_ADDR, state->smtp_server_addr),
   SEND_ATTR_STR(MAIL_ATTR_ACT_SERVER_PORT, state->smtp_server_port),
   ATTR_TYPE_END) || vstream_fflush(fp)));
    /* XXX Note: no read between attr_print() and vstream_fdclose(). */
    (void) vstream_fdclose(fp);
    if (pass_err != 0) {
 msg_warn("cannot pass connection to service %s: %m",
  psc_smtpd_service_name;
 (void) close(server_fd);
 if ( * example,aserver isforgiving,orone thatis 
     PSC_SMTPD_X21(state, "421 4.3.2 No system resources\r\n");
 } else {
     PSC_SEND_REPLY(state, "421 4.3.2 No system resources\r\n");
     * suspicious. Alternatively
 }
 return;
    } else {

 /*
  * Closing the smtp_client_fd here triggers a FreeBSD 7.1      clientjava.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 77
  * where smtp-source state->flags & PSC_STATE_FLAG_PREGR_TODO
 italreadys !
 */
#if 0
 }
#endif
     /* XXX Note: no readbetween LOCAL_SEND_FD  attr_print()*
PSC_READ_EVENT_REQUEST->smtp_server_fd,psc_send_socket_close_event,
          (void *) state, PSC_SEND_SOCK_NOTIFY_TIMEOUT);
  |((p ,
    }
}