NTA also uses SIP message objects msg_t and sip_t for handling messages, as defined in <sofia-sip/msg.h> and <sofia-sip/sip.h>, respectively. The various SIP headers are also defined in <sofia-sip/sip.h>.
The nta_agent_t object is created by calling nta_agent_create(). The object listens for incoming connections, receives messages, parses them, and pass them to the application. It also takes care of resolving the domain names and sending the messages.
The agent needs a su_root_t object to schedule its execution. A root object is used to wait for the network events, schedule the timer routines, and pass messages asyncronously. A root object can be created by, e.g., the function su_root_create(). The root object can be have its own thread, or its main loop can be executed by an application thread by calling the function su_root_run(). The main loop can be terminated by calling the function su_root_break().
A simple agent could be created as follows:
registrar->reg_root = su_root_create(NULL); if (registrar->reg_root) { registrar->reg_agent = nta_agent_create(registrar->reg_root, (url_string_t*)argv[1], NULL, NULL, NULL); if (registrar->reg_agent) { su_root_run(registrar->reg_root); nta_agent_destroy(registrar->reg_agent); } su_root_destroy(registrar->reg_root); }
default_leg = nta_leg_tcreate(agent, process_requests, context, URLTAG_URL(url), NTATAG_NO_DIALOG(1), TAG_END());
The url parameter is used to specify which URLs match to the leg. If it is given, only requests with requestURI matching are processed by the leg. The nta_leg_tcreate() is a tagarg function, taking a tagged argument list as its arguments.
Other, ordinary legs can be used to match incoming requests with existing dialogs, calls or transaction contexts, or to provide outgoing requests with consistent headers. When a call leg is created, it is provided with From and To headers, and optionally with other headers like Call-ID, Route, or CSeq.
A new call leg can be created as follows:
call_leg = nta_leg_tcreate(agent, process_call_requests, call_context, SIPTAG_CALL_ID(sip->sip_call_id), SIPTAG_TO(sip->sip_from), SIPTAG_FROM(sip->sip_to), TAG_END());
An existing leg can be used in any direction, however. If the leg was created for an incoming INVITE transaction, it is also possible to use the leg for an outgoing BYE transaction.
if (!nta_leg_tag(leg, nta_incoming_tag(irq, NULL))) nta_incoming_treply(irq, SIP_500_INTERNAL_SERVER_ERROR, TAG_END());
The simplest way to reply to the request is to return a valid status code from the callback function. Valid status codes are in range of 100 to 699, inclusive. If no automatic response is desired, the callback function should return 0.
It is not possible to respond with a 2xx status code to an incoming INVITE transaction by returning the status code from the callback.
The simple registrar/redirect server may have a incoming request callback as follows:
int process_request(server_t *server, nta_leg_t *leg, nta_incoming_t *irq, sip_t const *sip) { sip_contact_t *m; switch (sip->sip_request->rq_method) { case sip_method_register: return registrar_add(server, leg, reply, sip); case sip_method_ack: return 500; case sip_method_cancel: return 200; default: if (registrar_find(server, sip->sip_request->rq_url, &m) { nta_incoming_treply(irq, SIP_302_MOVED_TEMPORARILY, SIPTAG_CONTACT(m), TAG_END()); return 302; } else { nta_incoming_treply(irq, SIP_404_NOT_FOUND, TAG_END()); return 404; } } }
The default reply message will contain the status line with default phrase, then Via, To, From, Call-ID, CSeq, and Content-Length headers. If a more complex response message is required, the application should respond using the function nta_incoming_treply():
nta_incoming_treply(reply, SIP_200_OK, SIPTAG_CONTACT(contact), SIPTAG_CONTENT_TYPE_STR("application/sdp"), SIPTAG_PAYLOAD(sdp), TAG_END());
The nta_incoming_treply() is a tagarg function, taking a tagged argument list as its argument.
Using reliable responses is negotiated using the "100rel" option tag. The UAC (party sending the INVITE) can include the option tag to the Supported or Require header. In the first case, the UAC just announces support for reliable responses, in the second case, the UAC requires that the UAS (party responding to the call) always sends provisional responses in reliable manner.
When reliable responses are enabled with NTATAG_REL100() tag, the nta engine automatically inserts the "100rel" option tag to the Supported header in the INVITE requests.
Both the functions nta_reliable_treply () and nta_reliable_mreply() take a callback funtion pointer and an application context pointer as their arguments. The callback function is similar to the leg callback function. The callback is invoked when a corresponding PRACK request is received, or when there is a timeout.
The nta takes care of assigning a serial number to each reliable response and resending them if no PRACK request is received. It also automatically adds the 100rel option tag to the Require header.
Also, if a request with 100rel in Require header is responded with usual nta_incoming_treply()/nta_incoming_mreply() functions, the nta creates a reliable response object for each provisional response in behalf of application. As the application can not provide a PRACK callback function to nta, the PRACK requests are not delivered to the application.
int invite_callback(call_t *call, nta_outgoing_t *orq, sip_t const *sip) { int status = sip->sip_status->st_status; if (!call->has_dialog && (status >= 200 || (status > 100 && sip->sip_rseq))) { nta_leg_t *early = nta_leg_tcreate(call->nta_agent, mid_dialog_request, call, SIPTAG_TO(sip->sip_to), SIPTAG_FROM(sip->sip_from), SIPTAG_CALL_ID(sip->sip_call_id), SIPTAG_CSEQ(sip->sip_cseq), TAG_END()); nta_leg_client_route(early, sip->sip_record_route, sip->sip_contact); fork = call_fork(call, leg = early); if (!fork) { handle error; } call = fork; }
The original dialog object and client transaction object are used to process other call forks. For instance, if the early dialog is established with an announcement server it will never lead to an fully established call, but an another dialog will be used when the call is completed.
context->leg = nta_leg_tcreate(agent, callback, context, SIPTAG_CALL_ID(call_id), SIPTAG_FROM(from), SIPTAG_TO(to), TAG_END());
The callback
function and context
pointer are used for incoming transactions, and they may be NULL
if no such transactions are expected. If the callback is NULL
, NTA responds to incoming transactions with status 403 Forbidden.
The call_id may be NULL
or left out. In that case, NTA generates a new call ID.
The from and to are used in outgoing transactions. They are also used to select which incoming messages belong to this leg.
The initial sequence number can be supplied with SIPTAG_CSEQ() (taking a CSeq structure as parameter).
The additional parameters (after to) are included in outgoing messages using this leg. Currently, only SIPTAG_ROUTE()
is supported.
oreq = nta_outgoing_tcreate(leg, response_to_register, reg, proxy_url, SIP_METHOD_REGISTER, registrar_url, SIPTAG_CONTACT(my_contact), TAG_END());
NTA invokes the callback function response_to_register() each time a provisional answer is received, and when a final answer is received.
The final answer can be acknowledged like this:
url = sip->sip_contact ? sip->sip_contact->m_url : original_url; ack = nta_outgoing_tcreate(leg, NULL, NULL, SIP_METHOD_ACK, (url_string_t*)url, SIPTAG_CSEQ(sip->sip_cseq), SIPTAG_PAYLOAD(sdp), TAG_END());
Before invoking the stateless callback the agent will try to match the incoming request message with an existing dialog or dialog-less leg (or default leg). So, if you have created a default leg, all request messages are processed statefully by it instead of being passed to the stateless callback function.
If you want to process request messages with stateless callback and still use dialog-less legs (for instance, in order to look up domains with nta_leg_by_uri()), you have to switch over to stateless mode by including NTATAG_STATELESS(1) in nta_agent_create() or nta_agent_set_params() arguments.
Also, if a response message does not match with an existing client transaction, the agent will try to use the default outgoing (client) transaction. If you have created an default outgoing transaction, all stray response messages are passed to it instead of the stateless processing function.
int process_message(nta_agent_context_t *registrar, nta_agent_t *agent, msg_t *msg, sip_t *sip);
The application has three functions that can be used to process the messages in stateless manner:
The functionality of the stateless callback function can vary greatly, depending the purpose of the application. An user-agent, a proxy or a registrar/redirect server each have very different callback functions.
A simple redirect server could have a message callback function as follows.
int process_message(redirect_t *r, nta_agent_t *agent, msg_t *msg, sip_t *sip) { sip_contact_t *m; sip_unsupported_t *u;
The incoming response messages are simply ignored. The ACK requests can safely be discarded, too, because the redirect server keeps no state.
if (!sip->sip_request || sip->sip_request->rq_method == sip_method_ack) { nta_msg_discard(agent, msg); return 0; }
Next, the redirect server first checks if processing the request requires a feature that is not supported by it:
u = sip_unsupported(msg_home(msg), sip->sip_require, r->r_supported); if (u) { nta_msg_treply(agent, msg, SIP_420_BAD_EXTENSION, SIPTAG_SUPPORTED(r->r_supported), SIPTAG_UNSUPPORTED(u), TAG_END()); return 0; }
The CANCEL requests terminate a transacton. A stateless redirect server does not have transactions, so it redirect replies with a 481 Call Leg/Transaction Does Not Exist message:
if (sip->sip_request->rq_method == sip_method_cancel) { nta_msg_treply(agent, msg, SIP_481_NO_TRANSACTION, TAG_END()); return 0; }
All other requests are answered normally with a 302 response. The location service is searched for the request uri, and if a matching address was found, a list of active bindings is returned to the client.
m = location_find(redirect, sip->sip_request->rq_url); if (m) { nta_msg_treply(agent, msg, SIP_302_MOVED_TEMPORARILY, SIPTAG_CONTACT(m), TAG_END()); }
Otherwise, 404 Not Found is sent:
else { nta_msg_treply(agent, msg, SIP_404_NOT_FOUND, TAG_END()); } return 0; }