Version 3 Language Libraries

Version 3 Changes

Version 3.0 Changes

Version 3.0 was introduced in I2P release 0.7.3.
SAM v2 provided a way to manage several sockets
on the same I2P destination in parallel, i.e. the client does not
have to wait for data being successfully sent on one socket before sending
data on another socket. But all data transited through the same
client<-->SAM socket, which was quite complicated to manage for the client.

SAM v3 manages sockets in a different way: each I2P socket
matches a unique client<-->SAM socket, which is much more simple to handle.
This is similar to BOB.
SAM v3 also offers a UDP port for sending datagrams through I2P, and
can forward back I2P datagrams to the client's datagram server.

Version 3.1 Changes

Version 3.1 was introduced in I2P release 0.9.14.

DEST GENERATE and SESSION CREATE now support a SIGNATURE_TYPE parameter.

The MIN and MAX parameters in HELLO VERSION are now optional.

The MIN and MAX parameters in HELLO VERSION now support single-digit versions such as "3".

Version 3 Protocol

Simple Anonymous Messaging (SAM) Version 3.3 Specification Overview

The client application talks to the SAM bridge, which deals with
all of the I2P functionality (using the streaming
library for virtual streams, or I2CP directly for datagrams).

By default, the client<-->SAM bridge communication is unencrypted and unauthenticated.
The SAM bridge may support SSL/TLS connections;
configuration and implementation details are outside the scope of this specification.
As of SAM 3.2, optional authentication user/password parameters are supported in the initial handshake
and may be required by the bridge..

I2P communications are supported by I2P sessions, and each I2P
session is bound to an address (called destination). An I2P session
is associated with one of the three types above, and cannot carry
communications of another type,
unless using MASTER sessions.

Encoding and Escaping

All of these SAM messages are sent on a single line,
terminated by the newline character (\n).
Prior to SAM 3.2, only 7-bit ASCII was supported.
As of SAM 3.2, the encoding must be UTF-8.
Any UTF8-encoded keys or values should work.

The formatting shown in this specification
below is merely for readability, and while the first two words in
each message must stay in their specific order, the ordering of
the key=value pairs can change (e.g. "ONE TWO A=B C=D" or
"ONE TWO C=D A=B" are both perfectly valid constructions).
In addition, the protocol is case-sensitive.
In the following, message examples are preceded by "-> " for
messages sent by the client to the SAM bridge, and by "<- " for
messages sent by the SAM bridge to the client.

COMMAND without a SUBCOMMAND is supported for some new commands in SAM 3.2 only.

Key=value pairs must be separated by
a single space. (As of SAM 3.2, multiple spaces are allowed)
Values may be enclosed in double quotes if they contain spaces,
e.g. key="long value text".
(Prior to SAM 3.2, this did not work reliably in some implementations)

Prior to SAM 3.2, there was no escaping mechanism.
As of SAM 3.2, double quotes may be escaped with a backslash '\'
and a backslash may be represented as two backslashes '\\'.

Empty values

As of SAM 3.2,
empty option values such as KEY, KEY=, or KEY="" may be allowed, implementation dependent.

Case Sensitivity

The protocol, as specified, is case-sensitive.
It is recommended but not required that the server map commands to upper case, for ease in testing via telnet.
This would allow, for example, "hello version" to work.
This is implementation-dependent.
Do not map keys or values to upper case, as this would corrupt I2CP options.

SAM Connection Handshake

No SAM communication can occur until after the client and bridge have
agreed on a protocol version, which is done by the client sending
a HELLO and the bridge sending a HELLO REPLY:

-> HELLO VERSION
[MIN=$min] # Optional as of SAM 3.1, required for 3.0 and earlier
[MAX=$max] # Optional as of SAM 3.1, required for 3.0 and earlier
[USER="xxx"] # As of SAM 3.2, required if authentication is enabled, see below
[PASSWORD="yyy"] # As of SAM 3.2, required if authentication is enabled, see below

and

<- HELLO REPLY RESULT=OK VERSION=3.1

As of version 3.1 (I2P 0.9.14), the MIN and MAX parameters are optional.
SAM will always return the highest version possible given the
MIN and MAX constraints, or the current server version if no constraints are given.
If the SAM bridge cannot find a suitable version, it replies with:

<- HELLO REPLY RESULT=NOVERSION

If some error occurred, such as a bad request format, it replies with:

<- HELLO REPLY RESULT=I2P_ERROR MESSAGE=$message

SSL

The server's control socket may optionally offer SSL/TLS support, as configured on the server and client.
Implementations may offer other transport layers as well; this is outside the scope of the protocol definition.

Authorization

For authorization, client adds USER="xxx" PASSWORD="yyy" to the HELLO parameters.
Double quotes for user and password are recommended but not required.
A double quote inside a user or password must be escaped with a backslash.
On failure the server will reply with an I2P_ERROR and a message.
It is recommended that SSL be enabled on any SAM servers where authorization is required.

Timeouts

Servers may implement timeouts for the HELLO or subsequent commands, implementation dependent.
Clients should promptly send the HELLO and the next command after connecting.

If a timeout occurs before the HELLO is received, the bridge replies with:

<- HELLO REPLY RESULT=I2P_ERROR MESSAGE=$message

and then disconnects.

If a timeout occurs after the HELLO is received but before the next command, the bridge replies with:

<- SESSION STATUS RESULT=I2P_ERROR MESSAGE=$message

and then disconnects.

I2CP Ports and Protocol

As of SAM 3.2, the I2CP ports and protocol may be specified by the
SAM client sender to be passed through to I2CP, and
the SAM bridge will pass the received I2CP port and protocol
information to the SAM client.

For FROM_PORT and TO_PORT, the valid range is 0-65535, and the default is 0.

For PROTOCOL, which may be specified only for RAW, the valid range is 0-255, and the default is 18.

For SESSION commands, the specified ports and protocol are the defaults for that session.
For individual streams or datagrams, the specified ports and protocol override the session defaults.
For received streams or datagrams, the indicated ports and protocol are as received from I2CP.

See the I2CP specification for more information.

SAM Sessions

A SAM session is created by a client opening a socket to the SAM
bridge, operating a handshake, and sending a SESSION CREATE message,
and the session terminates when the socket is disconnected.

Each registered I2P Destination is uniquely associated with a session ID
(or nickname).

Each session is uniquely associated with:

the socket from which the client creates the session

its ID (or nickname)

Session Creation Request

The session creation message can only use one of these forms (messages
received through other forms are answered with an error message) :

DESTINATION specifies what destination should be used for
sending and receiving messages/streams.
The $privkey is the base 64 of the concatenation of the Destination
followed by the Private Key
followed by the Signing Private Key,
which is 663 or more bytes in binary and 884 or more bytes in base 64,
depending on signature type.
The binary format is specified in Private Key File.

If the destination is specified as TRANSIENT, the SAM bridge creates a new destination.
As of version 3.1 (I2P 0.9.14), if the destination is TRANSIENT, an optional parameter
SIGNATURE_TYPE is supported. The SIGNATURE_TYPE value may be any name
(e.g. ECDSA_SHA256_P256, case insensitive) or number (e.g. 1)
supported by Key Certificates.
The default is DSA_SHA1.

$nickname is the choice of the client. No whitespace is allowed.

Additional options given are passed to the I2P session
configuration if not interpreted by the SAM bridge (e.g.
outbound.length=0). These options are documented below..

The SAM bridge itself should already be configured with what router
it should communicate over I2P through (though if need be there may
be a way to provide an override, e.g. i2cp.tcp.host=localhost and
i2cp.tcp.port=7654).

Session Creation Response

After receiving the session create message, the SAM bridge will reply
with a session status message, as follows:

If it's not OK, the MESSAGE should contain human-readable information
as to why the session could not be created.

SAM sessions live and die with the socket they are associated with.
When the socket is closed, the session dies, and all communications
using the session die at the same time. And the other way round, when
the session dies for any reason, the SAM bridge closes the socket.

SAM Virtual Streams

Virtual streams are guaranteed to be sent reliably and in order, with
failure and success notification as soon as it is available.

Streams are bidirectional communication sockets between two I2P
destinations, but their opening has to be requested by one of them.
Hereafter, CONNECT commands are used by the SAM client for such a
request. FORWARD / ACCEPT commands are used by the SAM client when
he wants to listen to requests coming from other I2P destinations.

Connect Request

This establishes a new virtual connection from the local session
whose ID is $nickname to the specified peer.

The target is $destination, which is the base 64 of the Destination,
which is 516 or more base 64 characters (387 or more bytes in binary),
depending on signature type.

Connect Response

If SILENT=true is passed, the SAM bridge won't issue any other message
on the socket. If the connection fails, the socket will be closed.
If the connection succeeds, all remaining data passing through the
current socket is forwarded from and to the connected I2P destination
peer.

If SILENT=false, which is the default value, the SAM bridge sends a
last message to its client before forwarding or shutting down the
socket:

<- STREAM STATUS
RESULT=$result
[MESSAGE=...]

The RESULT value may be one of:

OK
CANT_REACH_PEER
I2P_ERROR
INVALID_KEY
INVALID_ID
TIMEOUT

If the RESULT is OK, all remaining data passing through the
current socket is forwarded from and to the connected I2P destination
peer. If the connection was not possible (timeout, etc),
RESULT will contain the appropriate error value (accompanied by an
optional human-readable MESSAGE), and the SAM bridge closes the
socket.

SAM Virtual Streams : ACCEPT

A client waits for an incoming connection request by:

opening a new socket with the SAM bridge

passing the same HELLO handshake as above

sending the STREAM ACCEPT command

Accept Request

-> STREAM ACCEPT
ID=$nickname
[SILENT={true,false}] # default false

This makes the session ${nickname} listen for one incoming
connection request from the I2P network.
ACCEPT is not allowed while there is an active FORWARD on the session.

As of SAM 3.2,
multiple concurrent pending STREAM ACCEPTs are allowed on the same session ID (even with the same port).
Prior to 3.2, concurrent accepts would fail with ALREADY_ACCEPTING.

Accept Response

If SILENT=true is passed, the SAM bridge won't issue any other message
on the socket. If the accept fails, the socket will be closed.
If the accept succeeds, all remaining data passing through the
current socket is forwarded from and to the connected I2P destination
peer.
For reliability, and to receive the destination for incoming connections,
SILENT=false is recommended.

If SILENT=false, which is the default value,
the SAM bridge answers with:

<- STREAM STATUS
RESULT=$result
[MESSAGE=...]

The RESULT value may be one of:

OK
I2P_ERROR
INVALID_ID

If the result is not OK, the socket is closed immediately by the SAM
bridge. If the result is OK, the SAM bridge starts waiting for an
incoming connection request from another I2P peer. When a request
arrives, the SAM bridge accepts it and:

If SILENT=true was passed, the SAM bridge won't issue any other message
on the client socket. All remaining data passing through the
current socket is forwarded from and to the connected I2P destination
peer.

If SILENT=false was passed, which is the default value, the SAM bridge
sends the client a ASCII line containing the base64 public destination key
of the requesting peer, and additional information for SAM 3.2 only:

Forward Request

This makes the session ${nickname} listen for incoming
connection requests from the I2P network.
FORWARD is not allowed while there is a pending ACCEPT on the session.

Forward Response

SILENT defaults to false.
Whether SILENT is true or false,
the SAM bridge always answers with a STREAM STATUS message.
Note that this is a different behavior from STREAM ACCEPT and STREAM CONNECT
when SILENT=true.
The STREAM STATUS message is:

<- STREAM STATUS
RESULT=$result
[MESSAGE=...]

The RESULT value may be one of:

OK
I2P_ERROR
INVALID_ID

$host is the hostname or IP address of the socket server to which
SAM will forward connection requests. If not given, SAM takes the IP
of the socket that issued the forward command.

$port is the port number of the socket server to which SAM will
forward connection requests. It is mandatory.

When a connection request arrives from I2P, the SAM bridge requests a
socket connection from $host:$port. If it is accepted after no more
than 3 seconds, SAM will accept the connection from I2P, and then:

If SILENT=true was passed, all data passing through the obtained
current socket is forwarded from and to the connected I2P destination
peer.

If SILENT=false was passed, which is the default value, the SAM bridge
sends on the obtained socket an ASCII line containing the base64 public
destination key of the requesting peer, and additional information for SAM 3.2 only:

After this '\n' terminated line,
all remaining data passing through the socket is forwarded from and to
the connected I2P destination peer, until one of the sides closes the
socket.

As of SAM 3.2, if SSL=true is specified, the forwarding socket is over SSL/TLS.

The I2P router will stop listening to incoming connection requests as
soon as the "forwarding" socket is closed.

SAM Datagrams : Sending Repliable or Raw Datagrams

While I2P doesn't inherently contain a FROM address, for ease of use
an additional layer is provided as repliable datagrams - unordered
and unreliable messages of up to 31744 bytes that include a FROM
address (leaving up to 1KB for header material). This FROM address
is authenticated internally by SAM (making use of the destination's
signing key to verify the source) and includes replay prevention.

Minimum size is 1. For best delivery reliability, recommended maximum
size is approximately 11 KB.
Reliability is inversely proportional to message size, perhaps even exponentially.

After establishing a SAM session with STYLE=DATAGRAM or STYLE=RAW, the client can
send repliable or raw datagrams through SAM's UDP port (7655).

The first line of a datagram sent through this port must be in the
following format.
This is all on one line (space separated), shown on multiple lines for clarity:

The target is $destination, which is the base 64 of the Destination,
which is 516 or more base 64 characters (387 or more bytes in binary),
depending on signature type.

All options are per-datagram settings that override the defaults specified in the SESSION CREATE.

Version 3.3 options SEND_TAGS, TAG_THRESHOLD, EXPIRES, and SEND_LEASESET
will be passed to I2CP if supported. See the I2CP specification for details.
Support by the SAM server is optional, it will ignore these options if unsupported.

this line is '\n' terminated.

The first line will be discarded by SAM before sending the remaining
data of the message to the specified destination.

SAM Repliable Datagrams : Receiving a Datagram

Received datagrams are written by SAM on the socket from which the
datagram session was opened, if a forwarding PORT is not specified in the SESSION CREATE
command. This is the v1/v2-compatible way of receiving datagrams.

When a datagram arrives, the bridge delivers it to the client via the
message:

The source is $destination, which is the base 64 of the Destination,
which is 516 or more base 64 characters (387 or more bytes in binary),
depending on signature type.

The SAM bridge never exposes to the client the authentication headers
or other fields, merely the data that the sender provided. This
continues until the session is closed (by the client dropping the
connection).

SAM Datagrams : Forwarding Raw or Repliable Datagrams

When creating a datagram session, the client can ask SAM to forward
incoming messages to a specified ip:port. It does so by issuing the
CREATE command with PORT and HOST options:

$host is the hostname or IP address of the datagram server to
which SAM will forward datagrams. If not given, SAM takes the
IP of the socket that issued the forward command.

$port is the port number of the datagram server to which SAM
will forward datagrams.
If $port is not set, datagrams will NOT be forwarded, they will be received on the control socket,
in the v1/v2-compatible way.

Additional options given are passed to the I2P session
configuration if not interpreted by the SAM bridge (e.g.
outbound.length=0). These options are documented below..

Forwarded repliable datagrams are always prefixed with the destination.
When a repliable datagram arrives, the bridge sends to the specified host:port
a UDP packet containing the following data:

Forwarded raw datagrams are forwarded as-is
to the specified host:port without a prefix.
The UDP packet contains the following data:

$datagram_payload

As of SAM 3.2, when HEADER=true is specified in SESSION CREATE,
the forwarded raw datagram will be prepended with a header line as follows:

FROM_PORT=nnn
TO_PORT=nnn
PROTOCOL=nnn
\n
$datagram_payload

The $destination is the base 64 of the Destination,
which is 516 or more base 64 characters (387 or more bytes in binary),
depending on signature type.

SAM Anonymous (Raw) Datagrams

Squeezing the most out of I2P's bandwidth, SAM allows clients to send
and receive anonymous datagrams, leaving authentication and reply
information up to the client themselves. These datagrams are
unreliable and unordered, and may be up to 32768 bytes.

Minimum size is 1. For best delivery reliability, recommended maximum
size is approximately 11 KB.

After establishing a SAM session with STYLE=RAW, the client can
send anonymous datagrams through the SAM bridge exactly the same way
as sending repliable datagrams.

Both ways of receiving datagrams are also available for anonymous
datagrams.

Received datagrams are written by SAM on the socket from which the
datagram session was opened, if a forwarding PORT is not specified in the SESSION CREATE
command. This is the v1/v2-compatible way of receiving datagrams.

DATAGRAM SEND, RAW SEND (V1/V2 Compatible Datagram Handling)

In SAM V3, the preferred way to send datagrams is via the datagram socket
at port 7655 as documented above. However, repliable datagrams may be sent
directly via the SAM bridge socket using the DATAGRAM SEND command,
as documented in SAM V1 and SAM V2.

As of release 0.9.14 (version 3.1), anonymous datagrams may be sent
directly via the SAM bridge socket using the RAW SEND command,
as documented in SAM V1 and SAM V2.

As of release 0.9.24 (version 3.2), DATAGRAM SEND and RAW SEND may include
the parameters FROM_PORT=nnnn and/or TO_PORT=nnnn to override the default ports.
As of release 0.9.24 (version 3.2), RAW SEND may include
the parameter PROTOCOL=nnn to override the default protocol.

These commands do not support the ID parameter. The datagrams are
sent to the most recently created DATAGRAM- or RAW-style session,
as appropriate. Support for the ID parameter may be added in a future release.

MASTER Sessions (V3.3 and higher)

Version 3.3 was introduced in I2P release 0.9.25.

SAM v3.3 adds support for running streaming, datagrams, and raw subsessions on the same
master session, and for running multiple subsessions of the same style.
All subsession traffic uses a single destination, or set of tunnels.
Routing of traffic from I2P is based on the port and protocol options for the subsessions.

To create multiplexed subsessions, you must create a master session
and then add subsessions to the master session.
Each subsession must have a unique id and a unique listen protocol and port.
Subsessions may also be removed from the master session.

With a MASTER session and a combination of subsessions, a SAM client
may support multiple applications, or a single sophisticated application
using a variety of protcols, on a single set of tunnels.
For example, a bittorrent client could set up a streaming subsession
for peer-to-peer connections, together with datagram and raw subsessions
for DHT communication.

Do not set the PORT, HOST, FROM_PORT, TO_PORT, PROTOCOL, LISTEN_PORT, LISTEN_PROTOCOL, or HEADER options on a master session.
You may not send any data on a MASTER session ID or on the control socket. All commands such as
STREAM CONNECT, DATAGRAM SEND, etc. must use the subsession ID on a separate socket.

The MASTER session connects to the router and builds tunnels. When the SAM bridge responds,
tunnels have been built and the session is ready for subsessions to be added.
All I2CP options pertaining to tunnel parameters such as length, quantity, and nickname must
be provided in the master's SESSION CREATE.

All utility commands are supported on a master session.

When the master session is closed, all subsessions get closed also.

Creating a Subsession

Using the same control socket on which the MASTER session was created:

The SAM bridge will respond with success or failure as in the response to a standard SESSION CREATE.
As the tunnels were already built in the master SESSION CREATE, the SAM bridge should respond immediately.

Do not set the DESTINATION option on a SESSION ADD.
The subsession will use the destination specified in the master session.
All subsessions must be added on the control socket, i.e. the same connection that you created the master session on.

Multiple subsessions must have options sufficiently unique
that incoming data can be routed correctly.
In particular, multiple sessions of the same style must have
different LISTEN_PORT options (and/or LISTEN_PROTOCOL, for RAW only).
A SESSION ADD with listen port and protocol that duplicates an existing subsession will result in an error.

The LISTEN_PORT is the local I2P port, i.e. the receive (TO) port for
incoming data.
If the LISTEN_PORT is not specified, the FROM_PORT value will be used.
If the LISTEN_PORT and FROM_PORT are not specified, incoming routing will be based on
STYLE and PROTOCOL alone.
For LISTEN_PORT and LISTEN_PROTOCOL, 0 means any value, that is, a wildcard.
If both LISTEN_PORT and LISTEN_PROTOCOL are 0,
this subsession will be the default for incoming traffic that does not get routed to another subsession.
Incoming streaming traffic (protocol 6) will never be routed to a RAW subsession, even if its LISTEN_PROTCOL is 0.
A RAW subsession may not set a LISTEN_PROTOCOL of 6.
If there is no default or subsession that matching the protocol and port of incoming traffic, that data will be dropped.

Use the subsession ID, not the master session ID, for sending and receiving data.
All commands such as STREAM CONNECT, DATAGRAM SEND, etc.
must use the subsession ID.

All utility commands are supported on a master session or subsession.
v1/v2 datagram/raw sending/receiving are not supported on a master session or on subsessions.

Stopping a Subsession

Using the same control socket on which the MASTER session was created:

-> SESSION REMOVE
ID=$nickname

This removes a subsession from the master session.
Do not set any other options on a SESSION REMOVE.
Subsessions must be removed on the control socket, i.e. the same connection that you created the master session on.
After a subsession is removed, it is closed and may not be used to send or receive data.

If NAME=ME, then the reply will contain the destination used by the
current session (useful if you're using a TRANSIENT one). If $result
is not OK, MESSAGE may convey a descriptive message, such as "bad
format", etc.
INVALID_KEY implies that something is wrong with $name in the request,
possibly invalid characters.

The $destination is the base 64 of the Destination,
which is 516 or more base 64 characters (387 or more bytes in binary),
depending on signature type.

NAMING LOOKUP does not require that a session has been created first.
However, in some implementations, a .b32.i2p lookup which is uncached and requires
a network query may fail, as no client tunnels are available for the lookup.

Destination Key Generation

Public and private base64 keys can be generated using the following
message:

As of version 3.1 (I2P 0.9.14), an optional parameter SIGNATURE_TYPE is supported.
The SIGNATURE_TYPE value may be any name (e.g. ECDSA_SHA256_P256, case insensitive) or number (e.g. 1)
that is supported by Key Certificates.
The default is DSA_SHA1.

The $destination is the base 64 of the Destination,
which is 516 or more base 64 characters (387 or more bytes in binary),
depending on signature type.

PING/PONG (SAM 3.2 or higher)

to be used for control socket keepalive.
Either side may close the session and socket if no response is received in a reasonable time, implementation dependent.

If a timeout occurs waiting for a PONG from the client, the bridge may send:

<- SESSION STATUS RESULT=I2P_ERROR MESSAGE=$message

and then disconnect.

If a timeout occurs waiting for a PONG from the bridge, the client may simply disconnect.

PING/PONG do not require that a session has been created first.

QUIT/STOP/EXIT (SAM 3.2 or higher, optional features)

Commands QUIT, STOP and EXIT will close the session and socket.
Implementation is optional, for ease in testing via telnet.
Whether there is any response before the socket is closed
(for example, a SESSION STATUS message) is
implementation-specific and outside the scope of this specification.

QUIT/STOP/EXIT do not require that a session has been created first.

HELP (optional feature)

Servers may implement a HELP command.
Implementation is optional, for ease in testing via telnet.
Output format and detection of the end of the output is
implementation-specific and outside the scope of this specification.

HELP does not require that a session has been created first.

Authorization Configuration (SAM 3.2 or higher, optional feature)

Authorization configuration using the AUTH command.
A SAM server may implement these commands to facilite persistent storage of credentials.
Configuration of authentication other than with these commands is
implementation-specific and outside the scope of this specification.

AUTH ENABLE enables authorization on subsequent connections

AUTH DISABLE disables authorization on subsequent connections

AUTH ADD USER="foo" PASSWORD="bar" adds a user/password

AUTH REMOVE USER="foo" removes this user

Double quotes for user and password are recommended but not required.
A double quote inside a user or password must be escaped with a backslash.
On failure the server will reply with an I2P_ERROR and a message.

AUTH does not require that a session has been created first.

RESULT Values

These are the values that can be carried by the RESULT field, with
their meaning:

OK Operation completed successfully
CANT_REACH_PEER The peer exists, but cannot be reached
DUPLICATED_DEST The specified Destination is already in use
I2P_ERROR A generic I2P error (e.g. I2CP disconnection, etc.)
INVALID_KEY The specified key is not valid (bad format, etc.)
KEY_NOT_FOUND The naming system can't resolve the given name
PEER_NOT_FOUND The peer cannot be found on the network
TIMEOUT Timeout while waiting for an event (e.g. peer answer)

Tunnel, I2CP, and Streaming Options

These options may be passed in as name=value pairs at the end of a
SAM SESSION CREATE line.

BASE 64 Notes

Client Library Implementations

Client libraries are available for C, C++, C#, Perl, and Python.
These are in the apps/sam/ directory in the I2P Source Package.
Some may be older and have not been updated for SAMv3 support.

Default SAM Setup

The default SAM port is 7656. SAM is not enabled by default in the Java I2P Router;
it must be started manually, or configured to start automatically,
on the configure clients page in the router console, or in the clients.config file.
The default SAM UDP port is 7655, listening on 127.0.0.1.
These may be changed by adding the arguments sam.udp.port=nnnnn and/or
sam.udp.host=w.x.y.z to the invocation.