context

Namespace: global/context

Inspect the transaction context.

fn to_debug

fn to_debug(ctx: State<StatefulCtxReceived>) -> String

Description

fn set_routing_path

fn set_routing_path(ctx: State<StatefulCtxReceived>, rcpt: Recipient>, path: String) -> Result<()>

Description

fn client_address

fn client_address(ctx: State<StatefulCtxReceived>) -> String

Description

Get the address of the client.

Effective smtp stage

All of them.

Return

• string - the client's address with the ip:port format.

Examples

#{
  connect: [
    action "log client address" || {
      log("info", `new client: ${ctx::client_address()}`);
    },
  ],
}

get client_ip

fn get client_ip(ctx: State<StatefulCtxReceived>) -> String

Description

Get the ip address of the client.

Effective smtp stage

All of them.

Return

• string - the client's ip address.

Example

#{
  connect: [
    action "log client ip" || {
      log("info", `new client: ${ctx::client_ip()}`);
    },
  ],
}

fn client_port

fn client_port(ctx: State<StatefulCtxReceived>) -> int

Description

Get the ip port of the client.

Effective smtp stage

All of them.

Return

• int - the client's port.

Example

#{
  connect: [
    action "log client address" || {
      log("info", `new client: ${ctx::client_ip()}:${ctx::client_port()}`);
    },
  ],
}

fn server_address

fn server_address(ctx: State<StatefulCtxReceived>) -> String

Description

Get the full server address.

Effective smtp stage

All of them.

Return

• string - the server's address with the ip:port format.

Example

#{
  connect: [
    action "log server address" || {
      log("info", `server: ${ctx::server_address()}`);
    },
  ],
}

fn server_ip

fn server_ip(ctx: State<StatefulCtxReceived>) -> String

Description

Get the server's ip.

Effective smtp stage

All of them.

Return

• string - the server's ip.

Example

#{
  connect: [
    action "log server ip" || {
      log("info", `server: ${ctx::server_ip()}`);
    },
  ],
}

fn server_port

fn server_port(ctx: State<StatefulCtxReceived>) -> int

Description

Get the server's port.

Effective smtp stage

All of them.

Return

• string - the server's port.

Example

#{
  connect: [
    action "log server address" || {
      log("info", `server: ${ctx::server_ip()}:${ctx::server_port()}`);
    },
  ],
}

fn connection_timestamp

fn connection_timestamp(ctx: State<StatefulCtxReceived>) -> OffsetDateTime

Description

Get a the timestamp of the client's connection time.

Effective smtp stage

All of them.

Return

• timestamp - the connection timestamp of the client.

Example

#{
  connect: [
    action "log client" || {
      log("info", `new client connected at ${ctx::connection_timestamp()}`);
    },
  ],
}

fn server_name

fn server_name(ctx: State<StatefulCtxReceived>) -> String

Description

Get the name of the server.

Effective smtp stage

All of them.

Return

• string - the name of the server.

Example

#{
  connect: [
    action "log server" || {
      log("info", `server name: ${ctx::server_name()}`);
    },
  ],
}

fn is_secured

fn is_secured(_ctx: State<StatefulCtxReceived>) -> bool

Description

Has the connection been secured under the encryption protocol SSL/TLS.

Effective smtp stage

all of them.

Return

• bool - true if the connection is secured, false otherwise.

Example

#{
  connect: [
    action "log ssl/tls" || {
      log("info", `The client is ${if ctx::is_secured() { "secured" } else { "unsecured!!!" }}`)
    }
  ],
}

get helo

fn get helo(ctx: State<StatefulCtxReceived>) -> Result<String>

Description

Get the value of the `HELO/EHLO` command sent by the client.

Effective smtp stage

helo and onwards.

Return

• string - the value of the HELO/EHLO command.

Examples

#{
    helo: [
       action "log info" || log("info", `helo/ehlo value: ${ctx::helo()}`),
    ]
}

get sender

fn get sender(ctx: State<StatefulCtxReceived>) -> ?>

Description

Get the value of the `MAIL FROM` command sent by the client.

Effective smtp stage

mail and onwards.

Return

String or "" (for null reverse path))

Examples

#{
    helo: [
       action "log info" || log("info", `received sender: ${ctx::sender()}`),
    ]
}

get recipients

fn get recipients(ctx: State<StatefulCtxReceived>) -> Array>

Description

Get the list of recipients received by the client.

Effective smtp stage

rcpt and onwards. Note that you will not have all recipients received all at once in the rcpt stage. It is better to use this function in the later stages.

Return

• Array of addresses - the list containing all recipients.

Examples

#{
    preq: [
       action "log recipients" || log("info", `recipients: ${ctx::recipients()}`),
    ]
}

get domain

fn get domain(ctx: Recipient>) -> String
fn get domain(ctx: Mailbox) -> String

Description

Get the recipient's domain.

get local_part

fn get local_part(ctx: Recipient>) -> String

Description

get address

fn get address(ctx: Recipient>) -> String

Description

get is_null

fn get is_null(mailbox: ?) -> bool

Description

fn mail_timestamp

fn mail_timestamp(ctx: State<StatefulCtxReceived>) -> OffsetDateTime>

Description

Get the time of reception of the email.

Effective smtp stage

preq and onwards.

Return

• string - the timestamp.

Examples

#{
    preq: [
       action "receiving the email" || log("info", `time of reception: ${ctx::mail_timestamp()}`),
    ]
}

get message_id

fn get message_id(ctx: State<StatefulCtxReceived>) -> Result<String>

Description

Get the unique id of the received message.

Effective smtp stage

preq and onwards.

Return

• string - the message id.

Examples

#{
    preq: [
       action "message received" || log("info", `message id: ${ctx::message_id()}`),
    ]
}