/*---------------------------------------------------------------------------*/
static
PT_THREAD(handle_dhcp(void))
{
PT_BEGIN(&s.pt);
/* try_again:*/
s.state = STATE_SENDING;
s.ticks = CLOCK_SECOND;
do {
send_discover();
s.timer_init = platform_timer_op( ELUA_DHCP_TIMER_ID, PLATFORM_TIMER_OP_START, 0 );
PT_WAIT_UNTIL(&s.pt, uip_newdata() || platform_timer_get_diff_us( ELUA_DHCP_TIMER_ID, s.timer_init, platform_timer_op( ELUA_DHCP_TIMER_ID, PLATFORM_TIMER_OP_READ, 0 ) ) >= s.ticks );
if(uip_newdata() && parse_msg() == DHCPOFFER) {
uip_flags &= ~UIP_NEWDATA;
s.state = STATE_OFFER_RECEIVED;
break;
}
uip_flags &= ~UIP_NEWDATA;
if(s.ticks < CLOCK_SECOND * 60) {
s.ticks *= 2;
} else {
s.ipaddr[0] = 0;
goto dhcp_failed;
}
} while(s.state != STATE_OFFER_RECEIVED);
s.ticks = CLOCK_SECOND;
do {
send_request();
s.timer_init = platform_timer_op( ELUA_DHCP_TIMER_ID, PLATFORM_TIMER_OP_START, 0 );
PT_WAIT_UNTIL(&s.pt, uip_newdata() || platform_timer_get_diff_us( ELUA_DHCP_TIMER_ID, s.timer_init, platform_timer_op( ELUA_DHCP_TIMER_ID, PLATFORM_TIMER_OP_READ, 0 ) ) >= s.ticks );
if(uip_newdata() && parse_msg() == DHCPACK) {
uip_flags &= ~UIP_NEWDATA;
s.state = STATE_CONFIG_RECEIVED;
break;
}
uip_flags &= ~UIP_NEWDATA;
if(s.ticks <= CLOCK_SECOND * 10) {
s.ticks += CLOCK_SECOND;
} else {
PT_RESTART(&s.pt);
}
} while(s.state != STATE_CONFIG_RECEIVED);
dhcp_failed:
dhcpc_configured(&s);
/*
* PT_END restarts the thread so we do this instead. Eventually we
* should reacquire expired leases here.
*/
while(1) {
PT_YIELD(&s.pt);
}
PT_END(&s.pt);
}
static inline struct sip_msg* buf_to_sip_msg(char *buf, unsigned int len,
dlg_t *dialog)
{
static struct sip_msg req;
memset( &req, 0, sizeof(req) );
req.id = get_next_msg_no();
req.buf = buf;
req.len = len;
if (parse_msg(buf, len, &req)!=0) {
LM_CRIT("BUG - buffer parsing failed!");
return NULL;
}
/* populate some special fields in sip_msg */
req.set_global_address=default_global_address;
req.set_global_port=default_global_port;
req.force_send_socket = dialog->send_sock;
if (set_dst_uri(&req, dialog->hooks.next_hop)) {
LM_ERR("failed to set dst_uri");
free_sip_msg(&req);
return NULL;
}
req.rcv.proto = dialog->send_sock->proto;
req.rcv.src_ip = req.rcv.dst_ip = dialog->send_sock->address;
req.rcv.src_port = req.rcv.dst_port = dialog->send_sock->port_no;
req.rcv.bind_address = dialog->send_sock;
return &req;
}
void do_irc(int fd) {
char recvbuf[MAX_MSG_LEN + 1];
char recvbuf2[MAX_MSG_LEN+1];
char sendbuf[MAX_MSG_LEN + 1];
char tokens[MAX_MSG_TOKENS][MAX_MSG_LEN+1];
int length;
bzero(&recvbuf, sizeof(recvbuf));
bzero(&sendbuf, sizeof(sendbuf));
read_msg(fd, recvbuf);
bzero(&recvbuf2, sizeof(recvbuf2));
trim(recvbuf, recvbuf2);
length = tokenize(recvbuf2, tokens);
parse_msg(tokens, length, sendbuf, fd);
}
static void dealnet(aeEventLoop *loop, int fd, void *privdata, int mask)
{
struct sockaddr_in peer;
char buf[MAX_MSG_LEN];
struct ipcam_search_msg *msg_buf;
socklen_t len;
int ret;
len = sizeof(struct sockaddr_in);
ret = recvfrom(fd, buf, sizeof(buf), 0,
(struct sockaddr *)&peer, (socklen_t *)&len);
if (ret < 0) {
debug_print("recvfrom fail");
return;
}
msg_buf = malloc(sizeof(struct ipcam_search_msg)
+ ((struct ipcam_search_msg *)buf)->exten_len);
parse_msg(buf, ret, msg_buf);
deal_msg_func(msg_buf, &peer);
if (msg_buf) {
free(msg_buf);
msg_buf = NULL;
}
}
static void process_msg(msg_t* msg, int localfd)
{
void* buffer = NULL;
unsigned short len;
int sys;
size_t room_id;
if (parse_msg(msg, &sys, &buffer, &len, &room_id))
{
if (sys) client_process_sys(msg, buffer, len);
else
{
ssize_t written = write_n(localfd, buffer, len);
SYSLOG(LOG_INFO, "write local length: %ld", written);
}
}
else
{
SYSLOG(LOG_WARNING, "Parse message error");
return;
}
if (buffer) pool_room_free(&this.pool, room_id);
this.client.status = (this.client.status & ~CLIENT_STATUS_WAITING_BODY) | CLIENT_STATUS_WAITING_HEADER;
this.client.want = sizeof(msg_t);
this.client.read = this.client.buffer;
}
int faked_msg_init_with_dlg_info(str *callid, str *from_tag, str *to_tag, struct sip_msg **msg)
{
memset(_faked_sip_msg_buf, 0, FAKED_SIP_MSG_BUF_LEN);
sprintf(_faked_sip_msg_buf, FAKED_SIP_MSG_FORMAT, from_tag->len, from_tag->s,
to_tag->len, to_tag->s,
callid->len, callid->s);
memset(&_faked_msg, 0, sizeof(struct sip_msg));
_faked_msg.buf = _faked_sip_msg_buf;
_faked_msg.len = strlen(_faked_sip_msg_buf);
_faked_msg.set_global_address = default_global_address;
_faked_msg.set_global_port = default_global_port;
if (parse_msg(_faked_msg.buf, _faked_msg.len, &_faked_msg) != 0)
{
LM_ERR("parse_msg failed\n");
return -1;
}
_faked_msg.rcv.proto = PROTO_UDP;
_faked_msg.rcv.src_port = 5060;
_faked_msg.rcv.src_ip.u.addr32[0] = 0x7f000001;
_faked_msg.rcv.src_ip.af = AF_INET;
_faked_msg.rcv.src_ip.len = 4;
_faked_msg.rcv.dst_port = 5060;
_faked_msg.rcv.dst_ip.u.addr32[0] = 0x7f000001;
_faked_msg.rcv.dst_ip.af = AF_INET;
_faked_msg.rcv.dst_ip.len = 4;
*msg = &_faked_msg;
return 0;
}
static int readResponse(int type, int timeoutSecs)
{
int len;
JIF_t end;
int wait;
wait = timeoutSecs * HZ;
end = jiffies + wait;
do {
if ((len = netSockRead(s.conn, &dhcp_msg_buf, sizeof(dhcp_msg_buf), wait)) > 0) {
if(msg_for_me(len) == type) {
parse_msg(len);
return len;
}
}
wait = end - jiffies;
} while (wait > 0);
return -1;
}
int skip_media_changes(sip_msg_t *msg) {
if (parse_msg(msg->buf, msg->len, msg) == 0) {
if (msg->first_line.type == SIP_REQUEST) {
if (msg->REQ_METHOD == METHOD_INVITE) {
return 1;
}
} else if (msg->first_line.type == SIP_REPLY) {
if (parse_headers(msg, HDR_CSEQ_F, 0) != 0) {
return -1;
}
if (&msg->cseq == NULL || &msg->cseq->body.s == NULL) {
return -1;
}
unsigned int code = msg->REPLY_STATUS;
if (code >= 200 && code < 300 && get_cseq(msg)->method_id == METHOD_INVITE) {
return 1;
}
}
}
return -1;
}
int faked_msg_init(void)
{
if(_faked_msg_no>0)
return 0;
/* init faked sip msg */
memcpy(_faked_sip_buf, FAKED_SIP_MSG, FAKED_SIP_MSG_LEN);
_faked_sip_buf[FAKED_SIP_MSG_LEN] = '\0';
memset(&_faked_msg, 0, sizeof(struct sip_msg));
_faked_msg.buf=_faked_sip_buf;
_faked_msg.len=FAKED_SIP_MSG_LEN;
_faked_msg.set_global_address=default_global_address;
_faked_msg.set_global_port=default_global_port;
if (parse_msg(_faked_msg.buf, _faked_msg.len, &_faked_msg)!=0)
{
LM_ERR("parse_msg failed\n");
return -1;
}
_faked_msg.rcv.proto = PROTO_UDP;
_faked_msg.rcv.src_port = 5060;
_faked_msg.rcv.src_ip.u.addr32[0] = 0x7f000001;
_faked_msg.rcv.src_ip.af = AF_INET;
_faked_msg.rcv.src_ip.len = 4;
_faked_msg.rcv.dst_port = 5060;
_faked_msg.rcv.dst_ip.u.addr32[0] = 0x7f000001;
_faked_msg.rcv.dst_ip.af = AF_INET;
_faked_msg.rcv.dst_ip.len = 4;
return 0;
}
static PT_THREAD(handle_connection(void))
{
PT_BEGIN(&s.pt);
s.state = STATE_LISTENING;
do {
PT_WAIT_UNTIL(&s.pt, uip_newdata());
if(uip_newdata() && parse_msg()) {
s.state = STATE_HELLO_RECEIVED;
uip_flags &= (~UIP_NEWDATA);
break;
}
} while(s.state != STATE_HELLO_RECEIVED);
do {
send_request();
PT_WAIT_UNTIL(&s.pt, uip_newdata());
if(uip_newdata()) {
s.state = STATE_NAME_RECEIVED;
uip_flags &= (~UIP_NEWDATA);
break;
}
} while(s.state != STATE_NAME_RECEIVED);
send_response();
s.state = STATE_INIT;
PT_END(&s.pt);
}
int th_prepare_msg(sip_msg_t *msg)
{
if (parse_msg(msg->buf, msg->len, msg)!=0)
{
LM_DBG("outbuf buffer parsing failed!");
return 1;
}
if(msg->first_line.type==SIP_REQUEST)
{
if(!IS_SIP(msg))
{
LM_DBG("non sip request message\n");
return 1;
}
} else if(msg->first_line.type!=SIP_REPLY) {
LM_DBG("non sip message\n");
return 1;
}
if (parse_headers(msg, HDR_EOH_F, 0)==-1)
{
LM_DBG("parsing headers failed [[%.*s]]\n",
msg->len, msg->buf);
return 2;
}
/* force 2nd via parsing here - it helps checking it later */
if (parse_headers(msg, HDR_VIA2_F, 0)==-1
|| (msg->via2==0) || (msg->via2->error!=PARSE_OK))
{
LM_DBG("no second via in this message \n");
}
if(parse_from_header(msg)<0)
{
LM_ERR("cannot parse FROM header\n");
return 3;
}
if(parse_to_header(msg)<0 || msg->to==NULL)
{
LM_ERR("cannot parse TO header\n");
return 3;
}
if(get_to(msg)==NULL)
{
LM_ERR("cannot get TO header\n");
return 3;
}
if(msg->via1==NULL || msg->callid==NULL) {
LM_ERR("mandatory headers missing - via1: %p callid: %p\n",
msg->via1, msg->callid);
return 4;
}
return 0;
}
void pb2json(const Message* msg, std::string& str)
{
rapidjson::Value::AllocatorType allocator;
rapidjson::Value* json = parse_msg(msg, allocator);
json2string(json, str);
delete json;
}
int gzc_prepare_msg(sip_msg_t *msg)
{
if (parse_msg(msg->buf, msg->len, msg)!=0)
{
LM_DBG("outbuf buffer parsing failed!");
return 1;
}
if(msg->first_line.type==SIP_REQUEST)
{
if(!IS_SIP(msg) && !IS_HTTP(msg))
{
LM_DBG("non sip or http request\n");
return 1;
}
} else if(msg->first_line.type==SIP_REPLY) {
if(!IS_SIP_REPLY(msg) && !IS_HTTP_REPLY(msg))
{
LM_DBG("non sip or http response\n");
return 1;
}
} else {
LM_DBG("non sip or http message\n");
return 1;
}
if (parse_headers(msg, HDR_EOH_F, 0)==-1)
{
LM_DBG("parsing headers failed");
return 2;
}
return 0;
}
END_TEST
#ifdef HAVE_PARSE_PRINTF_FORMAT
/**
* Test parsing additional format strings, that are only supported if
* we're under glibc.
*/
START_TEST (test_positional_params)
{
char *msg;
struct json_object *jo;
ul_openlog ("umberlog/test_positional_params", 0, LOG_LOCAL0);
#define COMPLEX_FORMAT \
"%3$*5$.*2$hhd , %1$Lf , %4$.3s , %4$s", 1.0L, 5, (char)100, "prefix", -8
#define COMPLEX_RESULT "00100 , 1.000000 , pre , prefix"
msg = ul_format (LOG_DEBUG, COMPLEX_FORMAT,
"simple1", "value1",
"complex", COMPLEX_FORMAT,
"simple2", "value2",
NULL);
jo = parse_msg (msg);
free (msg);
verify_value (jo, "msg", COMPLEX_RESULT);
verify_value (jo, "simple1", "value1");
verify_value (jo, "complex", COMPLEX_RESULT);
verify_value (jo, "simple2", "value2");
json_object_put (jo);
ul_closelog ();
}
END_TEST
/**
* Test that ul_openlog() will ignore any LOG_UL_* flags.
*/
START_TEST (test_ul_openlog_flag_ignore)
{
char *msg;
struct json_object *jo;
ul_openlog ("umberlog/test_ul_openlog_flag_ignore", LOG_UL_NOIMPLICIT,
LOG_LOCAL0);
msg = ul_format (LOG_DEBUG, "hello, I'm %s!", __FUNCTION__, NULL);
jo = parse_msg (msg);
free (msg);
verify_value_exists (jo, "pid");
verify_value_exists (jo, "uid");
verify_value_exists (jo, "gid");
verify_value_exists (jo, "host");
json_object_put (jo);
ul_closelog ();
}
END_TEST
/**
* Test adding additional fields.
*/
START_TEST (test_additional_fields)
{
char *msg;
struct json_object *jo;
ul_openlog ("umberlog/test_additional_fields", 0, LOG_LOCAL0);
msg = ul_format (LOG_DEBUG, "testing 1, 2, 3...",
"random_number", "%d", 42,
"random_string", "fourty-two",
NULL);
jo = parse_msg (msg);
free (msg);
verify_value (jo, "msg", "testing 1, 2, 3...");
verify_value (jo, "random_number", "42");
verify_value (jo, "random_string", "fourty-two");
json_object_put (jo);
ul_closelog ();
}
END_TEST
/**
* Test that discovering priorities work, and the implicit pid
* overrides the explicit one.
*/
START_TEST (test_discover_priority)
{
char *msg, *pid;
struct json_object *jo;
ul_openlog ("umberlog/test_discover_priority", 0, LOG_LOCAL0);
ul_set_log_flags (LOG_UL_ALL);
msg = ul_format (LOG_DEBUG, "testing 1, 2, 3...",
"pid", "%d", getpid () + 42,
NULL);
jo = parse_msg (msg);
free (msg);
verify_value (jo, "msg", "testing 1, 2, 3...");
if (asprintf (&pid, "%d", getpid ()) == -1)
abort ();
verify_value (jo, "pid", pid);
free (pid);
json_object_put (jo);
ul_closelog ();
}
END_TEST
/**
* Test turning off the timestamp.
*/
START_TEST (test_no_timestamp)
{
char *msg;
struct json_object *jo;
ul_openlog ("umberlog/test_no_timestamp", 0, LOG_LOCAL0);
ul_set_log_flags (LOG_UL_NOTIME);
msg = ul_format (LOG_DEBUG, "hello, I'm %s!", __FUNCTION__, NULL);
jo = parse_msg (msg);
free (msg);
verify_value (jo, "msg", "hello, I'm test_no_timestamp!");
verify_value (jo, "facility", "local0");
verify_value (jo, "priority", "debug");
verify_value (jo, "program", "umberlog/test_no_timestamp");
verify_value_exists (jo, "pid");
verify_value_exists (jo, "uid");
verify_value_exists (jo, "gid");
verify_value_missing (jo, "timestamp");
verify_value_exists (jo, "host");
json_object_put (jo);
ul_closelog ();
}
static inline struct sip_msg *parse_ac_msg(hdr_flags_t flags,char *start,int len)
{
struct sip_msg *my_msg;
my_msg=NULL;
if(!(my_msg=pkg_malloc(sizeof(struct sip_msg)))){
LM_ERR("ac_reply: out of memory!\n");
goto error;
}
memset(my_msg,0,sizeof(struct sip_msg));
my_msg->buf=start;
my_msg->len=len;
LM_DBG("Action Message:[%.*s]\n",len,start);
if(0>parse_msg(start,len,my_msg)){
LM_ERR("parse_ac_msg: parsing sip_msg");
goto error;
}
if(0>parse_headers(my_msg,flags,0)){
LM_ERR("parse_ac_msg: parsing headers\n");
goto error;
}
return my_msg;
error:
if(my_msg){
free_sip_msg_lite(my_msg);
pkg_free(my_msg);
}
return NULL;
}
END_TEST
/**
* Test that setting LOG_UL_NOIMPLICIT will, indeed, turn off
* automatically discovered fields.
*/
START_TEST (test_no_implicit)
{
char *msg;
struct json_object *jo;
ul_openlog ("umberlog/test_no_implicit", 0, LOG_LOCAL0);
ul_set_log_flags (LOG_UL_NOIMPLICIT);
msg = ul_format (LOG_DEBUG, "hello, I'm %s!", __FUNCTION__, NULL);
jo = parse_msg (msg);
free (msg);
verify_value (jo, "msg", "hello, I'm test_no_implicit!");
verify_value_missing (jo, "facility");
verify_value_missing (jo, "priority");
verify_value_missing (jo, "program");
verify_value_missing (jo, "pid");
verify_value_missing (jo, "uid");
verify_value_missing (jo, "gid");
verify_value_missing (jo, "host");
verify_value_missing (jo, "timestamp");
json_object_put (jo);
ul_closelog ();
}
END_TEST
/**
* Test that using ul_openlog() does work, and sets up the program
* identity appropriately.
*/
START_TEST (test_ul_openlog)
{
char *msg;
struct json_object *jo;
char host[_POSIX_HOST_NAME_MAX + 1];
ul_openlog ("umberlog/test_ul_openlog", 0, LOG_LOCAL0);
msg = ul_format (LOG_DEBUG, "hello, I'm %s!", __FUNCTION__, NULL);
jo = parse_msg (msg);
free (msg);
gethostname (host, _POSIX_HOST_NAME_MAX);
verify_value (jo, "msg", "hello, I'm test_ul_openlog!");
verify_value (jo, "facility", "local0");
verify_value (jo, "priority", "debug");
verify_value (jo, "program", "umberlog/test_ul_openlog");
verify_value_exists (jo, "pid");
verify_value_exists (jo, "uid");
verify_value_exists (jo, "gid");
verify_value_exists (jo, "timestamp");
verify_value (jo, "host", host);
json_object_put (jo);
ul_closelog ();
}
static void stdin_cmd_poll(rarch_cmd_t *handle)
{
if (!handle->stdin_enable)
return;
size_t ret = read_stdin(handle->stdin_buf + handle->stdin_buf_ptr, STDIN_BUF_SIZE - handle->stdin_buf_ptr - 1);
if (ret == 0)
return;
handle->stdin_buf_ptr += ret;
handle->stdin_buf[handle->stdin_buf_ptr] = '\0';
char *last_newline = strrchr(handle->stdin_buf, '\n');
if (!last_newline)
{
// We're receiving bogus data in pipe (no terminating newline),
// flush out the buffer.
if (handle->stdin_buf_ptr + 1 >= STDIN_BUF_SIZE)
{
handle->stdin_buf_ptr = 0;
handle->stdin_buf[0] = '\0';
}
return;
}
*last_newline++ = '\0';
ptrdiff_t msg_len = last_newline - handle->stdin_buf;
parse_msg(handle, handle->stdin_buf);
memmove(handle->stdin_buf, last_newline, handle->stdin_buf_ptr - msg_len);
handle->stdin_buf_ptr -= msg_len;
}
static void network_cmd_poll(rarch_cmd_t *handle)
{
if (handle->net_fd < 0)
return;
fd_set fds;
FD_ZERO(&fds);
FD_SET(handle->net_fd, &fds);
struct timeval tmp_tv = {0};
if (select(handle->net_fd + 1, &fds, NULL, NULL, &tmp_tv) <= 0)
return;
if (!FD_ISSET(handle->net_fd, &fds))
return;
for (;;)
{
char buf[1024];
ssize_t ret = recvfrom(handle->net_fd, buf, sizeof(buf) - 1, 0, NULL, NULL);
if (ret <= 0)
break;
buf[ret] = '\0';
parse_msg(handle, buf);
}
}
static int dlg_cseq_prepare_new_msg(sip_msg_t *msg)
{
LM_DBG("prepare new msg for cseq update operations\n");
if (parse_msg(msg->buf, msg->len, msg)!=0) {
LM_DBG("outbuf buffer parsing failed!");
return 1;
}
return dlg_cseq_prepare_msg(msg);
}
static int xhttp_process_request(sip_msg_t* orig_msg,
char* new_buf, unsigned int new_len)
{
int ret;
sip_msg_t tmp_msg, *msg;
struct run_act_ctx ra_ctx;
ret=0;
if (new_buf && new_len)
{
memset(&tmp_msg, 0, sizeof(sip_msg_t));
tmp_msg.buf = new_buf;
tmp_msg.len = new_len;
tmp_msg.rcv = orig_msg->rcv;
tmp_msg.id = orig_msg->id;
tmp_msg.set_global_address = orig_msg->set_global_address;
tmp_msg.set_global_port = orig_msg->set_global_port;
if (parse_msg(new_buf, new_len, &tmp_msg) != 0)
{
LM_ERR("parse_msg failed\n");
goto error;
}
msg = &tmp_msg;
} else {
msg = orig_msg;
}
if ((msg->first_line.type != SIP_REQUEST) || (msg->via1 == 0) ||
(msg->via1->error != PARSE_OK))
{
LM_CRIT("strange message: %.*s\n", msg->len, msg->buf);
goto error;
}
if (exec_pre_script_cb(msg, REQUEST_CB_TYPE) == 0)
{
goto done;
}
init_run_actions_ctx(&ra_ctx);
if (run_actions(&ra_ctx, event_rt.rlist[xhttp_route_no], msg) < 0)
{
ret=-1;
LM_DBG("error while trying script\n");
goto done;
}
done:
exec_post_script_cb(msg, REQUEST_CB_TYPE);
if (msg != orig_msg)
{
free_sip_msg(msg);
}
return ret;
error:
return -1;
}
int test_bfcp_bin(void)
{
static const uint8_t msg[] =
"\x20\x04\x00\x04"
"\x00\x00\x00\x01"
"\x00\x01\x00\x01"
"\x1e\x10\x00\x01"
"\x24\x08\x00\x01"
"\x0a\x04\x03\x00"
"\x22\x04\x00\x02"
"";
int err = 0;
err |= parse_msg(msg, sizeof(msg) - 1);
err |= parse_msg(bfcp_msg, sizeof(bfcp_msg) - 1);
return err;
}
const char* filter_rx(const char *data, size_t len)
{
char *pos = filtered;
for(size_t i = 0; i < len; i++) {
const char ch = data[i];
if(!parse_msg((u08) ch))
parse_line(*pos++ = ch);
}
return *pos = '\0', filtered;
}
int dlg_th_callid_pre_parse(struct sip_msg *msg,int want_from)
{
#ifdef CHANGEABLE_DEBUG_LEVEL
int prev_dbg_level;
#endif
#ifdef CHANGEABLE_DEBUG_LEVEL
prev_dbg_level = *debug;
*debug = L_ALERT;
#endif
if (parse_msg(msg->buf,msg->len,msg)!=0) {
LM_ERR("Invalid SIP msg\n");
goto error;
}
if (parse_headers(msg,HDR_EOH_F,0)<0) {
LM_ERR("Failed to parse SIP headers\n");
goto error;
}
if (msg->cseq==NULL || get_cseq(msg)==NULL) {
LM_ERR("Failed to parse CSEQ header\n");
goto error;
}
if((get_cseq(msg)->method_id)&MSG_SKIP_BITMASK) {
LM_DBG("Skipping %d for DLG callid topo hiding\n",get_cseq(msg)->method_id);
goto error;
}
if (parse_to_header(msg)<0 || msg->to==NULL || get_to(msg)==NULL) {
LM_ERR("cannot parse TO header\n");
goto error;
}
if (parse_from_header(msg)<0 || msg->from==NULL || get_from(msg)==NULL) {
LM_ERR("cannot parse TO header\n");
goto error;
}
#ifdef CHANGEABLE_DEBUG_LEVEL
*debug = prev_dbg_level;
#endif
return 0;
error:
#ifdef CHANGEABLE_DEBUG_LEVEL
*debug = prev_dbg_level;
#endif
return -1;
}
int dlg_cseq_prepare_msg(sip_msg_t *msg)
{
if (parse_msg(msg->buf, msg->len, msg)!=0) {
LM_DBG("outbuf buffer parsing failed!");
return 1;
}
if(msg->first_line.type==SIP_REQUEST) {
if(!IS_SIP(msg))
{
LM_DBG("non sip request message\n");
return 1;
}
} else if(msg->first_line.type!=SIP_REPLY) {
LM_DBG("non sip message\n");
return 1;
}
if (parse_headers(msg, HDR_CSEQ_F, 0)==-1) {
LM_DBG("parsing cseq header failed\n");
return 2;
}
if(msg->first_line.type==SIP_REPLY) {
/* reply to local transaction -- nothing to do */
if (parse_headers(msg, HDR_VIA2_F, 0)==-1
|| (msg->via2==0) || (msg->via2->error!=PARSE_OK)) {
LM_DBG("no second via in this message \n");
return 3;
}
}
if(parse_from_header(msg)<0)
{
LM_ERR("cannot parse FROM header\n");
return 3;
}
if(parse_to_header(msg)<0 || msg->to==NULL)
{
LM_ERR("cannot parse TO header\n");
return 3;
}
if(get_to(msg)==NULL)
{
LM_ERR("cannot get TO header\n");
return 3;
}
return 0;
}
END_TEST
/**
* Test that closelog() does not clear the previous flag settings.
*/
START_TEST (test_closelog)
{
char *msg;
struct json_object *jo;
ul_openlog ("umberlog/test_closelog", 0, LOG_LOCAL0);
ul_set_log_flags (LOG_UL_NOIMPLICIT);
ul_closelog ();
msg = ul_format (LOG_DEBUG, "%s", __FUNCTION__, NULL);
jo = parse_msg (msg);
free (msg);
verify_value_missing (jo, "facility");
json_object_put (jo);
ul_openlog ("umberlog/test_closelog", 0, LOG_LOCAL0);
ul_closelog ();
msg = ul_format (LOG_DEBUG, "%s", __FUNCTION__, NULL);
jo = parse_msg (msg);
free (msg);
verify_value_missing (jo, "facility");
verify_value_missing (jo, "program");
verify_value_missing (jo, "pid");
verify_value_missing (jo, "uid");
verify_value_missing (jo, "gid");
verify_value_missing (jo, "host");
json_object_put (jo);
}
