milter_client_context_error_quark ()

GQuark
milter_client_context_error_quark (void);

MILTER_CLIENT_CONTEXT_STATE_IN_MESSAGE_PROCESSING()

#define             MILTER_CLIENT_CONTEXT_STATE_IN_MESSAGE_PROCESSING(state)

milter_client_context_new ()

MilterClientContext *
milter_client_context_new (MilterClient *client);

Creates a new context object. Normally, context object is created by MilterClient and passed by “connection-established” signal.

milter_client_context_feed ()

gboolean
milter_client_context_feed (MilterClientContext *context,
                            const gchar *chunk,
                            gsize size,
                            GError **error);

Feeds a chunk to the context . You can use it for testing or debugging.

milter_client_context_get_private_data ()

gpointer
milter_client_context_get_private_data
                               (MilterClientContext *context);

Gets the private data of the context .

milter_client_context_set_private_data ()

void
milter_client_context_set_private_data
                               (MilterClientContext *context,
                                gpointer data,
                                GDestroyNotify destroy);

Sets the private data of the context . data is destroyed by destroy when data is unset. data is unset when new private data is set or context is destroyed.

milter_client_context_set_reply ()

gboolean
milter_client_context_set_reply (MilterClientContext *context,
                                 guint code,
                                 const gchar *extended_code,
                                 const gchar *message,
                                 GError **error);

Sets the error reply code. 4xx code is used on MILTER_REPLY_TEMPORARY_FAILURE. 5xx code is used on MILTER_REPLY_REJECT.

See also smfi_setreply on milter.org.

milter_client_context_format_reply ()

gchar *
milter_client_context_format_reply (MilterClientContext *context);

Formats the current error reply code specified by milter_client_context_set_reply(). If error reply code isn't set, this function returns NULL.

milter_client_context_add_header ()

gboolean
milter_client_context_add_header (MilterClientContext *context,
                                  const gchar *name,
                                  const gchar *value,
                                  GError **error);

Adds a header to the current message's header list. This function can be called in “end-of-message” signal.

See also smfi_addheader on milter.org.

FIXME: write about MILTER_ACTION_ADD_HEADERS.

milter_client_context_insert_header ()

gboolean
milter_client_context_insert_header (MilterClientContext *context,
                                     guint32 index,
                                     const gchar *name,
                                     const gchar *value,
                                     GError **error);

Inserts a header into the current message's header lists at index . This function can be called in “end-of-message” signal. See also smfi_insheader on milter.org.

FIXME: write about MILTER_ACTION_ADD_HEADERS.

milter_client_context_change_header ()

gboolean
milter_client_context_change_header (MilterClientContext *context,
                                     const gchar *name,
                                     guint32 index,
                                     const gchar *value,
                                     GError **error);

Changes a header that is located at index in headers that all of them are named name . If value is NULL, the header is deleted. This function can be called in “end-of-message” signal.

See also smfi_chgheader on milter.org.

FIXME: write about MILTER_ACTION_CHANGE_HEADERS.

milter_client_context_delete_header ()

gboolean
milter_client_context_delete_header (MilterClientContext *context,
                                     const gchar *name,
                                     guint32 index,
                                     GError **error);

Deletes a header that is located at index in headers that all of them are named name . This function can be called in “end-of-message” signal. This function works same as milter_client_context_change_header() with NULL as value .

FIXME: write about MILTER_ACTION_CHANGE_HEADERS.

milter_client_context_change_from ()

gboolean
milter_client_context_change_from (MilterClientContext *context,
                                   const gchar *from,
                                   const gchar *parameters,
                                   GError **error);

Changes the envelope from address of the current message. ESMTP's 'MAIL FROM' parameter can be set by parameters . parameters may be NULL. This function can be called in “end-of-message” signal. See also smfi_chgfrom on milter.org.

FIXME: write about MILTER_ACTION_CHANGE_FROM.

milter_client_context_add_recipient ()

gboolean
milter_client_context_add_recipient (MilterClientContext *context,
                                     const gchar *recipient,
                                     const gchar *parameters,
                                     GError **error);

Adds a new envelope recipient address to the current message. ESMTP's 'RCPT TO' parameter can be set by parameters . parameters may be NULL. This function can be called in “end-of-message” signal. See also smfi_addrcpt and smfi_addrcpt_par on milter.org.

FIXME: write about MILTER_ACTION_ADD_RECIPIENT and MILTER_ACTION_ADD_ENVELOPE_RECIPIENT_WITH_PARAMETERS.

milter_client_context_delete_recipient ()

gboolean
milter_client_context_delete_recipient
                               (MilterClientContext *context,
                                const gchar *recipient,
                                GError **error);

Removes a envelope recipient that named recipient . This function can be called in “end-of-message” signal. See also smfi_delrcpt on milter.org.

FIXME: write about MILTER_ACTION_DELETE_RECIPIENT.

milter_client_context_replace_body ()

gboolean
milter_client_context_replace_body (MilterClientContext *context,
                                    const gchar *body,
                                    gsize body_size,
                                    GError **error);

This is a const gchar * version of milter_client_context_replace_body_bytes().

[skip]

milter_client_context_replace_body_bytes ()

gboolean
milter_client_context_replace_body_bytes
                               (MilterClientContext *context,
                                GBytes *body,
                                GError **error);

Replaces the body of the current message with body . This function can be called in “end-of-message” signal. See also smfi_replacebody on milter.org.

FIXME: write about MILTER_ACTION_CHANGE_BODY.

[rename-to milter_client_context_replace_body]

Since: 2.1.6

milter_client_context_progress ()

gboolean
milter_client_context_progress (MilterClientContext *context);

Notifies the MTA that this milter is still in progress. This function can be called in “end-of-message” signal. See also smfi_progress on milter.org.

milter_client_context_quarantine ()

gboolean
milter_client_context_quarantine (MilterClientContext *context,
                                  const gchar *reason);

Quarantines the current message with reason . This function can be called in “end-of-message” signal. See also smfi_quarantine on milter.org.

FIXME: write about MILTER_ACTION_QUARANTINE.

milter_client_context_set_timeout ()

void
milter_client_context_set_timeout (MilterClientContext *context,
                                   guint timeout);

Sets the timeout by seconds. If MTA doesn't responses in timeout seconds, “timeout” signal is emitted. See also smfi_settimeout on milter.org.

milter_client_context_get_timeout ()

guint
milter_client_context_get_timeout (MilterClientContext *context);

Gets the timeout by seconds.

milter_client_context_set_state ()

void
milter_client_context_set_state (MilterClientContext *context,
                                 MilterClientContextState state);

Sets the current state.

milter_client_context_get_state ()

MilterClientContextState
milter_client_context_get_state (MilterClientContext *context);

Gets the current state.

milter_client_context_set_quarantine_reason ()

void
milter_client_context_set_quarantine_reason
                               (MilterClientContext *context,
                                const gchar *reason);

Sets the quarantine reason.

milter_client_context_get_quarantine_reason ()

const gchar *
milter_client_context_get_quarantine_reason
                               (MilterClientContext *context);

Gets the quarantine reason.

milter_client_context_get_last_state ()

MilterClientContextState
milter_client_context_get_last_state (MilterClientContext *context);

Gets the last state. It's one of start, negotiate, connect, helo, envelope-from, envelope-recipient, data, unknown, header, end-of-header, body and end-of-message.

milter_client_context_set_status ()

void
milter_client_context_set_status (MilterClientContext *context,
                                  MilterStatus status);

Sets the current status.

milter_client_context_get_status ()

MilterStatus
milter_client_context_get_status (MilterClientContext *context);

Gets the current status.

milter_client_context_set_option ()

void
milter_client_context_set_option (MilterClientContext *context,
                                  MilterOption *option);

Sets the option for the context.

milter_client_context_get_option ()

MilterOption *
milter_client_context_get_option (MilterClientContext *context);

Gets the option for the context.

milter_client_context_set_socket_address ()

void
milter_client_context_set_socket_address
                               (MilterClientContext *context,
                                MilterGenericSocketAddress *address);

Sets the socket address of connected server for the context.

milter_client_context_get_socket_address ()

MilterGenericSocketAddress *
milter_client_context_get_socket_address
                               (MilterClientContext *context);

Gets the socket address of connected server for the context.

milter_client_context_get_message_result ()

MilterMessageResult *
milter_client_context_get_message_result
                               (MilterClientContext *context);

Gets the message result of context .

milter_client_context_set_message_result ()

void
milter_client_context_set_message_result
                               (MilterClientContext *context,
                                MilterMessageResult *result);

Sets the message result of context .

milter_client_context_reset_message_related_data ()

void
milter_client_context_reset_message_related_data
                               (MilterClientContext *context);

Resets message related data of context .

Normally, you don't need to call this function.

milter_client_context_get_n_processing_sessions ()

guint
milter_client_context_get_n_processing_sessions
                               (MilterClientContext *context);

Returns number of the current processing sessions.

milter_client_context_set_packet_buffer_size ()

void
milter_client_context_set_packet_buffer_size
                               (MilterClientContext *context,
                                guint size);

Sets the packet buffer size for the context. Packets on end-of-message are buffered until the buffer size is full. Packet buffering is for performance.

milter_client_context_get_packet_buffer_size ()

guint
milter_client_context_get_packet_buffer_size
                               (MilterClientContext *context);

Gets the packet buffer size for the context.

milter_client_context_set_use_bytes ()

void
milter_client_context_set_use_bytes (MilterClientContext *context,
                                     gboolean use);

Since: 2.1.6

milter_client_context_get_use_bytes ()

gboolean
milter_client_context_get_use_bytes (MilterClientContext *context);

Since: 2.1.6

milter_client_context_set_mail_transaction_shelf_value ()

void
milter_client_context_set_mail_transaction_shelf_value
                               (MilterClientContext *context,
                                const gchar *key,
                                const gchar *value);

Sets the string for the mail_transaction_shelf.

milter_client_context_get_mail_transaction_shelf_value ()

const gchar *
milter_client_context_get_mail_transaction_shelf_value
                               (MilterClientContext *context,
                                const gchar *key);

Gets the string for the mail_transaction_shelf.

milter_client_context_get_mail_transaction_shelf ()

GHashTable *
milter_client_context_get_mail_transaction_shelf
                               (MilterClientContext *context);

Gets the mail_transaction_shelf. This is a mail-transaction scope storage.

milter_client_context_clear_mail_transaction_shelf ()

void
milter_client_context_clear_mail_transaction_shelf
                               (MilterClientContext *context);

Remove all keys and values from mail_transaction_shelf.

MilterClientMailTransactionShelfFunc ()

void
(*MilterClientMailTransactionShelfFunc)
                               (const gchar *key,
                                const gchar *value,
                                gpointer user_data);

It is called with each metadata associated with a mail transaction, together with the user_data parameter which is passed to milter_client_context_mail_transaction_shelf_foreach().

milter_client_context_mail_transaction_shelf_foreach ()

void
milter_client_context_mail_transaction_shelf_foreach
                               (MilterClientContext *context,
                                MilterClientMailTransactionShelfFunc func,
                                gpointer user_data);

A wrapper for g_hash_table_foreach().

MILTER_CLIENT_CONTEXT_ERROR

#define MILTER_CLIENT_CONTEXT_ERROR           (milter_client_context_error_quark())

Used to get the GError quark for MilterClientContext errors.

enum MilterClientContextError

These identify the variable errors that can occur while calling MilterClientContext functions.

enum MilterClientContextState

These identify the state of MilterClientContext.

MILTER_TYPE_CLIENT_CONTEXT

#define MILTER_TYPE_CLIENT_CONTEXT            (milter_client_context_get_type())

struct MilterClientContextClass

struct MilterClientContextClass {
    MilterProtocolAgentClass parent_class;

    MilterStatus (*negotiate)          (MilterClientContext *context,
                                        MilterOption  *option,
                                        MilterMacrosRequests *macros_requests);
    void         (*negotiate_response) (MilterClientContext *context,
                                        MilterOption  *option,
                                        MilterMacrosRequests *macros_requests,
                                        MilterStatus   status);
    void         (*define_macro)       (MilterClientContext *context,
                                        MilterCommand command,
                                        GHashTable *macros);
    MilterStatus (*connect)            (MilterClientContext *context,
                                        const gchar   *host_name,
                                        struct sockaddr *address,
                                        socklen_t      address_length);
    void         (*connect_response)   (MilterClientContext *context,
                                        MilterStatus         status);
    MilterStatus (*helo)               (MilterClientContext *context,
                                        const gchar   *fqdn);
    void         (*helo_response)      (MilterClientContext *context,
                                        MilterStatus         status);
    MilterStatus (*envelope_from)      (MilterClientContext *context,
                                        const gchar   *from);
    void         (*envelope_from_response)
                                       (MilterClientContext *context,
                                        MilterStatus         status);
    MilterStatus (*envelope_recipient) (MilterClientContext *context,
                                        const gchar   *recipient);
    void         (*envelope_recipient_response)
                                       (MilterClientContext *context,
                                        MilterStatus         status);
    MilterStatus (*data)               (MilterClientContext *context);
    void         (*data_response)      (MilterClientContext *context,
                                        MilterStatus         status);
    MilterStatus (*unknown)            (MilterClientContext *context,
                                        const gchar   *command);
    void         (*unknown_response)   (MilterClientContext *context,
                                        MilterStatus         status);
    MilterStatus (*header)             (MilterClientContext *context,
                                        const gchar   *name,
                                        const gchar   *value);
    void         (*header_response)    (MilterClientContext *context,
                                        MilterStatus         status);
    MilterStatus (*end_of_header)      (MilterClientContext *context);
    void         (*end_of_header_response)
                                       (MilterClientContext *context,
                                        MilterStatus         status);
    MilterStatus (*body)               (MilterClientContext *context,
                                        const gchar         *chunk,
                                        gsize                size);
    MilterStatus (*body_bytes)         (MilterClientContext *context,
                                        GBytes              *chunk);
    void         (*body_response)      (MilterClientContext *context,
                                        MilterStatus         status);
    MilterStatus (*end_of_message)     (MilterClientContext *context,
                                        const gchar         *chunk,
                                        gsize                size);
    MilterStatus (*end_of_message_bytes)
                                       (MilterClientContext *context,
                                        GBytes              *chunk);
    void         (*end_of_message_response)
                                       (MilterClientContext *context,
                                        MilterStatus         status);
    MilterStatus (*abort)              (MilterClientContext *context,
                                        MilterClientContextState state);
    void         (*abort_response)     (MilterClientContext *context,
                                        MilterStatus         status);
    void         (*timeout)            (MilterClientContext *context);

    void         (*message_processed)  (MilterClientContext *context,
                                        MilterMessageResult *result);
};

MilterClientContext

typedef struct _MilterClientContext MilterClientContext;

The “client” property

  “client”                   MilterClient *

The client of the context.

Owner: MilterClientContext

Flags: Read / Write / Construct Only

The “message-result” property

  “message-result”           MilterMessageResult *

The message result of client context.

Owner: MilterClientContext

Flags: Read / Write

The “option” property

  “option”                   MilterOption *

The option of client context.

Owner: MilterClientContext

Flags: Read / Write

The “packet-buffer-size” property

  “packet-buffer-size”       guint

The packet buffer size of the client context.

Owner: MilterClientContext

Flags: Read / Write

Default value: 0

The “quarantine-reason” property

  “quarantine-reason”        char *

The quarantine reason of client context.

Owner: MilterClientContext

Flags: Read / Write

Default value: NULL

The “state” property

  “state”                    MilterClientContextState

The state of client context.

Owner: MilterClientContext

Flags: Read / Write

Default value: MILTER_CLIENT_CONTEXT_STATE_INVALID

The “status” property

  “status”                   MilterStatus

The status of client context.

Owner: MilterClientContext

Flags: Read / Write

Default value: MILTER_STATUS_DEFAULT

The “use-bytes” property

  “use-bytes”                gboolean

Owner: MilterClientContext

Flags: Read / Write

Default value: FALSE

The “abort” signal

MilterStatus
user_function (MilterClientContext     *context,
               MilterClientContextState state,
               gpointer                 user_data)

This signal may be emitted at any time between “envelope-from” and “end-of-message”. This signal is only emitted if the milter causes an internal error and the message processing isn't completed. For example, if the milter has already returned MILTER_STATUS_ACCEPT, MILTER_STATUS_REJECT, MILTER_STATUS_DISCARD and MILTER_STATUS_TEMPORARY_FAILURE, this signal will not emitted.

If the milter has any resources allocated for the message between “envelope-from” and “end-of-message”, should be freed in this signal. But any resources allocated for the connection should not be freed in this signal. It should be freed in “finished”.

All available response statuses are the followings:

See also xxfi_abort on milter.org.

Flags: Run Last

The “abort-response” signal

void
user_function (MilterClientContext *context,
               MilterStatus         status,
               gpointer             user_data)

This signal is emitted implicitly after “abort” returns a status except MILTER_STATUS_PROGRESS. This signal's default handler replies a response to MTA. You don't need to connect this signal.

If you returns MILTER_STATUS_PROGRESS in “abort”, you need to emit this signal to context by yourself.

Flags: Run Last

The “body” signal

MilterStatus
user_function (MilterClientContext *context,
               char                *chunk,
               guint64              size,
               gpointer             user_data)

This signal is emitted on body data is received. This signal is emitted zero or more times between “end-of-header” and “end-of-message”.

All available response statuses are the followings:

See also xxfi_body on milter.org.

Flags: Run Last

The “body-bytes” signal

MilterStatus
user_function (MilterClientContext *context,
               GBytes              *chunk,
               gpointer             user_data)

You can use this signal instead of “body-bytes” by calling milter_client_context_use_bytes(TRUE).

Flags: Run Last

Since: 2.1.6.

The “body-response” signal

void
user_function (MilterClientContext *context,
               MilterStatus         status,
               gpointer             user_data)

This signal is emitted implicitly after “body” returns a status except MILTER_STATUS_PROGRESS. This signal's default handler replies a response to MTA. You don't need to connect this signal.

If you returns MILTER_STATUS_PROGRESS in “body”, you need to emit this signal to context by yourself.

Flags: Run Last

The “connect” signal

MilterStatus
user_function (MilterClientContext *context,
               char                *host_name,
               gpointer             address,
               guint                address_size,
               gpointer             user_data)

This signal is emitted on SMTP client is connected to MTA.

All available response statuses are the followings:

See also xxfi_connect on milter.org.

Flags: Run Last

The “connect-response” signal

void
user_function (MilterClientContext *context,
               MilterStatus         status,
               gpointer             user_data)

This signal is emitted implicitly after “connect” returns a status except MILTER_STATUS_PROGRESS. This signal's default handler replies a response to MTA. You don't need to connect this signal.

If you returns MILTER_STATUS_PROGRESS in “connect”, you need to emit this signal to context by yourself.

Flags: Run Last

The “data” signal

MilterStatus
user_function (MilterClientContext *context,
               gpointer             user_data)

This signal is emitted on SMTP's "DATA" command.

All available response statuses are the followings:

See also xxfi_data on milter.org.

Flags: Run Last

The “data-response” signal

void
user_function (MilterClientContext *context,
               MilterStatus         status,
               gpointer             user_data)

This signal is emitted implicitly after “data” returns a status except MILTER_STATUS_PROGRESS. This signal's default handler replies a response to MTA. You don't need to connect this signal.

If you returns MILTER_STATUS_PROGRESS in “data”, you need to emit this signal to context by yourself.

Flags: Run Last

The “define-macro” signal

void
user_function (MilterClientContext *context,
               MilterCommand        command,
               gpointer             macros,
               gpointer             user_data)

This signal is emitted when macro definition is received. Normally, this signal isn't needed to be connected.

Flags: Run Last

The “end-of-header” signal

MilterStatus
user_function (MilterClientContext *context,
               gpointer             user_data)

This signal is emitted on all headers are processed.

All available response statuses are the followings:

See also xxfi_eof on milter.org.

Flags: Run Last

The “end-of-header-response” signal

void
user_function (MilterClientContext *context,
               MilterStatus         status,
               gpointer             user_data)

This signal is emitted implicitly after “end-of-header” returns a status except MILTER_STATUS_PROGRESS. This signal's default handler replies a response to MTA. You don't need to connect this signal.

If you returns MILTER_STATUS_PROGRESS in “end-of-header”, you need to emit this signal to context by yourself.

Flags: Run Last

The “end-of-message” signal

MilterStatus
user_function (MilterClientContext *context,
               char                *chunk,
               guint64              size,
               gpointer             user_data)

This signal is emitted after all “body” are emitted. All message modifications can be done only in this signal handler. The modifications can be done with milter_client_context_add_header(), milter_client_context_change_from() and so on.

All available response statuses are the followings:

See also xxfi_eom on milter.org.

Flags: Run Last

The “end-of-message-bytes” signal

MilterStatus
user_function (MilterClientContext *context,
               GBytes              *chunk,
               gpointer             user_data)

You can use this signal instead of “end-of-message-bytes” by calling milter_client_context_use_bytes(TRUE).

Flags: Run Last

Since: 2.1.6.

The “end-of-message-response” signal

void
user_function (MilterClientContext *context,
               MilterStatus         status,
               gpointer             user_data)

This signal is emitted implicitly after “end-of-message” returns a status except MILTER_STATUS_PROGRESS. This signal's default handler replies a response to MTA. You don't need to connect this signal.

If you returns MILTER_STATUS_PROGRESS in “end-of-message”, you need to emit this signal to context by yourself.

Flags: Run Last

The “envelope-from” signal

MilterStatus
user_function (MilterClientContext *context,
               char                *from,
               gpointer             user_data)

This signal is emitted on SMTP's "MAIL FROM" command.

All available response statuses are the followings:

See also xxfi_envfrom on milter.org.

Flags: Run Last

The “envelope-from-response” signal

void
user_function (MilterClientContext *context,
               MilterStatus         status,
               gpointer             user_data)

This signal is emitted implicitly after “envelope-from” returns a status except MILTER_STATUS_PROGRESS. This signal's default handler replies a response to MTA. You don't need to connect this signal.

If you returns MILTER_STATUS_PROGRESS in “envelope-from”, you need to emit this signal to context by yourself.

Flags: Run Last

The “envelope-recipient” signal

MilterStatus
user_function (MilterClientContext *context,
               char                *recipient,
               gpointer             user_data)

This signal is emitted on SMTP's "RCPT TO" command.

All available response statuses are the followings:

See also xxfi_envrcpt on milter.org.

Flags: Run Last

The “envelope-recipient-response” signal

void
user_function (MilterClientContext *context,
               MilterStatus         status,
               gpointer             user_data)

This signal is emitted implicitly after “envelope-recipient” returns a status except MILTER_STATUS_PROGRESS. This signal's default handler replies a response to MTA. You don't need to connect this signal.

If you returns MILTER_STATUS_PROGRESS in “envelope-recipient”, you need to emit this signal to context by yourself.

Flags: Run Last

The “header” signal

MilterStatus
user_function (MilterClientContext *context,
               char                *name,
               char                *value,
               gpointer             user_data)

This signal is emitted on each header. If MILTER_STEP_HEADER_LEADING_SPACE is set in “negotiate”, value have spaces after header name and value separator ":".

Example:

1
2
3

From: from <from@example.com>
To: recipient <recipient@example.com>
Subject:a subject

With MILTER_STEP_HEADER_VALUE_WITH_LEADING_SPACE:

1
2
3

"From", " from <from@example.com>"
"To", " recipient <recipient@example.com>"
"Subject", "a subject"

Without MILTER_STEP_HEADER_VALUE_WITH_LEADING_SPACE:

1
2
3

"From", "from <from@example.com>"
"To", "recipient <recipient@example.com>"
"Subject", "a subject"

All available response statuses are the followings:

See also xxfi_header on milter.org.

Flags: Run Last

The “header-response” signal

void
user_function (MilterClientContext *context,
               MilterStatus         status,
               gpointer             user_data)

This signal is emitted implicitly after “header” returns a status except MILTER_STATUS_PROGRESS. This signal's default handler replies a response to MTA. You don't need to connect this signal.

If you returns MILTER_STATUS_PROGRESS in “header”, you need to emit this signal to context by yourself.

Flags: Run Last

The “helo” signal

MilterStatus
user_function (MilterClientContext *context,
               char                *fqdn,
               gpointer             user_data)

This signal is emitted on SMTP's "HELO"/"EHLO" command.

All available response statuses are the followings:

See also xxfi_helo on milter.org.

Flags: Run Last

The “helo-response” signal

void
user_function (MilterClientContext *context,
               MilterStatus         status,
               gpointer             user_data)

This signal is emitted implicitly after “helo” returns a status except MILTER_STATUS_PROGRESS. This signal's default handler replies a response to MTA. You don't need to connect this signal.

If you returns MILTER_STATUS_PROGRESS in “helo”, you need to emit this signal to context by yourself.

Flags: Run Last

The “message-processed” signal

void
user_function (MilterClientContext *milterclientcontext,
               MilterMessageResult *arg1,
               gpointer             user_data)

Flags: Run Last

The “negotiate” signal

MilterStatus
user_function (MilterClientContext  *context,
               MilterOption         *option,
               MilterMacrosRequests *macros_requests,
               gpointer              user_data)

This signal is emitted on negotiate request from MTA. If you want to modify actions (MilterActionFlags) and steps (MilterStepFlags), you modify option . If you want to add macros that you want to receive, you modify macros_requests .

All available response statuses are the followings:

See also xxfi_negotiate on milter.org.

Flags: Run Last

The “negotiate-response” signal

void
user_function (MilterClientContext  *context,
               MilterOption         *option,
               MilterMacrosRequests *macros_requests,
               MilterStatus          status,
               gpointer              user_data)

This signal is emitted implicitly after “negotiate” returns a status except MILTER_STATUS_PROGRESS. This signal's default handler replies a response to MTA. You don't need to connect this signal.

If you returns MILTER_STATUS_PROGRESS in “negotiate” handler, you need to emit this signal to context by yourself.

Flags: Run Last

The “timeout” signal

void
user_function (MilterClientContext *context,
               gpointer             user_data)

This signal is emitted if MTA doesn't return the next command within milter_client_context_get_timeout() seconds. If “timeout” is emitted, the current connection is aborted and “finished” are emitted. “abort” may be emitted before “finished” if the milter is processing a message.

Flags: Run Last

The “unknown” signal

MilterStatus
user_function (MilterClientContext *context,
               char                *command,
               gpointer             user_data)

This signal is emitted on unknown or unimplemented SMTP command is sent.

All available response statuses are the followings:

Note that the unknown or unimplemented SMTP command will always be rejected by MTA.

See also xxfi_unknown on milter.org.

Flags: Run Last

The “unknown-response” signal

void
user_function (MilterClientContext *context,
               MilterStatus         status,
               gpointer             user_data)

This signal is emitted implicitly after “unknown” returns a status except MILTER_STATUS_PROGRESS. This signal's default handler replies a response to MTA. You don't need to connect this signal.

If you returns MILTER_STATUS_PROGRESS in “unknown”, you need to emit this signal to context by yourself.

Flags: Run Last