mirror of
https://github.com/signalwire/freeswitch.git
synced 2026-11-12 04:27:06 +00:00
add sofia-sip 1.12.4 (plus some patches through 12/21/2006) to in tree libs
git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@3774 d0543943-73ff-0310-b7d9-9358b9ac24b2
This commit is contained in:
Michael Jerris committed
1 parent
0cdfa4fe13
commit
2ecac238f3
719 files changed
+311340
-2
No files matched your search
@@ -0,0 +1,413 @@
|
||||
/*
|
||||
* This file is part of the Sofia-SIP package
|
||||
*
|
||||
* Copyright (C) 2005 Nokia Corporation.
|
||||
*
|
||||
* Contact: Pekka Pessi <pekka.pessi@nokia.com>
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public License
|
||||
* as published by the Free Software Foundation; either version 2.1 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
|
||||
* 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
/**@ingroup test_msg
|
||||
* @file test_class.c
|
||||
*
|
||||
* Message class for testing parser and transports.
|
||||
*
|
||||
* @author Pekka Pessi <Pekka.Pessi@nokia.com>
|
||||
*
|
||||
* @date Created: Tue Mar 5 11:57:20 2002 ppessi
|
||||
*/
|
||||
|
||||
#include "config.h"
|
||||
|
||||
#include <stddef.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#define TAG_NAMESPACE "tst"
|
||||
|
||||
#include <test_class.h>
|
||||
#include <sofia-sip/msg_parser.h>
|
||||
#include <sofia-sip/msg_mclass.h>
|
||||
#include <test_protos.h>
|
||||
#include <sofia-sip/msg_addr.h>
|
||||
|
||||
extern msg_mclass_t const msg_test_mclass[1];
|
||||
|
||||
extern msg_mclass_t const *msg_test_default(void)
|
||||
{
|
||||
return msg_test_mclass;
|
||||
}
|
||||
|
||||
#define msg_generic_update NULL
|
||||
|
||||
/**@ingroup test_msg
|
||||
* @defgroup msg_test_request Request Line for Testing
|
||||
*/
|
||||
|
||||
static msg_xtra_f msg_request_dup_xtra;
|
||||
static msg_dup_f msg_request_dup_one;
|
||||
|
||||
msg_hclass_t msg_request_class[] =
|
||||
MSG_HEADER_CLASS(msg_, request, NULL, "", rq_common,
|
||||
single_critical, msg_request, msg_generic);
|
||||
|
||||
/** Decode a request line */
|
||||
issize_t msg_request_d(su_home_t *home, msg_header_t *h, char *s, isize_t slen)
|
||||
{
|
||||
msg_request_t *rq = (msg_request_t *)h;
|
||||
char *uri, *version;
|
||||
|
||||
if (msg_firstline_d(s, &uri, &version) < 0 || !uri ||
|
||||
url_d(rq->rq_url, uri) < 0)
|
||||
return -1;
|
||||
|
||||
rq->rq_method_name = s;
|
||||
rq->rq_version = version;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**Encode a request line. */
|
||||
issize_t msg_request_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
|
||||
{
|
||||
msg_request_t const *rq = (msg_request_t const *)h;
|
||||
|
||||
return snprintf(b, bsiz, "%s " URL_FORMAT_STRING " %s" CRLF,
|
||||
rq->rq_method_name,
|
||||
URL_PRINT_ARGS(rq->rq_url),
|
||||
rq->rq_version);
|
||||
}
|
||||
|
||||
isize_t msg_request_dup_xtra(msg_header_t const *h, isize_t offset)
|
||||
{
|
||||
isize_t rv = offset;
|
||||
msg_request_t const *rq = (msg_request_t const *)h;
|
||||
|
||||
rv += url_xtra(rq->rq_url);
|
||||
rv += MSG_STRING_SIZE(rq->rq_method_name);
|
||||
rv += MSG_STRING_SIZE(rq->rq_version);
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
/** Duplicate one request header. */
|
||||
char *msg_request_dup_one(msg_header_t *dst, msg_header_t const *src,
|
||||
char *b, isize_t xtra)
|
||||
{
|
||||
msg_request_t *rq = (msg_request_t *)dst;
|
||||
msg_request_t const *o = (msg_request_t const *)src;
|
||||
char *end = b + xtra;
|
||||
|
||||
URL_DUP(b, end, rq->rq_url, o->rq_url);
|
||||
|
||||
MSG_STRING_DUP(b, rq->rq_method_name, o->rq_method_name);
|
||||
MSG_STRING_DUP(b, rq->rq_version, o->rq_version);
|
||||
|
||||
assert(b <= end);
|
||||
|
||||
return b;
|
||||
}
|
||||
|
||||
/**@ingroup test_msg
|
||||
* @defgroup msg_test_status Status Line for Testing
|
||||
*/
|
||||
|
||||
static msg_xtra_f msg_status_dup_xtra;
|
||||
static msg_dup_f msg_status_dup_one;
|
||||
|
||||
msg_hclass_t msg_status_class[1] =
|
||||
MSG_HEADER_CLASS(msg_, status, NULL, "", st_common,
|
||||
single_critical, msg_status, msg_generic);
|
||||
|
||||
/** Parse status line */
|
||||
issize_t msg_status_d(su_home_t *home, msg_header_t *h, char *s, isize_t slen)
|
||||
{
|
||||
msg_status_t *st = (msg_status_t *)h;
|
||||
char *status, *phrase;
|
||||
unsigned long code;
|
||||
|
||||
if (msg_firstline_d(s, &status, &phrase) < 0 ||
|
||||
(code = strtoul(status, &status, 10)) >= 1000 || *status)
|
||||
return -1;
|
||||
|
||||
st->st_status = code;
|
||||
st->st_phrase = phrase;
|
||||
st->st_version = s;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
issize_t msg_status_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
|
||||
{
|
||||
msg_status_t const *st = (msg_status_t const *)h;
|
||||
int status = st->st_status;
|
||||
|
||||
if (status > 999 || status < 100)
|
||||
status = 0;
|
||||
|
||||
return snprintf(b, bsiz, "%s %03u %s" CRLF,
|
||||
st->st_version, status, st->st_phrase);
|
||||
}
|
||||
|
||||
/** Extra size of a msg_status_t object. */
|
||||
isize_t msg_status_dup_xtra(msg_header_t const *h, isize_t offset)
|
||||
{
|
||||
isize_t rv = offset;
|
||||
msg_status_t const *st = (msg_status_t const *)h;
|
||||
rv += MSG_STRING_SIZE(st->st_version);
|
||||
rv += MSG_STRING_SIZE(st->st_phrase);
|
||||
return rv;
|
||||
}
|
||||
|
||||
/** Duplicate one status header. */
|
||||
char *msg_status_dup_one(msg_header_t *dst, msg_header_t const *src,
|
||||
char *b, isize_t xtra)
|
||||
{
|
||||
msg_status_t *st = (msg_status_t *)dst;
|
||||
msg_status_t const *o = (msg_status_t const *)src;
|
||||
char *end = b + xtra;
|
||||
|
||||
MSG_STRING_DUP(b, st->st_version, o->st_version);
|
||||
st->st_status = o->st_status;
|
||||
MSG_STRING_DUP(b, st->st_phrase, o->st_phrase);
|
||||
|
||||
assert(b <= end); (void)end;
|
||||
|
||||
return b;
|
||||
}
|
||||
|
||||
/** Extract the message body, including separator line.
|
||||
*
|
||||
* @param[in,out] msg message object
|
||||
* @param[in,out] pub public message structure
|
||||
* @param[in] b buffer containing unparsed data
|
||||
* @param[in] bsiz buffer size
|
||||
* @param[in] eos true if buffer contains whole message
|
||||
*
|
||||
* @retval -1 error
|
||||
* @retval 0 message is incomplete
|
||||
* @retval other number of bytes extracted
|
||||
*/
|
||||
issize_t msg_test_extract_body(msg_t *msg, msg_pub_t *pub,
|
||||
char b[], isize_t bsiz, int eos)
|
||||
{
|
||||
msg_test_t *tst = (msg_test_t *)pub;
|
||||
ssize_t m = 0;
|
||||
size_t body_len;
|
||||
|
||||
if (!(tst->msg_flags & MSG_FLG_BODY)) {
|
||||
/* We are looking at a potential empty line */
|
||||
m = msg_extract_separator(msg, (msg_pub_t *)tst, b, bsiz, eos);
|
||||
if (m == 0 || m == -1)
|
||||
return m;
|
||||
tst->msg_flags |= MSG_FLG_BODY;
|
||||
b += m;
|
||||
bsiz -= m;
|
||||
}
|
||||
|
||||
if (tst->msg_content_length)
|
||||
body_len = tst->msg_content_length->l_length;
|
||||
else if (MSG_IS_MAILBOX(tst->msg_flags)) /* message fragments */
|
||||
body_len = 0;
|
||||
else if (eos)
|
||||
body_len = bsiz;
|
||||
else
|
||||
return -1;
|
||||
|
||||
if (body_len == 0) {
|
||||
tst->msg_flags |= MSG_FLG_COMPLETE;
|
||||
return m;
|
||||
}
|
||||
|
||||
if (m)
|
||||
return m;
|
||||
|
||||
if ((m = msg_extract_payload(msg, (msg_pub_t *)tst, NULL, body_len, b, bsiz, eos) ) == -1)
|
||||
return -1;
|
||||
|
||||
tst->msg_flags |= MSG_FLG_FRAGS;
|
||||
if (bsiz >= body_len)
|
||||
tst->msg_flags |= MSG_FLG_COMPLETE;
|
||||
return m;
|
||||
}
|
||||
|
||||
msg_href_t const msg_content_length_href[1] =
|
||||
{{
|
||||
msg_content_length_class,
|
||||
offsetof(msg_test_t, msg_content_length)
|
||||
}};
|
||||
|
||||
#include <sofia-sip/su_tag_class.h>
|
||||
#include <sofia-sip/su_tag_inline.h>
|
||||
#include <sofia-sip/su_tagarg.h>
|
||||
#include <sofia-sip/msg_tag_class.h>
|
||||
|
||||
tagi_t *tsttag_filter(tagi_t *dst,
|
||||
tagi_t const f[],
|
||||
tagi_t const *src,
|
||||
void **bb);
|
||||
|
||||
/** Tag class for test header tags. @HIDE */
|
||||
tag_class_t tsthdrtag_class[1] =
|
||||
{{
|
||||
sizeof(tsthdrtag_class),
|
||||
/* tc_next */ NULL,
|
||||
/* tc_len */ NULL,
|
||||
/* tc_move */ NULL,
|
||||
/* tc_xtra */ msghdrtag_xtra,
|
||||
/* tc_dup */ msghdrtag_dup,
|
||||
/* tc_free */ NULL,
|
||||
/* tc_find */ NULL,
|
||||
/* tc_snprintf */ msghdrtag_snprintf,
|
||||
/* tc_filter */ tsttag_filter,
|
||||
/* tc_ref_set */ t_ptr_ref_set,
|
||||
/* tc_scan */ msghdrtag_scan,
|
||||
}};
|
||||
|
||||
/** Tag class for TST header string tags. @HIDE */
|
||||
tag_class_t tststrtag_class[1] =
|
||||
{{
|
||||
sizeof(tststrtag_class),
|
||||
/* tc_next */ NULL,
|
||||
/* tc_len */ NULL,
|
||||
/* tc_move */ NULL,
|
||||
/* tc_xtra */ t_str_xtra,
|
||||
/* tc_dup */ t_str_dup,
|
||||
/* tc_free */ NULL,
|
||||
/* tc_find */ NULL,
|
||||
/* tc_snprintf */ t_str_snprintf,
|
||||
/* tc_filter */ NULL /* msgtag_str_filter */,
|
||||
/* tc_ref_set */ t_ptr_ref_set,
|
||||
/* tc_scan */ t_str_scan
|
||||
}};
|
||||
|
||||
/** Tag class for TST message tags. @HIDE */
|
||||
tag_class_t tstmsgtag_class[1] =
|
||||
{{
|
||||
sizeof(tstmsgtag_class),
|
||||
/* tc_next */ NULL,
|
||||
/* tc_len */ NULL,
|
||||
/* tc_move */ NULL,
|
||||
/* tc_xtra */ msgobjtag_xtra,
|
||||
/* tc_dup */ msgobjtag_dup,
|
||||
/* tc_free */ NULL,
|
||||
/* tc_find */ NULL,
|
||||
/* tc_snprintf */ msgobjtag_snprintf,
|
||||
/* tc_filter */ NULL /* tsttag_tst_filter */,
|
||||
/* tc_ref_set */ t_ptr_ref_set,
|
||||
}};
|
||||
|
||||
tag_typedef_t tsttag_header =
|
||||
{{ TAG_NAMESPACE, "header", tsthdrtag_class, 0 }};
|
||||
|
||||
tag_typedef_t tsttag_header_str = STRTAG_TYPEDEF(header_str);
|
||||
|
||||
/** Filter a TST header structure. */
|
||||
tagi_t *tsttag_filter(tagi_t *dst,
|
||||
tagi_t const f[],
|
||||
tagi_t const *src,
|
||||
void **bb)
|
||||
{
|
||||
tagi_t stub[2] = {{ NULL }};
|
||||
tag_type_t sctt, tt = f->t_tag;
|
||||
msg_hclass_t *hc = (msg_hclass_t *)tt->tt_magic;
|
||||
|
||||
assert(src);
|
||||
|
||||
sctt = src->t_tag;
|
||||
|
||||
if (sctt && sctt->tt_class == tstmsgtag_class) {
|
||||
msg_test_t const *tst = (msg_test_t const *)src->t_value;
|
||||
msg_mclass_t *mc = (msg_mclass_t *)tst->msg_ident;
|
||||
msg_header_t const **hh = (msg_header_t const **)
|
||||
msg_hclass_offset(mc, (msg_pub_t *)tst, hc);
|
||||
msg_header_t const *h;
|
||||
|
||||
if (tst == NULL ||
|
||||
(char *)hh >= ((char *)tst + tst->msg_size) ||
|
||||
(char *)hh < (char const *)&tst->msg_request)
|
||||
return dst;
|
||||
|
||||
h = *hh;
|
||||
|
||||
if (h == NULL)
|
||||
return dst;
|
||||
|
||||
stub[0].t_tag = tt;
|
||||
stub[0].t_value = (tag_value_t)h;
|
||||
src = stub; sctt = tt;
|
||||
}
|
||||
|
||||
if (tt != sctt)
|
||||
return dst;
|
||||
|
||||
if (!src->t_value)
|
||||
return dst;
|
||||
else if (dst) {
|
||||
return t_dup(dst, src, bb);
|
||||
}
|
||||
else {
|
||||
*bb = (char *)*bb + t_xtra(src, (size_t)*bb);
|
||||
return dst + 1;
|
||||
}
|
||||
}
|
||||
|
||||
/** Add duplicates of headers from taglist to the TST message. */
|
||||
int tst_add_tl(msg_t *msg, msg_test_t *tst,
|
||||
tag_type_t tag, tag_value_t value, ...)
|
||||
{
|
||||
tagi_t const *t;
|
||||
ta_list ta;
|
||||
|
||||
ta_start(ta, tag, value);
|
||||
|
||||
for (t = ta_args(ta); t; t = tl_next(t)) {
|
||||
if (!(tag = t->t_tag) || !(value = t->t_value))
|
||||
continue;
|
||||
|
||||
if (TSTTAG_P(tag)) {
|
||||
msg_hclass_t *hc = (msg_hclass_t *)tag->tt_magic;
|
||||
msg_header_t *h = (msg_header_t *)value, **hh;
|
||||
|
||||
if (h == NULL)
|
||||
;
|
||||
else if (h == MSG_HEADER_NONE) { /* Remove header */
|
||||
hh = msg_hclass_offset(msg_mclass(msg), (msg_pub_t *)tst, hc);
|
||||
while (hh && *hh)
|
||||
msg_header_remove(msg, (msg_pub_t *)tst, *hh);
|
||||
} else if (msg_header_add_dup_as(msg, (msg_pub_t *)tst, hc, h) < 0)
|
||||
break;
|
||||
}
|
||||
else if (TSTTAG_STR_P(tag)) {
|
||||
msg_hclass_t *hc = (msg_hclass_t *)tag->tt_magic;
|
||||
char const *s = (char const *)value;
|
||||
if (s && msg_header_add_make(msg, (msg_pub_t *)tst, hc, s) < 0)
|
||||
break;
|
||||
}
|
||||
else if (tag == tsttag_header_str) {
|
||||
if (msg_header_add_str(msg, (msg_pub_t *)tst, (char const *)value) < 0)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ta_end(ta);
|
||||
|
||||
return t ? -1 : 0;
|
||||
}
|
||||
Reference in new issue
Block a user