/*---------------------------------------------------------------------------*/ 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); }