Invoked to signal the availability of a peer connection. In particular, capabilities exchange with the peer has indicated support for the application in question, the RFC 3539 watchdog state machine for the connection has reached state OKAY and Diameter messages can be both sent and received.

Invoked to signal that a peer connection is no longer available following a previous call to &peer_up;. In particular, that the RFC 3539 watchdog state machine for the connection has left state OKAY and the peer will no longer be a candidate in &pick_peer; callbacks.

Invoked as a consequence of a call to &mod_call; to select a destination peer for an outgoing request. The return value indicates the selected peer.

The candidate list contains only those peers that have advertised support for the Diameter application in question during capabilities exchange, that have not be excluded by a filter option in the call to &mod_call; and whose watchdog state machine is in the OKAY state. The order of the elements is unspecified except that any peers whose Origin-Host and Origin-Realm matches that of the outgoing request (in the sense of a {filter, {all, [host, realm]}} option to &mod_call;) will be placed at the head of the list.

A callback that returns a peer() will be followed by a &prepare_request; callback and, if the latter indicates that the request should be sent, by either &handle_answer; or &handle_error; depending on whether or not an answer message is received from the peer. If the transport becomes unavailable after &prepare_request; then a new &pick_peer; callback may take place to failover to an alternate peer, after which &prepare_retransmit; takes the place of &prepare_request; in resending the request. There is no guarantee that a &pick_peer; callback to select an alternate peer will be followed by any additional callbacks since a retransmission to an alternate peer is abandoned if an answer is received from a previously selected peer.

Returning false or {false, NewState} causes {error, no_connection} to be returned from &mod_call;.

The return values false and {false, State} (that is, NewState = State) are equivalent, as are {ok, Peer} and {Peer, State}.

Invoked to return a request for encoding and transport. Allows the sender to use the selected peer's capabilities to modify the outgoing request. Many implementations may simply want to return {send, Packet}

A returned &packet; should set the request to be encoded in its msg field and can set the transport_data field in order to pass information to the transport process. Extra arguments passed to &mod_call; can be used to communicate transport (or any other) data to the callback.

A returned &packet; can set the header field to a #diameter_header{} to specify values that should be preserved in the outgoing request, values otherwise being those in the header record contained in Packet. A returned length, cmd_code or application_id is ignored.

A returned PostF will be evaluated on any encoded #diameter_packet{} prior to transmission, the bin field containing the encoded binary. The return value is ignored.

Returning {discard, Reason} causes the request to be aborted and the &mod_call; for which the callback has taken place to return {error, Reason}. Returning discard is equivalent to returning {discard, discarded}.

Invoked to return a request for encoding and retransmission. Has the same role as &prepare_request; in the case that a peer connection is lost an an alternate peer selected but the argument &packet; is as returned by the initial &prepare_request;.

Returning {discard, Reason} causes the request to be aborted and a &handle_error; callback to take place with Reason as initial argument. Returning discard is equivalent to returning {discard, discarded}.

Invoked when an answer message is received from a peer. The return value is returned from &mod_call; unless the detach option was specified.

The decoded answer record and undecoded binary are in the msg and bin fields of the argument &packet; respectively. Request is the outgoing request message as was returned from &prepare_request; or &prepare_retransmit;.

For any given call to &mod_call; there is at most one &handle_answer; callback: any duplicate answer (due to retransmission or otherwise) is discarded. Similarly, only one of &handle_answer; or &handle_error; is called.

By default, an incoming answer message that cannot be successfully decoded causes the request process to fail, causing &mod_call; to return {error, failure} unless the detach option was specified. In particular, there is no &handle_error; callback in this case. The &mod_application_opt; answer_errors can be set to change this behaviour.

Invoked when an error occurs before an answer message is received in response to an outgoing request. The return value is returned from &mod_call; unless the detach option was specified.

Reason timeout indicates that an answer message has not been received within the time specified with the corresponding &mod_call_opt;. Reason failover indicates that the transport connection to the peer to which the request has been sent has become unavailable and that not alternate peer was not selected.

Invoked when a request message is received from a peer. The application in which the callback takes place (that is, the callback module as configured with &mod_start_service;) is determined by the Application Identifier in the header of the incoming request message, the selected module being the one whose corresponding dictionary declares itself as defining either the application in question or the Relay application.

The argument &packet; has the following signature.

#diameter_packet{header = #diameter_header{},
                 avps   = [#diameter_avp{}],
                 msg    = record() | undefined,
                 errors = [&dict_Unsigned32; | {&dict_Unsigned32;, #diameter_avp{}}],
                 bin    = binary(),
                 transport_data = term()}

The msg field will be undefined in case the request has been received in the relay application. Otherwise it contains the record representing the request as outlined in &dict;.

The errors field specifies any Result-Code's identifying errors that were encountered in decoding the request. In this case diameter will set both Result-Code and Failed-AVP AVP's in a returned answer &message; before sending it to the peer: the returned &message; need only set any other required AVP's. Note that the errors detected by diameter are all of the 5xxx series (Permanent Failures). The errors list is empty if the request has been received in the relay application.

The transport_data field contains an arbitrary term passed into diameter from the transport module in question, or the atom undefined if the transport specified no data. The term is preserved if a &message; is returned but must be set explicitly in a returned &packet;.

The semantics of each of the possible return values are as follows.

{reply, ['answer-message' | Avps]

Note that protocol errors detected by diameter will result in an answer message without handle_request/3 being invoked.