OpenSolaris_b135/lib/libsip/common/sip_itf.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <string.h>
#include <strings.h>
#include <stdlib.h>
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <pthread.h>
#include <sip.h>
#include "sip_msg.h"
#include "sip_miscdefs.h"
#include "sip_xaction.h"
#include "sip_dialog.h"
#include "sip_parse_generic.h"
void (*sip_ulp_recv)(const sip_conn_object_t, sip_msg_t,
const sip_dialog_t) = NULL;
uint_t (*sip_stack_timeout)(void *, void (*func)(void *),
struct timeval *) = NULL;
boolean_t (*sip_stack_untimeout)(uint_t) = NULL;
int (*sip_stack_send)(sip_conn_object_t xonn_object, char *, int) =
NULL;
void (*sip_refhold_conn)(sip_conn_object_t) = NULL;
void (*sip_refrele_conn)(sip_conn_object_t) = NULL;
boolean_t (*sip_is_conn_stream)(sip_conn_object_t) = NULL;
boolean_t (*sip_is_conn_reliable)(sip_conn_object_t) = NULL;
int (*sip_conn_rem_addr)(sip_conn_object_t, struct sockaddr *,
socklen_t *) = NULL;
int (*sip_conn_local_addr)(sip_conn_object_t, struct sockaddr *,
socklen_t *) = NULL;
int (*sip_conn_transport)(sip_conn_object_t) = NULL;
int (*sip_conn_timer1)(sip_conn_object_t) = NULL;
int (*sip_conn_timer2)(sip_conn_object_t) = NULL;
int (*sip_conn_timer4)(sip_conn_object_t) = NULL;
int (*sip_conn_timerd)(sip_conn_object_t) = NULL;
boolean_t sip_manage_dialog = B_FALSE;
uint64_t sip_hash_salt = 0;
/*
* Defaults, overridden by configured values, if any
*/
int sip_timer_T1 = SIP_TIMER_T1;
int sip_timer_T2 = SIP_TIMER_T2;
int sip_timer_T4 = SIP_TIMER_T4;
int sip_timer_TD = 32 * SIP_SECONDS;
/*
* list of sent-by values registered by the UA
*/
sent_by_list_t *sip_sent_by = NULL;
int sip_sent_by_count = 0;
pthread_mutex_t sip_sent_by_lock;
/*
* Create and send an error response
*/
static void
sip_send_resp(sip_conn_object_t conn_obj, _sip_msg_t *sip_msg, int resp)
{
_sip_msg_t *sip_msg_resp;
sip_msg_resp = (_sip_msg_t *)sip_create_response((sip_msg_t)sip_msg,
resp, sip_get_resp_desc(resp), NULL, NULL);
if (sip_msg_resp == NULL) {
/*
* Message was too bad to even create a
* response. Just drop the messge.
*/
return;
}
/*
* We directly send it to the transport here.
*/
if (sip_adjust_msgbuf(sip_msg_resp) != 0) {
sip_free_msg((sip_msg_t)sip_msg_resp);
return;
}
SIP_UPDATE_COUNTERS(B_FALSE, 0, resp, B_TRUE, sip_msg_resp->
sip_msg_len);
(void) sip_stack_send(conn_obj, sip_msg_resp->sip_msg_buf,
sip_msg_resp->sip_msg_len);
sip_free_msg((sip_msg_t)sip_msg_resp);
}
/*
* Validate some of the common headers
*/
boolean_t
sip_check_common_headers(sip_conn_object_t conn_obj, _sip_msg_t *sip_msg)
{
int err;
if (sip_get_to_uri_str((sip_msg_t)sip_msg, &err) == NULL)
goto error;
if (sip_get_from_uri_str((sip_msg_t)sip_msg, &err) == NULL)
goto error;
if (sip_get_callseq_num((sip_msg_t)sip_msg, &err) < 0)
goto error;
if (sip_get_callid((sip_msg_t)sip_msg, &err) == NULL)
goto error;
return (B_FALSE);
error:
sip_send_resp(conn_obj, sip_msg, SIP_BAD_REQUEST);
return (B_TRUE);
}
/*
* setup pointers to where the headers are.
*/
static int
sip_setup_header_pointers(_sip_msg_t *sip_msg)
{
char *msg;
_sip_header_t *sip_msg_header;
char *end;
msg = sip_msg->sip_msg_buf;
end = sip_msg->sip_msg_buf + sip_msg->sip_msg_len;
/*
* Skip while space.
*/
while (isspace(*msg)) {
if (msg < end)
msg++;
else
return (EINVAL);
}
/*
* We consider Request and Response line as a header
*/
for (;;) {
/*
* Skip CRLF
*/
if (strncmp(SIP_CRLF, msg, strlen(SIP_CRLF)) == 0) {
if (sip_msg->sip_msg_headers_end != NULL) {
SKIP_CRLF(msg);
sip_msg->sip_msg_headers_end->sip_hdr_end = msg;
}
/*
* Start of a header.
* Check for empty line.
*/
if (strncmp(SIP_CRLF, msg, strlen(SIP_CRLF)) == 0) {
/*
* empty line, start of content.
*/
SKIP_CRLF(msg);
sip_msg->sip_msg_headers_end->sip_hdr_end = msg;
break;
}
/*
* store start of header.
*/
sip_msg_header = calloc(1, sizeof (_sip_header_t));
if (sip_msg_header == NULL)
return (EINVAL);
sip_msg_header->sip_hdr_start = msg;
sip_msg_header->sip_hdr_current = msg;
sip_msg_header->sip_hdr_allocated = B_FALSE;
sip_msg_header->sip_hdr_prev =
sip_msg->sip_msg_headers_end;
sip_msg_header->sip_hdr_next = NULL;
sip_msg_header->sip_hdr_sipmsg = sip_msg;
sip_msg->sip_msg_headers_end->sip_hdr_next =
sip_msg_header;
sip_msg->sip_msg_headers_end = sip_msg_header;
} else {
if (sip_msg->sip_msg_headers_start == NULL) {
/*
* Allocate first header structure.
*/
sip_msg_header = calloc(1,
sizeof (_sip_header_t));
if (sip_msg_header == NULL)
return (EINVAL);
sip_msg_header->sip_hdr_allocated = B_FALSE;
sip_msg_header->sip_hdr_start = msg;
sip_msg_header->sip_hdr_current = msg;
sip_msg_header->sip_hdr_sipmsg = sip_msg;
sip_msg->sip_msg_headers_start = sip_msg_header;
sip_msg->sip_msg_headers_end = sip_msg_header;
}
msg++;
}
/*
* We have reached the end without hitting the empty line.
*/
if (msg - sip_msg->sip_msg_buf >= sip_msg->sip_msg_len)
return (EINVAL);
}
if (sip_msg->sip_msg_headers_start == NULL)
return (EPROTO);
/*
* Move start line to be a separate line.
*/
sip_msg->sip_msg_start_line = sip_msg->sip_msg_headers_start;
sip_msg->sip_msg_headers_start =
sip_msg->sip_msg_headers_start->sip_hdr_next;
sip_msg->sip_msg_start_line->sip_hdr_prev = NULL;
sip_msg->sip_msg_start_line->sip_hdr_next = NULL;
if (sip_msg->sip_msg_headers_start == NULL)
return (EINVAL);
sip_msg->sip_msg_headers_start->sip_hdr_prev = NULL;
/*
* Deal with content.
*/
sip_msg->sip_msg_content = calloc(1, sizeof (sip_content_t));
sip_msg->sip_msg_content->sip_content_start = msg;
sip_msg->sip_msg_content->sip_content_end = sip_msg->sip_msg_buf +
sip_msg->sip_msg_len;
sip_msg->sip_msg_content->sip_content_allocated = B_FALSE;
sip_msg->sip_msg_content_len =
sip_msg->sip_msg_content->sip_content_end -
sip_msg->sip_msg_content->sip_content_start;
return (0);
}
/*
* The send interface to the sip stack. Used by upper layers.
*/
int
sip_sendmsg(sip_conn_object_t obj, sip_msg_t sip_msg, sip_dialog_t dialog,
uint32_t flags)
{
sip_xaction_t *sip_trans = NULL;
int ret = 0;
sip_message_type_t *sip_msg_info;
_sip_msg_t *_sip_msg;
boolean_t stateful = flags & SIP_SEND_STATEFUL;
boolean_t dlg_on_fork = flags & SIP_DIALOG_ON_FORK;
sip_refhold_conn(obj);
_sip_msg = (_sip_msg_t *)sip_msg;
if ((ret = sip_adjust_msgbuf(_sip_msg)) != 0) {
sip_refrele_conn(obj);
return (ret);
}
assert(_sip_msg->sip_msg_req_res != NULL);
sip_msg_info = _sip_msg->sip_msg_req_res;
/*
* Send it statefully if:
* if stateful is set in 'flags' AND
* this is not an ACK request, if it is a request (should the upper
* layer set stateful in the latter case?, i.e is the check
* necessary here?)
*/
if (stateful && (!sip_msg_info->is_request ||
sip_msg_info->sip_req_method != ACK)) {
sip_trans = (sip_xaction_t *)sip_xaction_get(obj, sip_msg,
B_TRUE, sip_msg_info->is_request ? SIP_CLIENT_TRANSACTION :
SIP_SERVER_TRANSACTION, &ret);
if (sip_trans == NULL) {
sip_refrele_conn(obj);
return (ret);
}
ret = sip_xaction_output(obj, sip_trans, _sip_msg);
SIP_XACTION_REFCNT_DECR(sip_trans);
if (ret != 0) {
sip_refrele_conn(obj);
return (ret);
}
}
/*
* If the appln wants us to create the dialog, create a partial
* dialog at this stage, when we get the response, we will
* complete it.
*/
if (sip_manage_dialog) {
if (sip_msg_info->is_request && dialog == NULL) {
dialog = (sip_dialog_t)sip_seed_dialog(obj, sip_msg,
dlg_on_fork, SIP_UAC_DIALOG);
} else if (dialog != NULL && (!sip_msg_info->is_request ||
sip_msg_info->sip_req_method == NOTIFY)) {
(void) sip_update_dialog(dialog, _sip_msg);
} else if (dialog != NULL) {
/*
* Dialog is in CONFIRMED state. If logging is enabled
* track the SIP message sent within a dialog.
*/
(void) pthread_mutex_lock(&dialog->sip_dlg_mutex);
dialog->sip_dlg_msgcnt++;
sip_add_log(&dialog->sip_dlg_log[dialog->sip_dlg_state],
(sip_msg_t)sip_msg, dialog->sip_dlg_msgcnt,
SIP_DIALOG_LOG);
(void) pthread_mutex_unlock(&dialog->sip_dlg_mutex);
if (sip_msg_info->is_request && sip_msg_info->
sip_req_method == INVITE) {
(void) sip_dialog_add_new_contact(dialog,
_sip_msg);
}
}
}
/*
* if measure sip traffic is enabled, capture the measurements
* Is this the right place to measure or should I put this after
* the call to sip_stack_send()
*/
if (sip_msg_info->is_request) {
SIP_UPDATE_COUNTERS(B_TRUE, sip_msg_info->sip_req_method, 0,
B_TRUE, _sip_msg->sip_msg_len);
} else {
SIP_UPDATE_COUNTERS(B_FALSE, 0, sip_msg_info->sip_resp_code,
B_TRUE, _sip_msg->sip_msg_len);
}
if ((ret = sip_stack_send(obj, _sip_msg->sip_msg_buf,
_sip_msg->sip_msg_len)) != 0) {
if (sip_trans != NULL) {
sip_xaction_terminate(sip_trans, _sip_msg,
sip_conn_transport(obj));
}
sip_refrele_conn(obj);
return (ret);
}
sip_refrele_conn(obj);
return (ret);
}
/*
* Given a sent-by value check if it is in the registered list. If no values
* have been registered, the check passes.
*/
static boolean_t
sip_sent_by_registered(const sip_str_t *sb_val)
{
sent_by_list_t *sb;
int count = 0;
(void) pthread_mutex_lock(&sip_sent_by_lock);
if (sip_sent_by == NULL) {
(void) pthread_mutex_unlock(&sip_sent_by_lock);
return (B_TRUE);
}
sb = sip_sent_by;
for (count = 0; count < sip_sent_by_count; count++) {
if (strncasecmp(sb->sb_val, sb_val->sip_str_ptr,
sb_val->sip_str_len) == 0) {
(void) pthread_mutex_unlock(&sip_sent_by_lock);
return (B_TRUE);
}
sb = sb->sb_next;
}
(void) pthread_mutex_unlock(&sip_sent_by_lock);
return (B_FALSE);
}
/*
* Given a response, check if the sent-by in the VIA header is valid.
*/
boolean_t
sip_valid_sent_by(sip_msg_t sip_msg)
{
sip_header_t via;
sip_header_value_t value = NULL;
int error;
const sip_str_t *sent_by = NULL;
via = (sip_header_t)sip_get_header(sip_msg, SIP_VIA, NULL, &error);
if (via == NULL || error != 0)
return (B_TRUE);
value = (sip_header_value_t)sip_get_header_value(via, &error);
if (value == NULL || error != 0)
return (B_TRUE);
sent_by = sip_get_via_sent_by_host(value, &error);
if (sent_by == NULL || error != 0)
return (B_TRUE);
if (sip_sent_by_registered(sent_by))
return (B_TRUE);
return (B_FALSE);
}
/*
* The receive interface to the transport layer.
*/
void
sip_process_new_packet(sip_conn_object_t conn_object, void *msgstr,
size_t msglen)
{
_sip_msg_t *sip_msg;
sip_message_type_t *sip_msg_info;
sip_xaction_t *sip_trans;
sip_dialog_t dialog = NULL;
boolean_t dialog_created = B_FALSE;
int transport;
char *msgbuf = NULL;
sip_refhold_conn(conn_object);
transport = sip_conn_transport(conn_object);
if (transport == IPPROTO_TCP) {
next_msg:
msgstr = (char *)sip_get_tcp_msg(conn_object, (char *)msgstr,
&msglen);
if (msgstr == NULL) {
sip_refrele_conn(conn_object);
return;
}
} else {
msgbuf = (char *)malloc(msglen + 1);
if (msgbuf == NULL) {
sip_refrele_conn(conn_object);
return;
}
(void) strncpy(msgbuf, msgstr, msglen);
msgbuf[msglen] = '\0';
msgstr = msgbuf;
}
sip_msg = (_sip_msg_t *)sip_new_msg();
if (sip_msg == NULL) {
if (msgbuf != NULL)
free(msgbuf);
sip_refrele_conn(conn_object);
return;
}
sip_msg->sip_msg_buf = (char *)msgstr;
sip_msg->sip_msg_len = msglen;
(void) pthread_mutex_lock(&sip_msg->sip_msg_mutex);
if (sip_setup_header_pointers(sip_msg) != 0) {
(void) pthread_mutex_unlock(&sip_msg->sip_msg_mutex);
sip_refrele_conn(conn_object);
sip_free_msg((sip_msg_t)sip_msg);
return;
}
if (sip_parse_first_line(sip_msg->sip_msg_start_line,
&sip_msg->sip_msg_req_res)) {
(void) pthread_mutex_unlock(&sip_msg->sip_msg_mutex);
sip_refrele_conn(conn_object);
sip_free_msg((sip_msg_t)sip_msg);
return;
}
sip_msg_info = sip_msg->sip_msg_req_res;
(void) pthread_mutex_unlock(&sip_msg->sip_msg_mutex);
if (sip_check_common_headers(conn_object, sip_msg)) {
sip_refrele_conn(conn_object);
sip_free_msg((sip_msg_t)sip_msg);
return;
}
/*
* Silently discard the response if the top VIA has a sent-by value AND
* the UA has registered sent-by values AND the one in the VIA is
* not part of the registerd sent-by values.
*/
if (!sip_msg_info->is_request && !sip_valid_sent_by(sip_msg)) {
sip_refrele_conn(conn_object);
sip_free_msg((sip_msg_t)sip_msg);
return;
}
sip_trans = (sip_xaction_t *)sip_xaction_get(conn_object,
(sip_msg_t)sip_msg,
B_FALSE, sip_msg_info->is_request ? SIP_SERVER_TRANSACTION :
SIP_CLIENT_TRANSACTION, NULL);
if (sip_trans != NULL) {
if (sip_xaction_input(conn_object, sip_trans, &sip_msg) != 0) {
SIP_XACTION_REFCNT_DECR(sip_trans);
sip_refrele_conn(conn_object);
sip_free_msg((sip_msg_t)sip_msg);
return;
}
SIP_XACTION_REFCNT_DECR(sip_trans);
/*
* msg was retransmission - handled by the transaction
*/
if (sip_msg == NULL)
goto check_next;
} else {
/*
* If we are getting an INVITE request, let us send a
* 100 TRYING response here, as in 17.2.1:
* "The server transaction MUST generate a 100 (Trying)
* response unless it knows that the TU will generate a
* provisional or final response within 200 ms".
*/
if (sip_msg_info->is_request &&
sip_msg_info->sip_req_method == INVITE) {
sip_send_resp(conn_object, sip_msg, SIP_TRYING);
}
}
if (sip_manage_dialog) {
dialog = sip_dialog_find(sip_msg);
if (dialog == NULL) {
if (sip_msg_info->is_request) {
/*
* sip_seed_dialog will check for the
* method in the request
*/
dialog = (sip_dialog_t)sip_seed_dialog(
conn_object, sip_msg,
B_FALSE, SIP_UAS_DIALOG);
dialog_created = B_TRUE;
}
} else if (sip_incomplete_dialog(dialog)) {
if (!sip_msg_info->is_request ||
sip_msg_info->sip_req_method == NOTIFY) {
dialog = sip_update_dialog(dialog, sip_msg);
}
} else if (sip_dialog_process(sip_msg, &dialog) != 0) {
if (dialog != NULL)
sip_release_dialog(dialog);
/*
* cseq number in error, send a
* SIP_SERVER_INTERNAL_ERROR response.
*/
if (sip_msg_info->is_request) {
sip_send_resp(conn_object, sip_msg,
SIP_SERVER_INTERNAL_ERROR);
}
sip_refrele_conn(conn_object);
sip_free_msg((sip_msg_t)sip_msg);
return;
}
}
if (sip_msg_info->is_request) {
SIP_UPDATE_COUNTERS(B_TRUE, sip_msg_info->sip_req_method, 0,
B_FALSE, sip_msg->sip_msg_len);
} else {
SIP_UPDATE_COUNTERS(B_FALSE, 0, sip_msg_info->sip_resp_code,
B_FALSE, sip_msg->sip_msg_len);
}
sip_ulp_recv(conn_object, (sip_msg_t)sip_msg, dialog);
sip_free_msg((sip_msg_t)sip_msg);
if (dialog != NULL && !dialog_created)
sip_release_dialog(dialog);
check_next:
/*
* Check if there are more complete messages in the TCP fragment list
* to be consumed
*/
if (transport == IPPROTO_TCP) {
msgstr = NULL;
msglen = 0;
goto next_msg;
}
sip_refrele_conn(conn_object);
}
/*
* Initialize the stack. The connection manager functions, upper layer
* receive functions are mandatory.
*/
int
sip_stack_init(sip_stack_init_t *stack_val)
{
#ifdef __linux__
struct timespec tspec;
#endif
/*
* If the stack has already been configured, return error
*/
if (sip_stack_send != NULL ||
stack_val->sip_version != SIP_STACK_VERSION) {
return (EINVAL);
}
if (stack_val->sip_io_pointers == NULL ||
stack_val->sip_ulp_pointers == NULL) {
return (EINVAL);
}
sip_ulp_recv = stack_val->sip_ulp_pointers->sip_ulp_recv;
sip_manage_dialog = stack_val->sip_stack_flags & SIP_STACK_DIALOGS;
sip_stack_send = stack_val->sip_io_pointers->sip_conn_send;
sip_refhold_conn = stack_val->sip_io_pointers->sip_hold_conn_object;
sip_refrele_conn = stack_val->sip_io_pointers->sip_rel_conn_object;
sip_is_conn_stream = stack_val->sip_io_pointers->sip_conn_is_stream;
sip_is_conn_reliable = stack_val->sip_io_pointers->sip_conn_is_reliable;
sip_conn_rem_addr = stack_val->sip_io_pointers->sip_conn_remote_address;
sip_conn_local_addr =
stack_val->sip_io_pointers->sip_conn_local_address;
sip_conn_transport = stack_val->sip_io_pointers->sip_conn_transport;
sip_header_function_table_external = stack_val->sip_function_table;
if (sip_ulp_recv == NULL || sip_stack_send == NULL ||
sip_refhold_conn == NULL || sip_refrele_conn == NULL ||
sip_is_conn_stream == NULL || sip_is_conn_reliable == NULL ||
sip_conn_rem_addr == NULL || sip_conn_local_addr == NULL ||
sip_conn_transport == NULL) {
err_ret:
sip_ulp_recv = NULL;
sip_stack_send = NULL;
sip_refhold_conn = NULL;
sip_refrele_conn = NULL;
sip_is_conn_stream = NULL;
sip_is_conn_reliable = NULL;
sip_conn_rem_addr = NULL;
sip_conn_local_addr = NULL;
sip_conn_transport = NULL;
sip_header_function_table_external = NULL;
sip_stack_timeout = NULL;
sip_stack_untimeout = NULL;
return (EINVAL);
}
sip_conn_timer1 = stack_val->sip_io_pointers->sip_conn_timer1;
sip_conn_timer2 = stack_val->sip_io_pointers->sip_conn_timer2;
sip_conn_timer4 = stack_val->sip_io_pointers->sip_conn_timer4;
sip_conn_timerd = stack_val->sip_io_pointers->sip_conn_timerd;
/*
* Use Appln timeout routines, if provided
*/
if (stack_val->sip_ulp_pointers->sip_ulp_timeout != NULL) {
if (stack_val->sip_ulp_pointers->sip_ulp_untimeout == NULL)
goto err_ret;
sip_stack_timeout =
stack_val->sip_ulp_pointers->sip_ulp_timeout;
sip_stack_untimeout =
stack_val->sip_ulp_pointers->sip_ulp_untimeout;
} else {
if (stack_val->sip_ulp_pointers->sip_ulp_untimeout != NULL)
goto err_ret;
sip_timeout_init();
sip_stack_timeout = sip_timeout;
sip_stack_untimeout = sip_untimeout;
}
/*
* Manage Dialogs?
*/
if (sip_manage_dialog) {
sip_dialog_init(stack_val->sip_ulp_pointers->sip_ulp_dlg_del,
stack_val->sip_ulp_pointers->sip_ulp_dlg_state_cb);
}
sip_xaction_init(stack_val->sip_ulp_pointers->sip_ulp_trans_error,
stack_val->sip_ulp_pointers->sip_ulp_trans_state_cb);
/*
* Initialize SIP traffic counter mutex
*/
(void) pthread_mutex_init(&sip_counters.sip_counter_mutex, NULL);
/*
* Initialize SIP logfile structures mutex
*/
(void) pthread_mutex_init(&trans_log.sip_logfile_mutex, NULL);
(void) pthread_mutex_init(&dialog_log.sip_logfile_mutex, NULL);
#ifdef __linux__
if (clock_gettime(CLOCK_REALTIME, &tspec) != 0)
goto err_ret;
sip_hash_salt = tspec.tv_nsec;
#else
sip_hash_salt = gethrtime();
#endif
(void) pthread_mutex_init(&sip_sent_by_lock, NULL);
return (0);
}