sip_ui.c revision 2c2c41837e330b002c4220a39638150db504fe0e
/*
* 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 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <strings.h>
#include <pthread.h>
#include <sip.h>
#include "sip_msg.h"
#include "sip_miscdefs.h"
#include "sip_parse_uri.h"
#include "sip_xaction.h"
#define SIP_BUF_SIZE 128
/*
* Find the header named header, consecutive calls with old_header
* passed in will return next header of the same type.
* If no name is passed the first header is returned. consectutive calls
* with no name but an old header will return the next header.
*/
const struct sip_header *
sip_get_header(sip_msg_t sip_msg, char *header_name, sip_header_t old_header,
int *error)
{
_sip_msg_t *_sip_msg;
const struct sip_header *sip_hdr;
if (error != NULL)
*error = 0;
if (sip_msg == NULL) {
if (error != NULL)
*error = EINVAL;
return (NULL);
}
_sip_msg = (_sip_msg_t *)sip_msg;
(void) pthread_mutex_lock(&_sip_msg->sip_msg_mutex);
sip_hdr = (sip_header_t)sip_search_for_header((_sip_msg_t *)sip_msg,
header_name, (_sip_header_t *)old_header);
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
if (sip_hdr == NULL && error != NULL)
*error = EINVAL;
return (sip_hdr);
}
/*
* Return the request line as a string. Caller releases the returned string.
*/
char *
sip_reqline_to_str(sip_msg_t sip_msg, int *error)
{
char *reqstr;
if (error != NULL)
*error = 0;
if (sip_msg == NULL || !sip_msg_is_request(sip_msg, error)) {
if (error != NULL)
*error = EINVAL;
return (NULL);
}
reqstr = _sip_startline_to_str((_sip_msg_t *)sip_msg, error);
return (reqstr);
}
/*
* Return the response line as a string. Caller releases the returned string.
*/
char *
sip_respline_to_str(sip_msg_t sip_msg, int *error)
{
char *respstr;
if (error != NULL)
*error = 0;
if (sip_msg == NULL || sip_msg_is_request(sip_msg, error)) {
if (error != NULL)
*error = EINVAL;
return (NULL);
}
respstr = _sip_startline_to_str((_sip_msg_t *)sip_msg, error);
return (respstr);
}
/*
* return the first value of the header
*/
const struct sip_value *
sip_get_header_value(const struct sip_header *sip_header, int *error)
{
_sip_header_t *_sip_header;
sip_parsed_header_t *sip_parsed_header;
int ret = 0;
const struct sip_value *value;
if (error != NULL)
*error = 0;
if (sip_header == NULL) {
if (error != NULL)
*error = EINVAL;
return (NULL);
}
_sip_header = (_sip_header_t *)sip_header;
if (_sip_header->sip_hdr_sipmsg != NULL) {
(void) pthread_mutex_lock(
&_sip_header->sip_hdr_sipmsg->sip_msg_mutex);
}
if (_sip_header->sip_header_state == SIP_HEADER_DELETED) {
if (_sip_header->sip_hdr_sipmsg != NULL) {
(void) pthread_mutex_unlock(
&_sip_header->sip_hdr_sipmsg->sip_msg_mutex);
}
if (error != NULL)
*error = EINVAL;
return (NULL);
}
ret = _sip_header->sip_header_functions->header_parse_func(
_sip_header, &sip_parsed_header);
if (_sip_header->sip_hdr_sipmsg != NULL) {
(void) pthread_mutex_unlock
(&_sip_header->sip_hdr_sipmsg->sip_msg_mutex);
}
if (error != NULL)
*error = ret;
if (ret != 0)
return (NULL);
value = (sip_header_value_t)sip_parsed_header->value;
while (value != NULL && value->value_state == SIP_VALUE_DELETED)
value = value->next;
if (value != NULL && value->value_state == SIP_VALUE_BAD &&
error != NULL) {
*error = EPROTO;
}
return ((sip_header_value_t)value);
}
/*
* Return the next value of the header.
*/
const struct sip_value *
sip_get_next_value(sip_header_value_t old_value, int *error)
{
const struct sip_value *value;
if (error != NULL)
*error = 0;
if (old_value == NULL || old_value->next == NULL) {
if (error != NULL)
*error = EINVAL;
return (NULL);
}
/*
* We never free the deleted values so no need to hold a lock.
*/
value = (sip_header_value_t)old_value->next;
while (value != NULL && value->value_state == SIP_VALUE_DELETED)
value = value->next;
if (value != NULL && value->value_state == SIP_VALUE_BAD &&
error != NULL) {
*error = EPROTO;
}
return ((sip_header_value_t)value);
}
/*
* Given a SIP message, delete the header "header_name".
*/
int
sip_delete_header_by_name(sip_msg_t msg, char *header_name)
{
_sip_msg_t *_msg = (_sip_msg_t *)msg;
sip_header_t sip_hdr;
_sip_header_t *_sip_hdr;
if (_msg == NULL || header_name == NULL)
return (EINVAL);
(void) pthread_mutex_lock(&_msg->sip_msg_mutex);
if (_msg->sip_msg_cannot_be_modified) {
(void) pthread_mutex_unlock(&_msg->sip_msg_mutex);
return (EPERM);
}
sip_hdr = (sip_header_t)sip_search_for_header(_msg, header_name, NULL);
if (sip_hdr == NULL) {
(void) pthread_mutex_unlock(&_msg->sip_msg_mutex);
return (EINVAL);
}
_sip_hdr = (_sip_header_t *)sip_hdr;
_sip_hdr->sip_header_state = SIP_HEADER_DELETED;
_sip_hdr->sip_hdr_sipmsg->sip_msg_len -= _sip_hdr->sip_hdr_end -
_sip_hdr->sip_hdr_start;
assert(_sip_hdr->sip_hdr_sipmsg->sip_msg_len >= 0);
if (_msg->sip_msg_buf != NULL)
_msg->sip_msg_modified = B_TRUE;
(void) pthread_mutex_unlock(&_msg->sip_msg_mutex);
return (0);
}
/*
* Mark the header as deleted.
*/
int
sip_delete_header(sip_header_t sip_header)
{
_sip_header_t *_sip_header;
if (sip_header == NULL)
return (EINVAL);
_sip_header = (_sip_header_t *)sip_header;
(void) pthread_mutex_lock(&_sip_header->sip_hdr_sipmsg->sip_msg_mutex);
if (_sip_header->sip_hdr_sipmsg->sip_msg_cannot_be_modified) {
(void) pthread_mutex_unlock
(&_sip_header->sip_hdr_sipmsg->sip_msg_mutex);
return (EPERM);
}
if (_sip_header->sip_header_state == SIP_HEADER_DELETED) {
(void) pthread_mutex_unlock(
&_sip_header->sip_hdr_sipmsg->sip_msg_mutex);
return (EINVAL);
}
_sip_header->sip_header_state = SIP_HEADER_DELETED;
_sip_header->sip_hdr_sipmsg->sip_msg_len -= _sip_header->sip_hdr_end -
_sip_header->sip_hdr_start;
assert(_sip_header->sip_hdr_sipmsg->sip_msg_len >= 0);
if (_sip_header->sip_hdr_sipmsg->sip_msg_buf != NULL)
_sip_header->sip_hdr_sipmsg->sip_msg_modified = B_TRUE;
(void) pthread_mutex_unlock
(&_sip_header->sip_hdr_sipmsg->sip_msg_mutex);
return (0);
}
/*
* Mark the value as deleted.
*/
int
sip_delete_value(sip_header_t sip_header, sip_header_value_t sip_header_value)
{
_sip_header_t *_sip_header;
sip_value_t *_sip_header_value;
int vlen;
char *c;
if (sip_header == NULL || sip_header_value == NULL)
return (EINVAL);
_sip_header = (_sip_header_t *)sip_header;
(void) pthread_mutex_lock(&_sip_header->sip_hdr_sipmsg->sip_msg_mutex);
if (_sip_header->sip_hdr_sipmsg->sip_msg_cannot_be_modified) {
(void) pthread_mutex_unlock(&_sip_header->
sip_hdr_sipmsg->sip_msg_mutex);
return (EPERM);
}
if (_sip_header->sip_header_state == SIP_HEADER_DELETED) {
(void) pthread_mutex_unlock(
&_sip_header->sip_hdr_sipmsg->sip_msg_mutex);
return (EINVAL);
}
_sip_header_value = (sip_value_t *)sip_header_value;
if (_sip_header_value->value_state == SIP_VALUE_DELETED) {
(void) pthread_mutex_unlock(
&_sip_header->sip_hdr_sipmsg->sip_msg_mutex);
return (EINVAL);
}
_sip_header->sip_header_state = SIP_HEADER_DELETED_VAL;
_sip_header_value->value_state = SIP_VALUE_DELETED;
vlen = _sip_header_value->value_end - _sip_header_value->value_start;
if (_sip_header->sip_hdr_parsed->value == _sip_header_value) {
c = _sip_header_value->value_start;
while (*c-- != SIP_HCOLON)
vlen++;
} else {
c = _sip_header_value->value_start;
while (*c-- != SIP_COMMA)
vlen++;
}
if (_sip_header_value->next == NULL) {
sip_value_t *value = _sip_header->sip_hdr_parsed->value;
boolean_t crlf_present = B_FALSE;
char *s;
while (value != NULL && value != _sip_header_value) {
crlf_present = B_FALSE;
if (value->value_state == SIP_VALUE_DELETED) {
value = value->next;
continue;
}
s = value->value_end;
while (s != value->value_start) {
if (*s == '\r' && strncmp(s, SIP_CRLF,
strlen(SIP_CRLF)) == 0) {
crlf_present = B_TRUE;
break;
}
s--;
}
value = value->next;
}
if (!crlf_present) {
c = _sip_header_value->value_end;
while (*c-- != '\r')
vlen--;
assert(vlen > 0);
}
}
_sip_header->sip_hdr_sipmsg->sip_msg_len -= vlen;
if (_sip_header->sip_hdr_sipmsg->sip_msg_buf != NULL)
_sip_header->sip_hdr_sipmsg->sip_msg_modified = B_TRUE;
(void) pthread_mutex_unlock
(&_sip_header->sip_hdr_sipmsg->sip_msg_mutex);
return (0);
}
/*
* Given a param list, check if a param name exists.
*/
boolean_t
sip_is_param_present(const sip_param_t *param_list, char *param_name,
int param_len)
{
const sip_param_t *param = param_list;
while (param != NULL) {
if (param->param_name.sip_str_len == param_len &&
strncasecmp(param->param_name.sip_str_ptr, param_name,
param_len) == 0) {
return (B_TRUE);
}
param = param->param_next;
}
return (B_FALSE);
}
/*
* Given a value header return the value of the named param.
*/
const sip_str_t *
sip_get_param_value(sip_header_value_t header_value, char *param_name,
int *error)
{
sip_value_t *_sip_header_value;
sip_param_t *sip_param;
if (error != NULL)
*error = 0;
if (header_value == NULL || param_name == NULL) {
if (error != NULL)
*error = EINVAL;
return (NULL);
}
_sip_header_value = (sip_value_t *)header_value;
if (_sip_header_value->value_state == SIP_VALUE_DELETED) {
if (error != NULL)
*error = EINVAL;
return (NULL);
}
if (_sip_header_value->param_list == NULL) {
if (error != NULL)
*error = EINVAL;
return (NULL);
}
sip_param = sip_get_param_from_list(_sip_header_value->param_list,
param_name);
if (sip_param != NULL)
return (&sip_param->param_value);
return (NULL);
}
/*
* Return the list of params in the header
*/
const sip_param_t *
sip_get_params(sip_header_value_t header_value, int *error)
{
sip_value_t *sip_header_value;
if (error != NULL)
*error = 0;
if (header_value == NULL) {
if (error != NULL)
*error = EINVAL;
return (NULL);
}
sip_header_value = (sip_value_t *)header_value;
if (sip_header_value->value_state == SIP_VALUE_DELETED) {
if (error != NULL)
*error = EINVAL;
return (NULL);
}
return (sip_header_value->param_list);
}
/*
* Return true if this is a SIP request
*/
boolean_t
sip_msg_is_request(sip_msg_t sip_msg, int *error)
{
_sip_msg_t *_sip_msg;
sip_message_type_t *sip_msg_info;
boolean_t ret;
if (error != NULL)
*error = 0;
if (sip_msg == NULL) {
if (error != NULL)
*error = EINVAL;
return (B_FALSE);
}
_sip_msg = (_sip_msg_t *)sip_msg;
(void) pthread_mutex_lock(&_sip_msg->sip_msg_mutex);
if (_sip_msg->sip_msg_req_res == NULL) {
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
if (error != NULL)
*error = EINVAL;
return (B_FALSE);
}
sip_msg_info = _sip_msg->sip_msg_req_res;
ret = sip_msg_info->is_request;
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
return (ret);
}
/*
* Return true if this is a SIP response
*/
boolean_t
sip_msg_is_response(sip_msg_t sip_msg, int *error)
{
boolean_t is_resp;
_sip_msg_t *_sip_msg;
sip_message_type_t *sip_msg_info;
if (error != NULL)
*error = 0;
if (sip_msg == NULL) {
if (error != NULL)
*error = EINVAL;
return (B_FALSE);
}
_sip_msg = (_sip_msg_t *)sip_msg;
(void) pthread_mutex_lock(&_sip_msg->sip_msg_mutex);
if (_sip_msg->sip_msg_req_res == NULL) {
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
if (error != NULL)
*error = EINVAL;
return (B_FALSE);
}
sip_msg_info = _sip_msg->sip_msg_req_res;
is_resp = !sip_msg_info->is_request;
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
return (is_resp);
}
/*
* Return the method in the request line
*/
sip_method_t
sip_get_request_method(sip_msg_t sip_msg, int *error)
{
_sip_msg_t *_sip_msg;
sip_message_type_t *sip_msg_info;
sip_method_t ret = -1;
if (error != NULL)
*error = 0;
if (sip_msg == NULL) {
if (error != NULL)
*error = EINVAL;
return (ret);
}
_sip_msg = (_sip_msg_t *)sip_msg;
(void) pthread_mutex_lock(&_sip_msg->sip_msg_mutex);
sip_msg_info = _sip_msg->sip_msg_req_res;
if (_sip_msg->sip_msg_req_res == NULL) {
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
if (error != NULL)
*error = EINVAL;
return (ret);
}
if (sip_msg_info->is_request)
ret = sip_msg_info->sip_req_method;
else if (error != NULL)
*error = EINVAL;
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
return (ret);
}
/*
* Return the URI from the request line
*/
const sip_str_t *
sip_get_request_uri_str(sip_msg_t sip_msg, int *error)
{
_sip_msg_t *_sip_msg;
sip_message_type_t *sip_msg_info;
sip_str_t *ret = NULL;
struct sip_uri *parsed_uri;
if (error != NULL)
*error = 0;
if (sip_msg == NULL) {
if (error != NULL)
*error = EINVAL;
return (NULL);
}
_sip_msg = (_sip_msg_t *)sip_msg;
(void) pthread_mutex_lock(&_sip_msg->sip_msg_mutex);
if (_sip_msg->sip_msg_req_res == NULL) {
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
if (error != NULL)
*error = EINVAL;
return (NULL);
}
sip_msg_info = _sip_msg->sip_msg_req_res;
if (sip_msg_info->is_request)
ret = &sip_msg_info->sip_req_uri;
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
/*
* If the error is required, check the validity of the URI via
* sip_uri_parse().
*/
if (error != NULL) {
parsed_uri = sip_parse_uri(ret, error);
if (parsed_uri != NULL)
sip_free_parsed_uri((sip_uri_t)parsed_uri);
}
return (ret);
}
/*
* Return the response code
*/
int
sip_get_response_code(sip_msg_t sip_msg, int *error)
{
_sip_msg_t *_sip_msg;
sip_message_type_t *sip_msg_info;
int ret = -1;
if (error != NULL)
*error = 0;
if (sip_msg == NULL) {
if (error != NULL)
*error = EINVAL;
return (ret);
}
_sip_msg = (_sip_msg_t *)sip_msg;
(void) pthread_mutex_lock(&_sip_msg->sip_msg_mutex);
if (_sip_msg->sip_msg_req_res == NULL) {
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
if (error != NULL)
*error = EINVAL;
return (ret);
}
sip_msg_info = _sip_msg->sip_msg_req_res;
if (!sip_msg_info->is_request)
ret = sip_msg_info->sip_resp_code;
else if (error != NULL)
*error = EINVAL;
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
return (ret);
}
/*
* Get the response phrase
*/
const sip_str_t *
sip_get_response_phrase(sip_msg_t sip_msg, int *error)
{
_sip_msg_t *_sip_msg;
sip_message_type_t *sip_msg_info;
sip_str_t *ret = NULL;
if (error != NULL)
*error = 0;
if (sip_msg == NULL) {
if (error != NULL)
*error = EINVAL;
return (ret);
}
_sip_msg = (_sip_msg_t *)sip_msg;
(void) pthread_mutex_lock(&_sip_msg->sip_msg_mutex);
if (_sip_msg->sip_msg_req_res == NULL) {
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
if (error != NULL)
*error = EINVAL;
return (ret);
}
sip_msg_info = _sip_msg->sip_msg_req_res;
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
if (!sip_msg_info->is_request) {
if (sip_msg_info->sip_resp_phrase_len == 0)
ret = NULL;
else
ret = &sip_msg_info->sip_resp_phrase;
} else if (error != NULL) {
*error = EINVAL;
}
return (ret);
}
/*
* Get the SIP version string
*/
const sip_str_t *
sip_get_sip_version(sip_msg_t sip_msg, int *error)
{
_sip_msg_t *_sip_msg;
sip_message_type_t *sip_msg_info;
sip_str_t *ret = NULL;
if (error != NULL)
*error = 0;
if (sip_msg == NULL) {
if (error != NULL)
*error = EINVAL;
return (ret);
}
_sip_msg = (_sip_msg_t *)sip_msg;
(void) pthread_mutex_lock(&_sip_msg->sip_msg_mutex);
if (_sip_msg->sip_msg_req_res == NULL) {
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
if (error != NULL)
*error = EINVAL;
return (ret);
}
sip_msg_info = _sip_msg->sip_msg_req_res;
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
ret = &sip_msg_info->sip_proto_version.version;
return (ret);
}
/*
* Return the length of the SIP message
*/
int
sip_get_msg_len(sip_msg_t sip_msg, int *error)
{
_sip_msg_t *_sip_msg;
if (error != NULL)
*error = 0;
if (sip_msg == NULL) {
if (error != NULL)
*error = EINVAL;
return (-1);
}
_sip_msg = (_sip_msg_t *)sip_msg;
return (_sip_msg->sip_msg_len);
}
/*
* Get content as a string. Caller frees the string
*/
char *
sip_get_content(sip_msg_t sip_msg, int *error)
{
_sip_msg_t *_sip_msg;
sip_content_t *sip_content;
char *content;
int len;
char *p;
if (error != NULL)
*error = 0;
if (sip_msg == NULL) {
if (error != NULL)
*error = EINVAL;
return (NULL);
}
_sip_msg = (_sip_msg_t *)sip_msg;
(void) pthread_mutex_lock(&_sip_msg->sip_msg_mutex);
if (_sip_msg->sip_msg_content == NULL) {
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
if (error != NULL)
*error = EINVAL;
return (NULL);
}
content = malloc(_sip_msg->sip_msg_content_len + 1);
if (content == NULL) {
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
if (error != NULL)
*error = ENOMEM;
return (NULL);
}
p = content;
sip_content = _sip_msg->sip_msg_content;
while (sip_content != NULL) {
len = sip_content->sip_content_end -
sip_content->sip_content_start;
(void) strncpy(p, sip_content->sip_content_start, len);
p += len;
sip_content = sip_content->sip_content_next;
}
content[_sip_msg->sip_msg_content_len] = '\0';
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
return (content);
}
/*
* copy sip_header with param, if any, to sip_msg
*/
int
sip_copy_header(sip_msg_t sip_msg, sip_header_t sip_header, char *param)
{
_sip_msg_t *_sip_msg;
_sip_header_t *_sip_header;
int ret;
if (sip_msg == NULL || sip_header == NULL)
return (EINVAL);
_sip_msg = (_sip_msg_t *)sip_msg;
_sip_header = (_sip_header_t *)sip_header;
(void) pthread_mutex_lock(&_sip_msg->sip_msg_mutex);
if (_sip_msg->sip_msg_cannot_be_modified) {
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
return (EPERM);
}
if (_sip_header->sip_header_state == SIP_HEADER_DELETED) {
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
return (EINVAL);
}
ret = _sip_copy_header(_sip_msg, _sip_header, param, B_TRUE);
if (_sip_msg->sip_msg_buf != NULL)
_sip_msg->sip_msg_modified = B_TRUE;
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
return (ret);
}
/*
* copy the header specified by header_name, with param, if any
*/
int
sip_copy_header_by_name(sip_msg_t old_msg, sip_msg_t new_msg,
char *header_name, char *param)
{
int ret;
_sip_msg_t *_old_msg = (_sip_msg_t *)old_msg;
_sip_msg_t *_new_msg = (_sip_msg_t *)new_msg;
if (_old_msg == NULL || _new_msg == NULL || header_name == NULL ||
_old_msg == _new_msg) {
return (EINVAL);
}
(void) pthread_mutex_lock(&_new_msg->sip_msg_mutex);
if (_new_msg->sip_msg_cannot_be_modified) {
(void) pthread_mutex_unlock(&_new_msg->sip_msg_mutex);
return (EPERM);
}
(void) pthread_mutex_lock(&_old_msg->sip_msg_mutex);
ret = _sip_find_and_copy_header(_old_msg, _new_msg, header_name, param,
B_FALSE);
(void) pthread_mutex_unlock(&_old_msg->sip_msg_mutex);
if (_new_msg->sip_msg_buf != NULL)
_new_msg->sip_msg_modified = B_TRUE;
(void) pthread_mutex_unlock(&_new_msg->sip_msg_mutex);
return (ret);
}
/*
* add the given header to sip_message
*/
int
sip_add_header(sip_msg_t sip_msg, char *header_string)
{
int header_size;
_sip_header_t *new_header;
_sip_msg_t *_sip_msg;
if (sip_msg == NULL || header_string == NULL)
return (EINVAL);
_sip_msg = (_sip_msg_t *)sip_msg;
(void) pthread_mutex_lock(&_sip_msg->sip_msg_mutex);
if (_sip_msg->sip_msg_cannot_be_modified) {
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
return (EPERM);
}
header_size = strlen(header_string) + strlen(SIP_CRLF);
new_header = sip_new_header(header_size);
if (new_header == NULL) {
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
return (ENOMEM);
}
(void) snprintf(new_header->sip_hdr_start, header_size + 1, "%s%s",
header_string, SIP_CRLF);
_sip_add_header(_sip_msg, new_header, B_TRUE, B_FALSE, NULL);
if (_sip_msg->sip_msg_buf != NULL)
_sip_msg->sip_msg_modified = B_TRUE;
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
return (0);
}
/*
* add the given param to the sip_header. create a new header with the param
* and mark the old header as deleted.
*/
sip_header_t
sip_add_param(sip_header_t sip_header, char *param, int *error)
{
_sip_header_t *_sip_header;
_sip_header_t *new_header;
int hdrlen;
_sip_msg_t *_sip_msg;
int param_len;
char *tmp_ptr;
if (error != NULL)
*error = 0;
if (param == NULL || sip_header == NULL) {
if (error != NULL)
*error = EINVAL;
return (NULL);
}
_sip_header = (_sip_header_t *)sip_header;
(void) pthread_mutex_lock(&_sip_header->sip_hdr_sipmsg->sip_msg_mutex);
if (_sip_header->sip_hdr_sipmsg->sip_msg_cannot_be_modified) {
if (error != NULL)
*error = EPERM;
(void) pthread_mutex_unlock(
&_sip_header->sip_hdr_sipmsg->sip_msg_mutex);
return (NULL);
}
if (_sip_header->sip_header_state == SIP_HEADER_DELETED) {
if (error != NULL)
*error = EINVAL;
(void) pthread_mutex_unlock(
&_sip_header->sip_hdr_sipmsg->sip_msg_mutex);
return (NULL);
}
param_len = SIP_SPACE_LEN + sizeof (char) + SIP_SPACE_LEN +
strlen(param);
hdrlen = _sip_header->sip_hdr_end - _sip_header->sip_hdr_start;
new_header = sip_new_header(hdrlen + param_len);
if (new_header == NULL) {
if (error != NULL)
*error = ENOMEM;
(void) pthread_mutex_unlock(
&_sip_header->sip_hdr_sipmsg->sip_msg_mutex);
return (NULL);
}
(void) memcpy(new_header->sip_hdr_start, _sip_header->sip_hdr_start,
hdrlen);
new_header->sip_hdr_end = new_header->sip_hdr_start + hdrlen;
hdrlen = param_len + 1;
/*
* Find CRLF
*/
tmp_ptr = new_header->sip_hdr_end;
while (*tmp_ptr-- != '\n') {
hdrlen++;
if (tmp_ptr == new_header->sip_hdr_start) {
sip_free_header(new_header);
if (error != NULL)
*error = EINVAL;
(void) pthread_mutex_unlock(
&_sip_header->sip_hdr_sipmsg->sip_msg_mutex);
return (NULL);
}
}
(void) snprintf(tmp_ptr, hdrlen + 1,
" %c %s%s", SIP_SEMI, param, SIP_CRLF);
new_header->sip_hdr_end += param_len;
new_header->sip_header_functions = _sip_header->sip_header_functions;
_sip_msg = _sip_header->sip_hdr_sipmsg;
_sip_add_header(_sip_msg, new_header, B_TRUE, B_FALSE, NULL);
if (_sip_header->sip_hdr_sipmsg->sip_msg_buf != NULL)
_sip_header->sip_hdr_sipmsg->sip_msg_modified = B_TRUE;
(void) pthread_mutex_unlock(&new_header->sip_hdr_sipmsg->sip_msg_mutex);
(void) sip_delete_header(sip_header);
return ((sip_header_t)new_header);
}
/*
* Get Request URI
*/
const struct sip_uri *
sip_get_request_uri(sip_msg_t sip_msg, int *error)
{
_sip_msg_t *_sip_msg;
sip_message_type_t *sip_msg_info;
const struct sip_uri *ret = NULL;
if (error != NULL)
*error = 0;
if (sip_msg == NULL) {
if (error != NULL)
*error = EINVAL;
return (NULL);
}
_sip_msg = (_sip_msg_t *)sip_msg;
(void) pthread_mutex_lock(&_sip_msg->sip_msg_mutex);
sip_msg_info = _sip_msg->sip_msg_req_res;
if (sip_msg_info != NULL && sip_msg_info->is_request) {
ret = sip_msg_info->sip_req_parse_uri;
} else {
if (error != NULL)
*error = EINVAL;
}
(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
if (ret != NULL) {
if (ret->sip_uri_scheme.sip_str_len == 0 ||
ret->sip_uri_scheme.sip_str_ptr == NULL) {
ret = NULL;
if (error != NULL)
*error = EINVAL;
} else if (ret->sip_uri_errflags != 0 && error != NULL) {
*error = EINVAL;
}
}
return ((sip_uri_t)ret);
}
/*
* returns a comma separated string of all the sent-by values registered by
* the UA.
*/
char *
sip_sent_by_to_str(int *error)
{
sent_by_list_t *sb;
int sb_len = 0;
int slen;
char *sb_str;
char *p;
int count = 0;
int cnt = 0;
if (error != NULL)
*error = 0;
(void) pthread_mutex_lock(&sip_sent_by_lock);
if (sip_sent_by == NULL) {
(void) pthread_mutex_unlock(&sip_sent_by_lock);
return (NULL);
}
sb = sip_sent_by;
for (cnt = 0; cnt < sip_sent_by_count; cnt++) {
sb_len += strlen(sb->sb_val);
sb = sb->sb_next;
}
/*
* for the commas
*/
sb_len += sip_sent_by_count - 1;
sb_str = malloc(sb_len + 1);
if (sb_str == NULL) {
if (error != NULL)
*error = ENOMEM;
(void) pthread_mutex_unlock(&sip_sent_by_lock);
return (NULL);
}
sb = sip_sent_by;
p = sb_str;
slen = sb_len + 1;
for (cnt = 0; cnt < sip_sent_by_count; cnt++) {
if (cnt == 0) {
count = snprintf(p, slen, "%s", sb->sb_val);
} else {
count = snprintf(p, slen, "%c%s", SIP_COMMA,
sb->sb_val);
}
p += count;
slen -= count;
sb = sb->sb_next;
}
sb_str[sb_len] = '\0';
(void) pthread_mutex_unlock(&sip_sent_by_lock);
return (sb_str);
}
/*
* A comma separated list of sent-by values.
*/
int
sip_register_sent_by(char *val)
{
sent_by_list_t *sb = NULL;
sent_by_list_t *sb_tail = NULL;
char *str;
int count = 0;
if (val == NULL)
return (EINVAL);
str = strtok(val, ",");
while (str != NULL) {
int slen;
char *start = str;
char *end = str + strlen(str) - 1;
while (isspace(*start))
start++;
while (isspace(*end))
end--;
if (end <= start)
goto err_ret;
slen = end - start + 1;
sb_tail = (sent_by_list_t *)malloc(sizeof (*sb_tail));
if (sb_tail == NULL)
goto err_ret;
sb_tail->sb_next = sb_tail->sb_prev = NULL;
if ((sb_tail->sb_val = (char *)malloc(slen + 1)) == NULL) {
free(sb_tail);
goto err_ret;
}
(void) strncpy(sb_tail->sb_val, start, slen);
sb_tail->sb_val[slen] = '\0';
if (sb == NULL) {
sb = sb_tail;
} else {
sb_tail->sb_next = sb;
sb->sb_prev = sb_tail;
sb = sb_tail;
}
count++;
str = strtok(NULL, ",");
}
sb_tail = sb;
while (sb_tail->sb_next != NULL)
sb_tail = sb_tail->sb_next;
(void) pthread_mutex_lock(&sip_sent_by_lock);
if (sip_sent_by != NULL) {
sb_tail->sb_next = sip_sent_by;
sip_sent_by->sb_prev = sb_tail;
}
sip_sent_by = sb;
sip_sent_by_count += count;
(void) pthread_mutex_unlock(&sip_sent_by_lock);
return (0);
err_ret:
sb_tail = sb;
for (; count > 0; count--) {
sb = sb_tail->sb_next;
free(sb_tail->sb_val);
sb_tail->sb_next = NULL;
sb_tail->sb_prev = NULL;
free(sb_tail);
sb_tail = sb;
}
return (EINVAL);
}
/*
* Un-register sent-by values; 'val' contains a comma separated list
*/
void
sip_unregister_sent_by(char *val)
{
sent_by_list_t *sb;
char *str;
int count = 0;
(void) pthread_mutex_lock(&sip_sent_by_lock);
str = strtok(val, ",");
while (str != NULL) {
sb = sip_sent_by;
for (count = 0; count < sip_sent_by_count; count++) {
if (strncmp(sb->sb_val, str, strlen(str)) == 0) {
if (sb == sip_sent_by) {
if (sb->sb_next != NULL)
sip_sent_by = sb->sb_next;
else
sip_sent_by = NULL;
} else if (sb->sb_next == NULL) {
sb->sb_prev->sb_next = NULL;
} else {
sb->sb_prev->sb_next = sb->sb_next;
sb->sb_next->sb_prev = sb->sb_prev;
}
sip_sent_by_count--;
sb->sb_next = NULL;
sb->sb_prev = NULL;
free(sb->sb_val);
free(sb);
break;
}
sb = sb->sb_next;
}
str = strtok(NULL, ",");
}
(void) pthread_mutex_unlock(&sip_sent_by_lock);
}
/*
* Un-register all the sent-by values
*/
void
sip_unregister_all_sent_by()
{
sent_by_list_t *sb;
int count;
(void) pthread_mutex_lock(&sip_sent_by_lock);
sb = sip_sent_by;
for (count = 0; count < sip_sent_by_count; count++) {
sip_sent_by = sb->sb_next;
free(sb->sb_val);
sb->sb_next = NULL;
sb->sb_prev = NULL;
free(sb);
sb = sip_sent_by;
}
sip_sent_by = NULL;
sip_sent_by_count = 0;
(void) pthread_mutex_unlock(&sip_sent_by_lock);
}
/*
* Given a response code, return the corresponding phrase
*/
char *
sip_get_resp_desc(int resp_code)
{
switch (resp_code) {
case SIP_TRYING:
return ("TRYING");
case SIP_RINGING:
return ("RINGING");
case SIP_CALL_IS_BEING_FORWARDED:
return ("CALL_IS_BEING_FORWARDED");
case SIP_QUEUED:
return ("QUEUED");
case SIP_SESSION_PROGRESS:
return ("SESSION_PROGRESS");
case SIP_OK:
return ("OK");
case SIP_ACCEPTED:
return ("ACCEPTED");
case SIP_MULTIPLE_CHOICES:
return ("MULTIPLE_CHOICES");
case SIP_MOVED_PERMANENTLY:
return ("MOVED_PERMANENTLY");
case SIP_MOVED_TEMPORARILY:
return ("MOVED_TEMPORARILY");
case SIP_USE_PROXY:
return ("USE_PROXY");
case SIP_ALTERNATIVE_SERVICE:
return ("ALTERNATIVE_SERVICE");
case SIP_BAD_REQUEST:
return ("BAD_REQUEST");
case SIP_UNAUTHORIZED:
return ("UNAUTHORIZED");
case SIP_PAYMENT_REQUIRED:
return ("PAYMENT_REQUIRED");
case SIP_FORBIDDEN:
return ("FORBIDDEN");
case SIP_NOT_FOUND:
return ("NOT_FOUND");
case SIP_METHOD_NOT_ALLOWED:
return ("METHOD_NOT_ALLOWED");
case SIP_NOT_ACCEPTABLE:
return ("NOT_ACCEPTABLE");
case SIP_PROXY_AUTH_REQUIRED:
return ("PROXY_AUTH_REQUIRED");
case SIP_REQUEST_TIMEOUT:
return ("REQUEST_TIMEOUT");
case SIP_GONE:
return ("GONE");
case SIP_REQUEST_ENTITY_2_LARGE:
return ("REQUEST_ENTITY_2_LARGE");
case SIP_REQUEST_URI_2_LONG:
return ("REQUEST_URI_2_LONG");
case SIP_UNSUPPORTED_MEDIA_TYPE:
return ("UNSUPPORTED_MEDIA_TYPE");
case SIP_UNSUPPORTED_URI_SCHEME:
return ("UNSUPPORTED_URI_SCHEME");
case SIP_BAD_EXTENSION:
return ("BAD_EXTENSION");
case SIP_EXTENSION_REQUIRED:
return ("EXTENSION_REQUIRED");
case SIP_INTERVAL_2_BRIEF:
return ("INTERVAL_2_BRIEF");
case SIP_TEMPORARILY_UNAVAIL:
return ("TEMPORARILY_UNAVAIL");
case SIP_CALL_NON_EXISTANT:
return ("CALL_NON_EXISTANT");
case SIP_LOOP_DETECTED:
return ("LOOP_DETECTED");
case SIP_TOO_MANY_HOOPS:
return ("TOO_MANY_HOOPS");
case SIP_ADDRESS_INCOMPLETE:
return ("ADDRESS_INCOMPLETE");
case SIP_AMBIGUOUS:
return ("AMBIGUOUS");
case SIP_BUSY_HERE:
return ("BUSY_HERE");
case SIP_REQUEST_TERMINATED:
return ("REQUEST_TERMINATED");
case SIP_NOT_ACCEPTABLE_HERE:
return ("NOT_ACCEPTABLE_HERE");
case SIP_BAD_EVENT:
return ("BAD_EVENT");
case SIP_REQUEST_PENDING:
return ("REQUEST_PENDING");
case SIP_UNDECIPHERABLE:
return ("UNDECIPHERABLE");
case SIP_SERVER_INTERNAL_ERROR:
return ("SERVER_INTERNAL_ERROR");
case SIP_NOT_IMPLEMENTED:
return ("NOT_IMPLEMENTED");
case SIP_BAD_GATEWAY:
return ("BAD_GATEWAY");
case SIP_SERVICE_UNAVAILABLE:
return ("SERVICE_UNAVAILABLE");
case SIP_SERVER_TIMEOUT:
return ("SERVER_TIMEOUT");
case SIP_VERSION_NOT_SUPPORTED:
return ("VERSION_NOT_SUPPORTED");
case SIP_MESSAGE_2_LARGE:
return ("MESSAGE_2_LARGE");
case SIP_BUSY_EVERYWHERE:
return ("BUSY_EVERYWHERE");
case SIP_DECLINE:
return ("DECLINE");
case SIP_DOES_NOT_EXIST_ANYWHERE:
return ("DOES_NOT_EXIST_ANYWHERE");
case SIP_NOT_ACCEPTABLE_ANYWHERE:
return ("NOT_ACCEPTABLE_ANYWHERE");
default:
return ("UNKNOWN");
}
}
/*
* The following three fns initialize and destroy the private library
* data in sip_conn_object_t. The assumption is that the 1st member
* of sip_conn_object_t is reserved for library use. The private data
* is used only for byte-stream protocols such as TCP to accumulate
* a complete SIP message, based on the CONTENT-LENGTH value, before
* processing it.
*/
int
sip_init_conn_object(sip_conn_object_t obj)
{
void **obj_val;
sip_conn_obj_pvt_t *pvt_data;
if (obj == NULL)
return (EINVAL);
pvt_data = malloc(sizeof (sip_conn_obj_pvt_t));
if (pvt_data == NULL)
return (ENOMEM);
pvt_data->sip_conn_obj_cache = NULL;
pvt_data->sip_conn_obj_reass = malloc(sizeof (sip_reass_entry_t));
if (pvt_data->sip_conn_obj_reass == NULL) {
free(pvt_data);
return (ENOMEM);
}
bzero(pvt_data->sip_conn_obj_reass, sizeof (sip_reass_entry_t));
(void) pthread_mutex_init(&pvt_data->sip_conn_obj_reass_lock, NULL);
(void) pthread_mutex_init(&pvt_data->sip_conn_obj_cache_lock, NULL);
sip_refhold_conn(obj);
obj_val = (void *)obj;
*obj_val = (void *)pvt_data;
return (0);
}
/*
* Clear private date, if any
*/
void
sip_clear_stale_data(sip_conn_object_t obj)
{
void **obj_val;
sip_conn_obj_pvt_t *pvt_data;
sip_reass_entry_t *reass;
if (obj == NULL)
return;
obj_val = (void *)obj;
pvt_data = (sip_conn_obj_pvt_t *)*obj_val;
(void) pthread_mutex_lock(&pvt_data->sip_conn_obj_reass_lock);
reass = pvt_data->sip_conn_obj_reass;
if (reass->sip_reass_msg != NULL) {
assert(reass->sip_reass_msglen > 0);
free(reass->sip_reass_msg);
reass->sip_reass_msglen = 0;
}
assert(reass->sip_reass_msglen == 0);
(void) pthread_mutex_unlock(&pvt_data->sip_conn_obj_reass_lock);
}
/*
* Walk through all the transactions, remove if this obj has been cached
* by any.
*/
void
sip_conn_destroyed(sip_conn_object_t obj)
{
void **obj_val;
sip_conn_obj_pvt_t *pvt_data;
if (obj == NULL)
return;
obj_val = (void *)obj;
pvt_data = (sip_conn_obj_pvt_t *)*obj_val;
sip_clear_stale_data(obj);
free(pvt_data->sip_conn_obj_reass);
pvt_data->sip_conn_obj_reass = NULL;
(void) pthread_mutex_destroy(&pvt_data->sip_conn_obj_reass_lock);
sip_del_conn_obj_cache(obj, NULL);
(void) pthread_mutex_destroy(&pvt_data->sip_conn_obj_cache_lock);
free(pvt_data);
*obj_val = NULL;
sip_refrele_conn(obj);
}