diff --git a/src/modules/debugger/debugger_act.c b/src/modules/debugger/debugger_act.c
index 842f4506f32..414f12b3aa4 100644
--- a/src/modules/debugger/debugger_act.c
+++ b/src/modules/debugger/debugger_act.c
@@ -31,88 +31,73 @@
 
 #include "debugger_act.h"
 
-typedef struct _dbg_action {
+typedef struct _dbg_action
+{
 	int type;
 	str name;
 } dbg_action_t;
 
-static str _dbg_action_special[] = {
-	str_init("unknown"),   /* 0 */
-	str_init("exit"),      /* 1 */
-	str_init("drop"),      /* 2 */
-	str_init("return"),    /* 3 */
-	{0, 0}
-};
+static str _dbg_action_special[] = {str_init("unknown"), /* 0 */
+		str_init("exit"),								 /* 1 */
+		str_init("drop"),								 /* 2 */
+		str_init("return"),								 /* 3 */
+		{0, 0}};
 
-static dbg_action_t _dbg_action_list[] = {
-	{ FORWARD_T, str_init("forward") },
-	{ LOG_T, str_init("log") },
-	{ ERROR_T, str_init("error") },
-	{ ROUTE_T, str_init("route") },
-	{ EXEC_T, str_init("exec") },
-	{ SET_HOST_T, str_init("sethost") },
-	{ SET_HOSTPORT_T, str_init("sethostport") },
-	{ SET_USER_T, str_init("setuser") },
-	{ SET_USERPASS_T, str_init("setuserpass") },
-	{ SET_PORT_T, str_init("setport") },
-	{ SET_URI_T, str_init("seturi") },
-	{ SET_HOSTPORTTRANS_T, str_init("sethostporttrans") },
-	{ SET_HOSTALL_T, str_init("sethostall") },
-	{ SET_USERPHONE_T, str_init("setuserphone") },
-	{ IF_T, str_init("if") },
-	{ SWITCH_T, str_init("switch") },
-	{ BLOCK_T, str_init("block") },
-	{ EVAL_T, str_init("eval") },
-	{ SWITCH_JT_T, str_init("switch") },
-	{ SWITCH_COND_T, str_init("switch") },
-	{ MATCH_COND_T, str_init("case") },
-	{ WHILE_T, str_init("while") },
-	{ SETFLAG_T, str_init("setflag") },
-	{ RESETFLAG_T, str_init("resetflag") },
-	{ ISFLAGSET_T, str_init("isflagset") },
-	{ AVPFLAG_OPER_T, str_init("avpflag") },
-	{ LEN_GT_T, str_init("lengt") },
-	{ PREFIX_T, str_init("prefix") },
-	{ STRIP_T, str_init("strip") },
-	{ STRIP_TAIL_T, str_init("striptail") },
-	{ APPEND_BRANCH_T, str_init("append_branch") },
-	{ REVERT_URI_T, str_init("reverturi") },
-	{ FORWARD_TCP_T, str_init("forward_tcp") },
-	{ FORWARD_UDP_T, str_init("forward_udp") },
-	{ FORWARD_TLS_T, str_init("forward_tls") },
-	{ FORWARD_SCTP_T, str_init("forward_sctp") },
-	{ FORCE_RPORT_T, str_init("force_rport") },
-	{ ADD_LOCAL_RPORT_T, str_init("add_local_rport") },
-	{ SET_ADV_ADDR_T, str_init("set_adv_addr") },
-	{ SET_ADV_PORT_T, str_init("set_adv_port") },
-	{ FORCE_TCP_ALIAS_T, str_init("force_tcp_alias") },
-	{ LOAD_AVP_T, str_init("load_avp") },
-	{ AVP_TO_URI_T, str_init("avp_to_uri") },
-	{ FORCE_SEND_SOCKET_T, str_init("force_send_socket") },
-	{ ASSIGN_T, str_init("assign") },
-	{ ADD_T, str_init("add") },
-	{ UDP_MTU_TRY_PROTO_T, str_init("udp_mtu_try_proto") },
-	{ SET_FWD_NO_CONNECT_T, str_init("set_fwd_no_connect") },
-	{ SET_RPL_NO_CONNECT_T, str_init("set_rpl_no_connect") },
-	{ SET_FWD_CLOSE_T, str_init("set_fwd_close") },
-	{ SET_RPL_CLOSE_T, str_init("set_rpl_close") },
-	{ 0, {0, 0} }
-};
+static dbg_action_t _dbg_action_list[] = {{FORWARD_T, str_init("forward")},
+		{LOG_T, str_init("log")}, {ERROR_T, str_init("error")},
+		{ROUTE_T, str_init("route")}, {EXEC_T, str_init("exec")},
+		{SET_HOST_T, str_init("sethost")},
+		{SET_HOSTPORT_T, str_init("sethostport")},
+		{SET_USER_T, str_init("setuser")},
+		{SET_USERPASS_T, str_init("setuserpass")},
+		{SET_PORT_T, str_init("setport")}, {SET_URI_T, str_init("seturi")},
+		{SET_HOSTPORTTRANS_T, str_init("sethostporttrans")},
+		{SET_HOSTALL_T, str_init("sethostall")},
+		{SET_USERPHONE_T, str_init("setuserphone")}, {IF_T, str_init("if")},
+		{SWITCH_T, str_init("switch")}, {BLOCK_T, str_init("block")},
+		{EVAL_T, str_init("eval")}, {SWITCH_JT_T, str_init("switch")},
+		{SWITCH_COND_T, str_init("switch")}, {MATCH_COND_T, str_init("case")},
+		{WHILE_T, str_init("while")}, {SETFLAG_T, str_init("setflag")},
+		{RESETFLAG_T, str_init("resetflag")},
+		{ISFLAGSET_T, str_init("isflagset")},
+		{AVPFLAG_OPER_T, str_init("avpflag")}, {LEN_GT_T, str_init("lengt")},
+		{PREFIX_T, str_init("prefix")}, {STRIP_T, str_init("strip")},
+		{STRIP_TAIL_T, str_init("striptail")},
+		{APPEND_BRANCH_T, str_init("append_branch")},
+		{REVERT_URI_T, str_init("reverturi")},
+		{FORWARD_TCP_T, str_init("forward_tcp")},
+		{FORWARD_UDP_T, str_init("forward_udp")},
+		{FORWARD_TLS_T, str_init("forward_tls")},
+		{FORWARD_SCTP_T, str_init("forward_sctp")},
+		{FORCE_RPORT_T, str_init("force_rport")},
+		{ADD_LOCAL_RPORT_T, str_init("add_local_rport")},
+		{SET_ADV_ADDR_T, str_init("set_adv_addr")},
+		{SET_ADV_PORT_T, str_init("set_adv_port")},
+		{FORCE_TCP_ALIAS_T, str_init("force_tcp_alias")},
+		{LOAD_AVP_T, str_init("load_avp")},
+		{AVP_TO_URI_T, str_init("avp_to_uri")},
+		{FORCE_SEND_SOCKET_T, str_init("force_send_socket")},
+		{ASSIGN_T, str_init("assign")}, {ADD_T, str_init("add")},
+		{UDP_MTU_TRY_PROTO_T, str_init("udp_mtu_try_proto")},
+		{SET_FWD_NO_CONNECT_T, str_init("set_fwd_no_connect")},
+		{SET_RPL_NO_CONNECT_T, str_init("set_rpl_no_connect")},
+		{SET_FWD_CLOSE_T, str_init("set_fwd_close")},
+		{SET_RPL_CLOSE_T, str_init("set_rpl_close")}, {0, {0, 0}}};
 
-str* dbg_get_action_name(struct action *a)
+str *dbg_get_action_name(struct action *a)
 {
 	int i;
 	static str aname;
 	cmd_export_t *cmd;
 
-	if(a==NULL)
+	if(a == NULL)
 		return &_dbg_action_special[0];
 
 	switch(a->type) {
 		case DROP_T:
-			if(a->val[1].u.number&DROP_R_F)
+			if(a->val[1].u.number & DROP_R_F)
 				return &_dbg_action_special[2];
-			if(a->val[1].u.number&RETURN_R_F)
+			if(a->val[1].u.number & RETURN_R_F)
 				return &_dbg_action_special[3];
 			return &_dbg_action_special[1];
 		case MODULE0_T:
@@ -130,14 +115,13 @@ str* dbg_get_action_name(struct action *a)
 		case MODULE5_RVE_T:
 		case MODULE6_RVE_T:
 		case MODULEX_RVE_T:
-			cmd = (cmd_export_t*)(a->val[0].u.data);
+			cmd = (cmd_export_t *)(a->val[0].u.data);
 			aname.s = cmd->name;
 			aname.len = strlen(aname.s);
 			return &aname;
 		default:
-			for(i=0; _dbg_action_list[i].type!=0; i++)
-			{
-				if(_dbg_action_list[i].type==a->type)
+			for(i = 0; _dbg_action_list[i].type != 0; i++) {
+				if(_dbg_action_list[i].type == a->type)
 					return &_dbg_action_list[i].name;
 			}
 	}
diff --git a/src/modules/debugger/debugger_act.h b/src/modules/debugger/debugger_act.h
index 37ea83c0ba6..7bc4f2a3bdb 100644
--- a/src/modules/debugger/debugger_act.h
+++ b/src/modules/debugger/debugger_act.h
@@ -21,14 +21,13 @@
  *
  */
 
-		       
+
 #ifndef _DEBUGGER_ACT_H_
 #define _DEBUGGER_ACT_H_
 
 #include "../../core/str.h"
-#include "../../core/route_struct.h"     
+#include "../../core/route_struct.h"
 
-str* dbg_get_action_name(struct action *a);
+str *dbg_get_action_name(struct action *a);
 
 #endif
-
diff --git a/src/modules/debugger/debugger_api.c b/src/modules/debugger/debugger_api.c
index b9137594bac..2ebdefaba0b 100644
--- a/src/modules/debugger/debugger_api.c
+++ b/src/modules/debugger/debugger_api.c
@@ -43,17 +43,12 @@
 
 #define DBG_CMD_SIZE 256
 
-#define DBG_STATE_INIT	0
-#define DBG_STATE_WAIT	1
-#define DBG_STATE_NEXT	2
-
-static str _dbg_state_list[] = {
-	str_init("unknown"),
-	str_init("init"),
-	str_init("wait"),
-	str_init("next"),
-	{0, 0}
-};
+#define DBG_STATE_INIT 0
+#define DBG_STATE_WAIT 1
+#define DBG_STATE_NEXT 2
+
+static str _dbg_state_list[] = {str_init("unknown"), str_init("init"),
+		str_init("wait"), str_init("next"), {0, 0}};
 
 str *dbg_get_state_name(int t)
 {
@@ -68,58 +63,44 @@ str *dbg_get_state_name(int t)
 	return &_dbg_state_list[0];
 }
 
-#define DBG_CFGTRACE_ON	(1<<0)
-#define DBG_ABKPOINT_ON	(1<<1)
-#define DBG_LBKPOINT_ON	(1<<2)
-#define DBG_CFGTEST_ON	(1<<3)
-
-static str _dbg_status_list[] = {
-	str_init("cfgtrace-on"),
-	str_init("cfgtrace-off"),
-	str_init("abkpoint-on"),
-	str_init("abkpoint-off"),
-	str_init("lbkpoint-on"),
-	str_init("lbkpoint-off"),
-	str_init("cfgtest-on"),
-	str_init("cfgtest-off"),
-	{0, 0}
-};
+#define DBG_CFGTRACE_ON (1 << 0)
+#define DBG_ABKPOINT_ON (1 << 1)
+#define DBG_LBKPOINT_ON (1 << 2)
+#define DBG_CFGTEST_ON (1 << 3)
+
+static str _dbg_status_list[] = {str_init("cfgtrace-on"),
+		str_init("cfgtrace-off"), str_init("abkpoint-on"),
+		str_init("abkpoint-off"), str_init("lbkpoint-on"),
+		str_init("lbkpoint-off"), str_init("cfgtest-on"),
+		str_init("cfgtest-off"), {0, 0}};
 
 str *dbg_get_status_name(int t)
 {
-	if(t&DBG_CFGTRACE_ON)
+	if(t & DBG_CFGTRACE_ON)
 		return &_dbg_status_list[0];
-	if(t&DBG_ABKPOINT_ON)
+	if(t & DBG_ABKPOINT_ON)
 		return &_dbg_status_list[2];
-	if(t&DBG_LBKPOINT_ON)
+	if(t & DBG_LBKPOINT_ON)
 		return &_dbg_status_list[4];
-	if(t&DBG_CFGTEST_ON)
+	if(t & DBG_CFGTEST_ON)
 		return &_dbg_status_list[6];
 
 	return &_dbg_state_list[0];
 }
 
-#define DBG_CMD_NOP		0
-#define DBG_CMD_ERR		1
-#define DBG_CMD_READ	2
-#define DBG_CMD_NEXT	3
-#define DBG_CMD_MOVE	4
-#define DBG_CMD_SHOW	5
-#define DBG_CMD_PVEVAL	6
-#define DBG_CMD_PVLOG	7
-
-
-static str _dbg_cmd_list[] = {
-	str_init("nop"),
-	str_init("err"),
-	str_init("read"),
-	str_init("next"),
-	str_init("move"),
-	str_init("show"),
-	str_init("pveval"),
-	str_init("pvlog"),
-	{0, 0}
-};
+#define DBG_CMD_NOP 0
+#define DBG_CMD_ERR 1
+#define DBG_CMD_READ 2
+#define DBG_CMD_NEXT 3
+#define DBG_CMD_MOVE 4
+#define DBG_CMD_SHOW 5
+#define DBG_CMD_PVEVAL 6
+#define DBG_CMD_PVLOG 7
+
+
+static str _dbg_cmd_list[] = {str_init("nop"), str_init("err"),
+		str_init("read"), str_init("next"), str_init("move"), str_init("show"),
+		str_init("pveval"), str_init("pvlog"), {0, 0}};
 
 str *dbg_get_cmd_name(int t)
 {
@@ -149,7 +130,7 @@ str *dbg_get_cmd_name(int t)
  */
 int _dbg_cfgtrace = 0;
 
-#define DBG_CFGTRACE_NOCFGFILE (1<<0)
+#define DBG_CFGTRACE_NOCFGFILE (1 << 0)
 /**
  *
  */
@@ -229,7 +210,7 @@ typedef struct _dbg_pid
 	dbg_cmd_t out;
 	gen_lock_t *lock;
 	unsigned int reset_msgid; /* flag to reset the id */
-	unsigned int msgid_base; /* real id since the reset */
+	unsigned int msgid_base;  /* real id since the reset */
 } dbg_pid_t;
 
 /**
@@ -275,34 +256,31 @@ int dbg_msgid_filter(struct sip_msg *msg, unsigned int flags, void *bar)
 	int indx = dbg_get_pid_index(process_no);
 	unsigned int msgid_base = 0;
 	unsigned int msgid_new = 0;
-	if(indx<0) return -1;
+	if(indx < 0)
+		return -1;
 	LM_DBG("process_no:%d indx:%d\n", process_no, indx);
 	lock_get(_dbg_pid_list[indx].lock);
-	if(_dbg_pid_list[indx].reset_msgid==1)
-	{
+	if(_dbg_pid_list[indx].reset_msgid == 1) {
 		LM_DBG("reset_msgid! msgid_base:%d\n", msg->id);
 		_dbg_pid_list[indx].reset_msgid = 0;
 		_dbg_pid_list[indx].msgid_base = msg->id - 1;
 	}
 	msgid_base = _dbg_pid_list[indx].msgid_base;
 	lock_release(_dbg_pid_list[indx].lock);
-	if(msg->id > msgid_base)
-	{
+	if(msg->id > msgid_base) {
 		msgid_new = msg->id - msgid_base;
-		LM_DBG("msg->id:%d msgid_base:%d -> %d\n",
-			msg->id, msgid_base, msgid_new);
+		LM_DBG("msg->id:%d msgid_base:%d -> %d\n", msg->id, msgid_base,
+				msgid_new);
 		msg->id = msgid_new;
-	}
-	else
-	{
+	} else {
 		LM_DBG("msg->id:%d already processed\n", msg->id);
 	}
 	return 1;
 }
 
-char* get_current_route_type_name()
+char *get_current_route_type_name()
 {
-	switch(route_type){
+	switch(route_type) {
 		case REQUEST_ROUTE:
 			return "request_route";
 		case FAILURE_ROUTE:
@@ -337,211 +315,175 @@ int dbg_cfg_trace(sr_event_param_t *evp)
 	int olen;
 	str pvn;
 	pv_spec_t pvs;
-    pv_value_t val;
+	pv_value_t val;
 	void **srevp;
 	str *an;
 
-	srevp = (void**)evp->data;
+	srevp = (void **)evp->data;
 
 	a = (struct action *)srevp[0];
 	msg = (struct sip_msg *)srevp[1];
 
-	if(a==NULL || msg==NULL || _dbg_pid_list==NULL)
+	if(a == NULL || msg == NULL || _dbg_pid_list == NULL)
 		return 0;
 
 	an = dbg_get_action_name(a);
 
-	if(_dbg_cfgpkgcheck!=0)
-	{
-#if defined (PKG_MEMORY) && defined (q_malloc_h)
-		LM_DBG("checking pkg memory before action %.*s (line %d)\n",
-				an->len, an->s, a->cline);
+	if(_dbg_cfgpkgcheck != 0) {
+#if defined(PKG_MEMORY) && defined(q_malloc_h)
+		LM_DBG("checking pkg memory before action %.*s (line %d)\n", an->len,
+				an->s, a->cline);
 		qm_check(mem_block);
 #else
 		LM_DBG("cfg pkg check is disabled due to missing qm handler\n");
 #endif
 	}
 
-	if(_dbg_pid_list[process_no].set&DBG_CFGTRACE_ON)
-	{
-		if(is_printable(_dbg_cfgtrace_level))
-		{
+	if(_dbg_pid_list[process_no].set & DBG_CFGTRACE_ON) {
+		if(is_printable(_dbg_cfgtrace_level)) {
 			if(unlikely(_dbg_cfgtrace_format & DBG_CFGTRACE_NOCFGFILE)) {
 				LOG_FL(_dbg_cfgtrace_facility, _dbg_cfgtrace_level,
 						_dbg_cfgtrace_lname, _dbg_cfgtrace_prefix,
 						"%s=[%s] l=%d a=%d n=%.*s\n",
-						get_current_route_type_name(), ZSW(a->rname),
-						a->cline,
-						a->type, an->len, ZSW(an->s)
-					);
+						get_current_route_type_name(), ZSW(a->rname), a->cline,
+						a->type, an->len, ZSW(an->s));
 			} else {
 				LOG_FL(_dbg_cfgtrace_facility, _dbg_cfgtrace_level,
 						_dbg_cfgtrace_lname, _dbg_cfgtrace_prefix,
 						"%s=[%s] c=[%s] l=%d a=%d n=%.*s\n",
 						get_current_route_type_name(), ZSW(a->rname),
-						ZSW(a->cfile), a->cline,
-						a->type, an->len, ZSW(an->s)
-					);
+						ZSW(a->cfile), a->cline, a->type, an->len, ZSW(an->s));
 			}
 		}
 	}
-	if(_dbg_pid_list[process_no].set&DBG_CFGTEST_ON)
-	{
-		if(_dbg_cfgt.cfgt_process_route(msg, a)<0)
-				LM_ERR("Error processing route\n");
+	if(_dbg_pid_list[process_no].set & DBG_CFGTEST_ON) {
+		if(_dbg_cfgt.cfgt_process_route(msg, a) < 0)
+			LM_ERR("Error processing route\n");
 	}
-	if(!(_dbg_pid_list[process_no].set&DBG_ABKPOINT_ON))
-	{
+	if(!(_dbg_pid_list[process_no].set & DBG_ABKPOINT_ON)) {
 		/* no breakpoints to be considered */
 		return 0;
 	}
 
-	if(_dbg_pid_list[process_no].state==DBG_STATE_INIT)
-	{
+	if(_dbg_pid_list[process_no].state == DBG_STATE_INIT) {
 		LOG(_dbg_cfgtrace_level,
-					"breakpoint hit: p=[%u] c=[%s] l=%d a=%d n=%.*s\n",
-					_dbg_pid_list[process_no].pid,
-					ZSW(a->cfile), a->cline, a->type, an->len, ZSW(an->s)
-				);
+				"breakpoint hit: p=[%u] c=[%s] l=%d a=%d n=%.*s\n",
+				_dbg_pid_list[process_no].pid, ZSW(a->cfile), a->cline, a->type,
+				an->len, ZSW(an->s));
 		_dbg_pid_list[process_no].in.cmd = DBG_CMD_NOP;
 		_dbg_pid_list[process_no].state = DBG_STATE_WAIT;
 	}
 
 	loop = 1;
-	while(loop)
-	{
-		switch(_dbg_pid_list[process_no].in.cmd)
-		{
+	while(loop) {
+		switch(_dbg_pid_list[process_no].in.cmd) {
 			case DBG_CMD_NOP:
-				sleep_us(_dbg_step_usleep); 
-			break;
+				sleep_us(_dbg_step_usleep);
+				break;
 			case DBG_CMD_MOVE:
 				loop = 0;
-				_dbg_pid_list[process_no].state=DBG_STATE_INIT;
+				_dbg_pid_list[process_no].state = DBG_STATE_INIT;
 				_dbg_pid_list[process_no].in.cmd = DBG_CMD_NOP;
 				_dbg_pid_list[process_no].in.pid = 0;
-			break;
+				break;
 			case DBG_CMD_NEXT:
 				loop = 0;
-				if(_dbg_pid_list[process_no].state==DBG_STATE_WAIT)
-					_dbg_pid_list[process_no].state=DBG_STATE_NEXT;
+				if(_dbg_pid_list[process_no].state == DBG_STATE_WAIT)
+					_dbg_pid_list[process_no].state = DBG_STATE_NEXT;
 				_dbg_pid_list[process_no].in.cmd = DBG_CMD_NOP;
-				olen = snprintf(_dbg_pid_list[process_no].out.buf,
-						DBG_CMD_SIZE,
-						"exec [%s:%d] a=%d n=%.*s",
-						ZSW(a->cfile), a->cline, a->type, an->len, ZSW(an->s));
-				if(olen<0)
-				{
+				olen = snprintf(_dbg_pid_list[process_no].out.buf, DBG_CMD_SIZE,
+						"exec [%s:%d] a=%d n=%.*s", ZSW(a->cfile), a->cline,
+						a->type, an->len, ZSW(an->s));
+				if(olen < 0) {
 					_dbg_pid_list[process_no].out.cmd = DBG_CMD_ERR;
 					break;
 				}
 				_dbg_pid_list[process_no].out.cmd = DBG_CMD_READ;
-			break;
+				break;
 			case DBG_CMD_PVEVAL:
 			case DBG_CMD_PVLOG:
 				loop = _dbg_pid_list[process_no].in.cmd;
 				_dbg_pid_list[process_no].in.cmd = DBG_CMD_NOP;
 				pvn.s = _dbg_pid_list[process_no].in.buf;
 				pvn.len = strlen(pvn.s);
-				if(pvn.len<=0)
-				{
+				if(pvn.len <= 0) {
 					LM_ERR("no pv to eval\n");
 					break;
 				}
 				LM_DBG("pv to eval: %s\n", pvn.s);
-				if(pv_parse_spec(&pvn, &pvs)<0)
-				{
+				if(pv_parse_spec(&pvn, &pvs) < 0) {
 					LM_ERR("unable to parse pv [%s]\n", pvn.s);
 					break;
 				}
 				memset(&val, 0, sizeof(pv_value_t));
-				if(pv_get_spec_value(msg, &pvs, &val) != 0)
-				{
+				if(pv_get_spec_value(msg, &pvs, &val) != 0) {
 					LM_ERR("unable to get pv value for [%s]\n", pvn.s);
 					break;
 				}
-				if(val.flags&PV_VAL_NULL)
-				{
-					if(loop==DBG_CMD_PVEVAL)
-					{
+				if(val.flags & PV_VAL_NULL) {
+					if(loop == DBG_CMD_PVEVAL) {
 						olen = snprintf(_dbg_pid_list[process_no].out.buf,
-							DBG_CMD_SIZE,
-							"%s : t=null",
-							pvn.s);
-						if(olen<0)
-						{
+								DBG_CMD_SIZE, "%s : t=null", pvn.s);
+						if(olen < 0) {
 							_dbg_pid_list[process_no].out.cmd = DBG_CMD_ERR;
 							break;
 						}
 						_dbg_pid_list[process_no].out.cmd = DBG_CMD_READ;
 					} else {
 						LOG(_dbg_cfgtrace_level,
-								"breakpoint eval: %s : t=null\n",
-								pvn.s
-							);
+								"breakpoint eval: %s : t=null\n", pvn.s);
 					}
 					break;
 				}
-				if(val.flags&PV_TYPE_INT)
-				{
-					if(loop==DBG_CMD_PVEVAL)
-					{
+				if(val.flags & PV_TYPE_INT) {
+					if(loop == DBG_CMD_PVEVAL) {
 						olen = snprintf(_dbg_pid_list[process_no].out.buf,
-							DBG_CMD_SIZE,
-							"%s : t=int v=%ld",
-							pvn.s, val.ri);
-						if(olen<0)
-						{
+								DBG_CMD_SIZE, "%s : t=int v=%ld", pvn.s,
+								val.ri);
+						if(olen < 0) {
 							_dbg_pid_list[process_no].out.cmd = DBG_CMD_ERR;
 							break;
 						}
 						_dbg_pid_list[process_no].out.cmd = DBG_CMD_READ;
 					} else {
 						LOG(_dbg_cfgtrace_level,
-								"breakpoint eval: %s : t=int v=%ld\n",
-								pvn.s, val.ri
-							);
+								"breakpoint eval: %s : t=int v=%ld\n", pvn.s,
+								val.ri);
 					}
 					break;
 				}
-		
-				if(loop==DBG_CMD_PVEVAL)
-				{
+
+				if(loop == DBG_CMD_PVEVAL) {
 					olen = snprintf(_dbg_pid_list[process_no].out.buf,
-						DBG_CMD_SIZE,
-						"%s : t=str v=%.*s",
-						pvn.s, val.rs.len, val.rs.s);
-					if(olen<0)
-					{
+							DBG_CMD_SIZE, "%s : t=str v=%.*s", pvn.s,
+							val.rs.len, val.rs.s);
+					if(olen < 0) {
 						_dbg_pid_list[process_no].out.cmd = DBG_CMD_ERR;
 						break;
 					}
 					_dbg_pid_list[process_no].out.cmd = DBG_CMD_READ;
 				} else {
 					LOG(_dbg_cfgtrace_level,
-							"breakpoint eval: %s : t=str v=%.*s\n",
-							pvn.s, val.rs.len, val.rs.s
-						);
+							"breakpoint eval: %s : t=str v=%.*s\n", pvn.s,
+							val.rs.len, val.rs.s);
 				}
-			break;
+				break;
 			case DBG_CMD_SHOW:
 				_dbg_pid_list[process_no].in.cmd = DBG_CMD_NOP;
 				_dbg_pid_list[process_no].out.cmd = DBG_CMD_NOP;
-				olen = snprintf(_dbg_pid_list[process_no].out.buf,
-						DBG_CMD_SIZE,
-						"at bkp [%s:%d] a=%d n=%.*s",
-						a->cfile, a->cline, a->type, an->len, an->s);
-				if(olen<0)
-				{
+				olen = snprintf(_dbg_pid_list[process_no].out.buf, DBG_CMD_SIZE,
+						"at bkp [%s:%d] a=%d n=%.*s", a->cfile, a->cline,
+						a->type, an->len, an->s);
+				if(olen < 0) {
 					_dbg_pid_list[process_no].out.cmd = DBG_CMD_ERR;
 					break;
 				}
 				_dbg_pid_list[process_no].out.cmd = DBG_CMD_READ;
-			break;
+				break;
 			default:
 				/* unknown command?!? - exit loop */
 				_dbg_pid_list[process_no].in.cmd = DBG_CMD_NOP;
-				_dbg_pid_list[process_no].state=DBG_STATE_INIT;
+				_dbg_pid_list[process_no].state = DBG_STATE_INIT;
 				loop = 0;
 		}
 	}
@@ -553,18 +495,17 @@ int dbg_cfg_trace(sr_event_param_t *evp)
  */
 int dbg_init_bp_list(void)
 {
-	if(_dbg_bp_list!=NULL)
+	if(_dbg_bp_list != NULL)
 		return -1;
-	_dbg_bp_list = (dbg_bp_t*)shm_malloc(sizeof(dbg_bp_t));
-	if(_dbg_bp_list==NULL)
-	{
+	_dbg_bp_list = (dbg_bp_t *)shm_malloc(sizeof(dbg_bp_t));
+	if(_dbg_bp_list == NULL) {
 		SHM_MEM_ERROR;
 		return -1;
 	}
 	memset(_dbg_bp_list, 0, sizeof(dbg_bp_t));
-	if(_dbg_breakpoint==1)
+	if(_dbg_breakpoint == 1)
 		_dbg_bp_list->set |= DBG_ABKPOINT_ON;
-	if(_dbg_cfgtrace==1)
+	if(_dbg_cfgtrace == 1)
 		_dbg_bp_list->set |= DBG_CFGTRACE_ON;
 	sr_event_register_cb(SREV_CFG_RUN_ACTION, dbg_cfg_trace);
 	return 0;
@@ -577,23 +518,22 @@ int dbg_add_breakpoint(struct action *a, int bpon)
 {
 	int len;
 	dbg_bp_t *nbp = NULL;
-	if(_dbg_bp_list==NULL)
+	if(_dbg_bp_list == NULL)
 		return -1;
 	len = strlen(a->cfile);
 	len += sizeof(dbg_bp_t) + 1;
-	nbp = (dbg_bp_t*)shm_malloc(len);
-	if(nbp==NULL)
-	{
+	nbp = (dbg_bp_t *)shm_malloc(len);
+	if(nbp == NULL) {
 		SHM_MEM_ERROR;
 		return -1;
 	}
 	memset(nbp, 0, len);
-	nbp->set |= (bpon)?DBG_ABKPOINT_ON:0;
+	nbp->set |= (bpon) ? DBG_ABKPOINT_ON : 0;
 	nbp->cline = a->cline;
-	nbp->cfile.s = (char*)nbp + sizeof(dbg_bp_t);
+	nbp->cfile.s = (char *)nbp + sizeof(dbg_bp_t);
 	strcpy(nbp->cfile.s, a->cfile);
 	nbp->cfile.len = strlen(nbp->cfile.s);
-	nbp->next =	_dbg_bp_list->next;
+	nbp->next = _dbg_bp_list->next;
 	_dbg_bp_list->next = nbp;
 	return 0;
 }
@@ -605,17 +545,16 @@ int dbg_init_pid_list(void)
 {
 	_dbg_pid_no = get_max_procs();
 
-	if(_dbg_pid_no<=0)
+	if(_dbg_pid_no <= 0)
 		return -1;
-	if(_dbg_pid_list!=NULL)
+	if(_dbg_pid_list != NULL)
 		return -1;
-	_dbg_pid_list = (dbg_pid_t*)shm_malloc(_dbg_pid_no*sizeof(dbg_pid_t));
-	if(_dbg_pid_list==NULL)
-	{
+	_dbg_pid_list = (dbg_pid_t *)shm_malloc(_dbg_pid_no * sizeof(dbg_pid_t));
+	if(_dbg_pid_list == NULL) {
 		SHM_MEM_ERROR;
 		return -1;
 	}
-	memset(_dbg_pid_list, 0, _dbg_pid_no*sizeof(dbg_pid_t));
+	memset(_dbg_pid_list, 0, _dbg_pid_no * sizeof(dbg_pid_t));
 	return 0;
 }
 
@@ -624,28 +563,25 @@ int dbg_init_pid_list(void)
  */
 int dbg_init_mypid(void)
 {
-	if(_dbg_pid_list==NULL)
+	if(_dbg_pid_list == NULL)
 		return -1;
-	if(process_no>=_dbg_pid_no)
+	if(process_no >= _dbg_pid_no)
 		return -1;
 	_dbg_pid_list[process_no].pid = (unsigned int)my_pid();
-	if(_dbg_breakpoint==1)
+	if(_dbg_breakpoint == 1)
 		_dbg_pid_list[process_no].set |= DBG_ABKPOINT_ON;
-	if(_dbg_cfgtrace==1)
+	if(_dbg_cfgtrace == 1)
 		_dbg_pid_list[process_no].set |= DBG_CFGTRACE_ON;
-	if(_dbg_cfgtest==1)
+	if(_dbg_cfgtest == 1)
 		_dbg_pid_list[process_no].set |= DBG_CFGTEST_ON;
-	if(_dbg_reset_msgid==1)
-	{
+	if(_dbg_reset_msgid == 1) {
 		LM_DBG("[%d] create locks\n", process_no);
 		_dbg_pid_list[process_no].lock = lock_alloc();
-		if(_dbg_pid_list[process_no].lock==NULL)
-		{
+		if(_dbg_pid_list[process_no].lock == NULL) {
 			LM_ERR("cannot allocate the lock\n");
 			return -1;
 		}
-		if(lock_init(_dbg_pid_list[process_no].lock)==NULL)
-		{
+		if(lock_init(_dbg_pid_list[process_no].lock) == NULL) {
 			LM_ERR("cannot init the lock\n");
 			lock_dealloc(_dbg_pid_list[process_no].lock);
 			return -1;
@@ -660,8 +596,7 @@ int dbg_init_mypid(void)
 int dbg_get_pid_index(unsigned int pid)
 {
 	int i;
-	for(i=0; i<_dbg_pid_no; i++)
-	{
+	for(i = 0; i < _dbg_pid_no; i++) {
 		if(_dbg_pid_list[i].pid == pid)
 			return i;
 	}
@@ -671,15 +606,12 @@ int dbg_get_pid_index(unsigned int pid)
 /**
  *
  */
-static const char* dbg_rpc_bp_doc[2] = {
-	"Breakpoint command",
-	0
-};
+static const char *dbg_rpc_bp_doc[2] = {"Breakpoint command", 0};
 
 /**
  *
  */
-static void  dbg_rpc_bp(rpc_t* rpc, void* ctx)
+static void dbg_rpc_bp(rpc_t *rpc, void *ctx)
 {
 	int i;
 	int limit;
@@ -688,23 +620,19 @@ static void  dbg_rpc_bp(rpc_t* rpc, void* ctx)
 	str val;
 	int loop;
 
-	if(_dbg_pid_list==NULL)
-	{
+	if(_dbg_pid_list == NULL) {
 		rpc->fault(ctx, 500, "Not initialized");
 		return;
 	}
-	if (rpc->scan(ctx, "S", &cmd) < 1)
-	{
+	if(rpc->scan(ctx, "S", &cmd) < 1) {
 		rpc->fault(ctx, 500, "Config breakpoint command missing");
 		return;
 	}
 	i = 0;
 	limit = _dbg_pid_no;
-	if (rpc->scan(ctx, "*d", &lpid) == 1)
-	{
+	if(rpc->scan(ctx, "*d", &lpid) == 1) {
 		i = dbg_get_pid_index((unsigned int)lpid);
-		if(i<0)
-		{
+		if(i < 0) {
 			rpc->fault(ctx, 500, "No such pid");
 			return;
 		}
@@ -712,74 +640,59 @@ static void  dbg_rpc_bp(rpc_t* rpc, void* ctx)
 	} else {
 		lpid = -1;
 	}
-	if(cmd.len==2 && strncmp(cmd.s, "on", 2)==0)
-	{
-		for(; i<limit; i++)
-		{
-			_dbg_pid_list[i].set |=  DBG_ABKPOINT_ON;
-			_dbg_pid_list[i].state=DBG_STATE_INIT;
+	if(cmd.len == 2 && strncmp(cmd.s, "on", 2) == 0) {
+		for(; i < limit; i++) {
+			_dbg_pid_list[i].set |= DBG_ABKPOINT_ON;
+			_dbg_pid_list[i].state = DBG_STATE_INIT;
 		}
-	} else if(cmd.len==3 && strncmp(cmd.s, "off", 3)==0) {
-		for(; i<limit; i++)
-		{
-			_dbg_pid_list[i].set &=  ~DBG_ABKPOINT_ON;
-			_dbg_pid_list[i].state=DBG_STATE_INIT;
+	} else if(cmd.len == 3 && strncmp(cmd.s, "off", 3) == 0) {
+		for(; i < limit; i++) {
+			_dbg_pid_list[i].set &= ~DBG_ABKPOINT_ON;
+			_dbg_pid_list[i].state = DBG_STATE_INIT;
 		}
-	} else if(cmd.len==7 && strncmp(cmd.s, "release", 7)==0) {
-		for(; i<limit; i++)
-		{
-			if(_dbg_pid_list[i].state!=DBG_STATE_WAIT)
-			{
-				_dbg_pid_list[i].set &=  ~DBG_ABKPOINT_ON;
-				_dbg_pid_list[i].state=DBG_STATE_INIT;
+	} else if(cmd.len == 7 && strncmp(cmd.s, "release", 7) == 0) {
+		for(; i < limit; i++) {
+			if(_dbg_pid_list[i].state != DBG_STATE_WAIT) {
+				_dbg_pid_list[i].set &= ~DBG_ABKPOINT_ON;
+				_dbg_pid_list[i].state = DBG_STATE_INIT;
 			}
 		}
-	} else if(cmd.len==4 && strncmp(cmd.s, "keep", 4)==0) {
-		if(lpid==-1)
-		{
+	} else if(cmd.len == 4 && strncmp(cmd.s, "keep", 4) == 0) {
+		if(lpid == -1) {
 			rpc->fault(ctx, 500, "Missing pid parameter");
 			return;
 		}
-		for(loop=0; loop<_dbg_pid_no; loop++)
-		{
-			if(i!=loop)
-			{
-				_dbg_pid_list[loop].set &=  ~DBG_ABKPOINT_ON;
-				if(_dbg_pid_list[loop].state!=DBG_STATE_INIT)
-				{
+		for(loop = 0; loop < _dbg_pid_no; loop++) {
+			if(i != loop) {
+				_dbg_pid_list[loop].set &= ~DBG_ABKPOINT_ON;
+				if(_dbg_pid_list[loop].state != DBG_STATE_INIT) {
 					_dbg_pid_list[loop].in.pid = my_pid();
 					_dbg_pid_list[loop].in.cmd = DBG_CMD_MOVE;
 				}
 			}
 		}
-	} else if(cmd.len==4 && strncmp(cmd.s, "move", 4)==0) {
-		if(lpid==-1)
-		{
+	} else if(cmd.len == 4 && strncmp(cmd.s, "move", 4) == 0) {
+		if(lpid == -1) {
 			rpc->fault(ctx, 500, "Missing pid parameter");
 			return;
 		}
-		for(; i<limit; i++)
-		{
-			if(_dbg_pid_list[i].state!=DBG_STATE_INIT)
-			{
-				_dbg_pid_list[i].set &=  ~DBG_ABKPOINT_ON;
+		for(; i < limit; i++) {
+			if(_dbg_pid_list[i].state != DBG_STATE_INIT) {
+				_dbg_pid_list[i].set &= ~DBG_ABKPOINT_ON;
 				_dbg_pid_list[i].in.pid = my_pid();
 				_dbg_pid_list[i].in.cmd = DBG_CMD_MOVE;
 			}
 		}
-	} else if(cmd.len==4 && strncmp(cmd.s, "next", 4)==0) {
-		if(lpid==-1)
-		{
+	} else if(cmd.len == 4 && strncmp(cmd.s, "next", 4) == 0) {
+		if(lpid == -1) {
 			rpc->fault(ctx, 500, "Missing pid parameter");
 			return;
 		}
 		_dbg_pid_list[i].in.pid = my_pid();
 		_dbg_pid_list[i].in.cmd = DBG_CMD_NEXT;
-		for(loop=0; loop<_dbg_step_loops; loop++)
-		{
+		for(loop = 0; loop < _dbg_step_loops; loop++) {
 			sleep_us(_dbg_step_usleep);
-			if(_dbg_pid_list[i].out.cmd == DBG_CMD_READ)
-			{
+			if(_dbg_pid_list[i].out.cmd == DBG_CMD_READ) {
 				rpc->add(ctx, "s", _dbg_pid_list[i].out.buf);
 				_dbg_pid_list[i].out.cmd = DBG_CMD_NOP;
 				return;
@@ -790,19 +703,16 @@ static void  dbg_rpc_bp(rpc_t* rpc, void* ctx)
 			}
 		}
 		/* nothing to read ... err?!? */
-	} else if(cmd.len==4 && strncmp(cmd.s, "show", 4)==0) {
-		if(lpid==-1)
-		{
+	} else if(cmd.len == 4 && strncmp(cmd.s, "show", 4) == 0) {
+		if(lpid == -1) {
 			rpc->fault(ctx, 500, "Missing pid parameter");
 			return;
 		}
 		_dbg_pid_list[i].in.pid = my_pid();
 		_dbg_pid_list[i].in.cmd = DBG_CMD_SHOW;
-		for(loop=0; loop<_dbg_step_loops; loop++)
-		{
+		for(loop = 0; loop < _dbg_step_loops; loop++) {
 			sleep_us(_dbg_step_usleep);
-			if(_dbg_pid_list[i].out.cmd == DBG_CMD_READ)
-			{
+			if(_dbg_pid_list[i].out.cmd == DBG_CMD_READ) {
 				rpc->add(ctx, "s", _dbg_pid_list[i].out.buf);
 				_dbg_pid_list[i].out.cmd = DBG_CMD_NOP;
 				return;
@@ -813,19 +723,16 @@ static void  dbg_rpc_bp(rpc_t* rpc, void* ctx)
 			}
 		}
 		/* nothing to read ... err?!? */
-	} else if(cmd.len==4 && strncmp(cmd.s, "eval", 4)==0) {
-		if(lpid==-1)
-		{
+	} else if(cmd.len == 4 && strncmp(cmd.s, "eval", 4) == 0) {
+		if(lpid == -1) {
 			rpc->fault(ctx, 500, "Missing pid parameter");
 			return;
 		}
-		if (rpc->scan(ctx, "S", &val) < 1)
-		{
+		if(rpc->scan(ctx, "S", &val) < 1) {
 			rpc->fault(ctx, 500, "pv param missing");
 			return;
 		}
-		if (val.len < 2 || val.len>=DBG_CMD_SIZE)
-		{
+		if(val.len < 2 || val.len >= DBG_CMD_SIZE) {
 			rpc->fault(ctx, 500, "invalid pv param");
 			return;
 		}
@@ -833,11 +740,9 @@ static void  dbg_rpc_bp(rpc_t* rpc, void* ctx)
 		_dbg_pid_list[i].in.buf[val.len] = '\0';
 		_dbg_pid_list[i].in.pid = my_pid();
 		_dbg_pid_list[i].in.cmd = DBG_CMD_PVEVAL;
-		for(loop=0; loop<_dbg_step_loops; loop++)
-		{
+		for(loop = 0; loop < _dbg_step_loops; loop++) {
 			sleep_us(_dbg_step_usleep);
-			if(_dbg_pid_list[i].out.cmd == DBG_CMD_READ)
-			{
+			if(_dbg_pid_list[i].out.cmd == DBG_CMD_READ) {
 				rpc->add(ctx, "s", _dbg_pid_list[i].out.buf);
 				_dbg_pid_list[i].out.cmd = DBG_CMD_NOP;
 				return;
@@ -848,19 +753,16 @@ static void  dbg_rpc_bp(rpc_t* rpc, void* ctx)
 			}
 		}
 		/* nothing to read ... err?!? */
-	} else if(cmd.len==3 && strncmp(cmd.s, "log", 3)==0) {
-		if(lpid==-1)
-		{
+	} else if(cmd.len == 3 && strncmp(cmd.s, "log", 3) == 0) {
+		if(lpid == -1) {
 			rpc->fault(ctx, 500, "Missing pid parameter");
 			return;
 		}
-		if (rpc->scan(ctx, "S", &val) < 1)
-		{
+		if(rpc->scan(ctx, "S", &val) < 1) {
 			rpc->fault(ctx, 500, "pv param missing");
 			return;
 		}
-		if (val.len < 2 || val.len>=DBG_CMD_SIZE)
-		{
+		if(val.len < 2 || val.len >= DBG_CMD_SIZE) {
 			rpc->fault(ctx, 500, "invalid pv param");
 			return;
 		}
@@ -877,56 +779,44 @@ static void  dbg_rpc_bp(rpc_t* rpc, void* ctx)
 /**
  *
  */
-static const char* dbg_rpc_list_doc[2] = {
-	"List debugging process array",
-	0
-};
+static const char *dbg_rpc_list_doc[2] = {"List debugging process array", 0};
 
 /**
  *
  */
-static void  dbg_rpc_list(rpc_t* rpc, void* ctx)
+static void dbg_rpc_list(rpc_t *rpc, void *ctx)
 {
 	int i;
 	int limit;
 	int lpid;
-	void* th;
+	void *th;
 
-	if(_dbg_pid_list==NULL)
-	{
+	if(_dbg_pid_list == NULL) {
 		rpc->fault(ctx, 500, "Not initialized");
 		return;
 	}
 	i = 0;
 	limit = _dbg_pid_no;
-	if (rpc->scan(ctx, "*d", &lpid) == 1)
-	{
+	if(rpc->scan(ctx, "*d", &lpid) == 1) {
 		i = dbg_get_pid_index((unsigned int)lpid);
-		if(i<0)
-		{
+		if(i < 0) {
 			rpc->fault(ctx, 500, "No such pid");
 			return;
 		}
 		limit = i + 1;
 	}
 
-	for(; i<limit; i++)
-	{
+	for(; i < limit; i++) {
 		/* add entry node */
-		if (rpc->add(ctx, "{", &th) < 0)
-		{
+		if(rpc->add(ctx, "{", &th) < 0) {
 			rpc->fault(ctx, 500, "Internal error creating rpc");
 			return;
 		}
-		if(rpc->struct_add(th, "dddddd",
-						"entry",  i,
-						"pid",    _dbg_pid_list[i].pid,
-						"set",    _dbg_pid_list[i].set,
-						"state",  _dbg_pid_list[i].state,
-						"in.pid", _dbg_pid_list[i].in.pid,
-						"in.cmd", _dbg_pid_list[i].in.cmd
-					)<0)
-		{
+		if(rpc->struct_add(th, "dddddd", "entry", i, "pid",
+				   _dbg_pid_list[i].pid, "set", _dbg_pid_list[i].set, "state",
+				   _dbg_pid_list[i].state, "in.pid", _dbg_pid_list[i].in.pid,
+				   "in.cmd", _dbg_pid_list[i].in.cmd)
+				< 0) {
 			rpc->fault(ctx, 500, "Internal error creating rpc");
 			return;
 		}
@@ -936,69 +826,56 @@ static void  dbg_rpc_list(rpc_t* rpc, void* ctx)
 /**
  *
  */
-static const char* dbg_rpc_trace_doc[2] = {
-	"Config trace command",
-	0
-};
+static const char *dbg_rpc_trace_doc[2] = {"Config trace command", 0};
 
 /**
  *
  */
-static void  dbg_rpc_trace(rpc_t* rpc, void* ctx)
+static void dbg_rpc_trace(rpc_t *rpc, void *ctx)
 {
 	int i;
 	int limit;
 	int lpid;
 	str cmd;
 
-	if(_dbg_pid_list==NULL)
-	{
+	if(_dbg_pid_list == NULL) {
 		rpc->fault(ctx, 500, "Not initialized");
 		return;
 	}
-	if (rpc->scan(ctx, "S", &cmd) < 1)
-	{
+	if(rpc->scan(ctx, "S", &cmd) < 1) {
 		rpc->fault(ctx, 500, "Config trace command missing");
 		return;
 	}
 	i = 0;
 	limit = _dbg_pid_no;
-	if (rpc->scan(ctx, "*d", &lpid) == 1)
-	{
+	if(rpc->scan(ctx, "*d", &lpid) == 1) {
 		i = dbg_get_pid_index((unsigned int)lpid);
-		if(i<0)
-		{
+		if(i < 0) {
 			rpc->fault(ctx, 500, "No such pid");
 			return;
 		}
 		limit = i + 1;
 	}
-	if(cmd.len!=2 && cmd.len!=3)
-	{
+	if(cmd.len != 2 && cmd.len != 3) {
 		rpc->fault(ctx, 500, "Unknown trace command");
 		return;
 	}
-	if(cmd.len==2)
-	{
-		if(strncmp(cmd.s, "on", 2)!=0)
-		{
+	if(cmd.len == 2) {
+		if(strncmp(cmd.s, "on", 2) != 0) {
 			rpc->fault(ctx, 500, "Unknown trace command");
 			return;
 		}
 	} else {
-		if(strncmp(cmd.s, "off", 3)!=0)
-		{
+		if(strncmp(cmd.s, "off", 3) != 0) {
 			rpc->fault(ctx, 500, "Unknown trace command");
 			return;
 		}
 	}
-	for(; i<limit; i++)
-	{
-		if(cmd.len==2)
-		{
-			_dbg_pid_list[i].set |=  DBG_CFGTRACE_ON;
+	for(; i < limit; i++) {
+		if(cmd.len == 2) {
+			_dbg_pid_list[i].set |= DBG_CFGTRACE_ON;
 		} else {
-			_dbg_pid_list[i].set &=  ~DBG_CFGTRACE_ON;
+			_dbg_pid_list[i].set &= ~DBG_CFGTRACE_ON;
 		}
 	}
 	rpc->add(ctx, "s", "200 ok");
@@ -1007,23 +884,19 @@ static void  dbg_rpc_trace(rpc_t* rpc, void* ctx)
 /**
  *
  */
-static const char* dbg_rpc_set_mod_level_doc[2] = {
-	"Set module log level",
-	0
-};
+static const char *dbg_rpc_set_mod_level_doc[2] = {"Set module log level", 0};
 
-static void dbg_rpc_set_mod_level(rpc_t* rpc, void* ctx){
+static void dbg_rpc_set_mod_level(rpc_t *rpc, void *ctx)
+{
 	int l;
-	str value = {0,0};
+	str value = {0, 0};
 
-	if (rpc->scan(ctx, "Sd", &value, &l) < 1)
-	{
+	if(rpc->scan(ctx, "Sd", &value, &l) < 1) {
 		rpc->fault(ctx, 500, "invalid parameters");
 		return;
 	}
 
-	if(dbg_set_mod_debug_level(value.s, value.len, &l)<0)
-	{
+	if(dbg_set_mod_debug_level(value.s, value.len, &l) < 0) {
 		rpc->fault(ctx, 500, "cannot store parameter");
 		return;
 	}
@@ -1033,31 +906,28 @@ static void dbg_rpc_set_mod_level(rpc_t* rpc, void* ctx){
 /**
  *
  */
-static const char* dbg_rpc_set_mod_facility_doc[2] = {
-	"Set module log facility",
-	0
-};
+static const char *dbg_rpc_set_mod_facility_doc[2] = {
+		"Set module log facility", 0};
 
-static void dbg_rpc_set_mod_facility(rpc_t* rpc, void* ctx) {
+static void dbg_rpc_set_mod_facility(rpc_t *rpc, void *ctx)
+{
 	int fl;
 	str value = {0, 0};
 	str facility = {0, 0};
 
-	if (rpc->scan(ctx, "SS", &value, &facility) < 1)
-	{
-	    rpc->fault(ctx, 500, "invalid parameters");
-	    return;
+	if(rpc->scan(ctx, "SS", &value, &facility) < 1) {
+		rpc->fault(ctx, 500, "invalid parameters");
+		return;
 	}
 
-	if ((fl = str2facility(facility.s)) == -1) {
-	    rpc->fault(ctx, 500, "facility not found");
-	    return;
+	if((fl = str2facility(facility.s)) == -1) {
+		rpc->fault(ctx, 500, "facility not found");
+		return;
 	}
 
-	if(dbg_set_mod_debug_facility(value.s, value.len, &fl) < 0)
-	{
-	    rpc->fault(ctx, 500, "cannot store parameter");
-	    return;
+	if(dbg_set_mod_debug_facility(value.s, value.len, &fl) < 0) {
+		rpc->fault(ctx, 500, "cannot store parameter");
+		return;
 	}
 	rpc->add(ctx, "s", "200 ok");
 }
@@ -1065,17 +935,14 @@ static void dbg_rpc_set_mod_facility(rpc_t* rpc, void* ctx) {
 /**
  *
  */
-static const char* dbg_rpc_get_mod_level_doc[2] = {
-	"Get module log level",
-	0
-};
+static const char *dbg_rpc_get_mod_level_doc[2] = {"Get module log level", 0};
 
-static void dbg_rpc_get_mod_level(rpc_t* rpc, void* ctx){
+static void dbg_rpc_get_mod_level(rpc_t *rpc, void *ctx)
+{
 	int l;
-	str value = {0,0};
+	str value = {0, 0};
 
-	if (rpc->scan(ctx, "S", &value) < 1)
-	{
+	if(rpc->scan(ctx, "S", &value) < 1) {
 		rpc->fault(ctx, 500, "invalid parameters");
 		return;
 	}
@@ -1088,20 +955,18 @@ static void dbg_rpc_get_mod_level(rpc_t* rpc, void* ctx){
 /**
  *
  */
-static const char* dbg_rpc_get_mod_facility_doc[2] = {
-	"Get module log facility",
-	0
-};
+static const char *dbg_rpc_get_mod_facility_doc[2] = {
+		"Get module log facility", 0};
 
-static void dbg_rpc_get_mod_facility(rpc_t* rpc, void* ctx) {
+static void dbg_rpc_get_mod_facility(rpc_t *rpc, void *ctx)
+{
 	int fl;
 	str value = {0, 0};
 	str facility = {0, 0};
 
-	if (rpc->scan(ctx, "S", &value) < 1)
-	{
-	    rpc->fault(ctx, 500, "invalid parameters");
-	    return;
+	if(rpc->scan(ctx, "S", &value) < 1) {
+		rpc->fault(ctx, 500, "invalid parameters");
+		return;
 	}
 
 	fl = get_debug_facility(value.s, value.len);
@@ -1114,28 +979,23 @@ static void dbg_rpc_get_mod_facility(rpc_t* rpc, void* ctx) {
 /**
  *
  */
-static const char* dbg_rpc_reset_msgid_doc[2] = {
-	"Reset msgid on all process",
-	0
-};
+static const char *dbg_rpc_reset_msgid_doc[2] = {
+		"Reset msgid on all process", 0};
 
-static void dbg_rpc_reset_msgid(rpc_t* rpc, void* ctx){
+static void dbg_rpc_reset_msgid(rpc_t *rpc, void *ctx)
+{
 	int i;
-	if (_dbg_reset_msgid==0)
-	{
+	if(_dbg_reset_msgid == 0) {
 		rpc->fault(ctx, 500, "reset_msgid is 0. Set it to 1 to enable.");
 		return;
 	}
-	if(_dbg_pid_list==NULL)
-	{
+	if(_dbg_pid_list == NULL) {
 		rpc->fault(ctx, 500, "_dbg_pid_list is NULL");
 		return;
 	}
 	LM_DBG("set reset_msgid\n");
-	for(i=0; i<_dbg_pid_no; i++)
-	{
-		if (_dbg_pid_list[i].lock!=NULL)
-		{
+	for(i = 0; i < _dbg_pid_no; i++) {
+		if(_dbg_pid_list[i].lock != NULL) {
 			lock_get(_dbg_pid_list[i].lock);
 			_dbg_pid_list[i].reset_msgid = 1;
 			lock_release(_dbg_pid_list[i].lock);
@@ -1147,39 +1007,42 @@ static void dbg_rpc_reset_msgid(rpc_t* rpc, void* ctx){
 /**
  *
  */
-rpc_export_t dbg_rpc[] = {
-	{"dbg.bp",        dbg_rpc_bp,        dbg_rpc_bp_doc,        0},
-	{"dbg.ls",        dbg_rpc_list,      dbg_rpc_list_doc,      0},
-	{"dbg.trace",     dbg_rpc_trace,     dbg_rpc_trace_doc,     0},
-	{"dbg.set_mod_level", dbg_rpc_set_mod_level, dbg_rpc_set_mod_level_doc, 0},
-	{"dbg.set_mod_facility", dbg_rpc_set_mod_facility, dbg_rpc_set_mod_facility_doc, 0},
-	{"dbg.get_mod_level", dbg_rpc_get_mod_level, dbg_rpc_get_mod_level_doc, 0},
-	{"dbg.get_mod_facility", dbg_rpc_get_mod_facility, dbg_rpc_get_mod_facility_doc, 0},
-	{"dbg.reset_msgid", dbg_rpc_reset_msgid, dbg_rpc_reset_msgid_doc, 0},
-	{0, 0, 0, 0}
-};
+rpc_export_t dbg_rpc[] = {{"dbg.bp", dbg_rpc_bp, dbg_rpc_bp_doc, 0},
+		{"dbg.ls", dbg_rpc_list, dbg_rpc_list_doc, 0},
+		{"dbg.trace", dbg_rpc_trace, dbg_rpc_trace_doc, 0},
+		{"dbg.set_mod_level", dbg_rpc_set_mod_level, dbg_rpc_set_mod_level_doc,
+				0},
+		{"dbg.set_mod_facility", dbg_rpc_set_mod_facility,
+				dbg_rpc_set_mod_facility_doc, 0},
+		{"dbg.get_mod_level", dbg_rpc_get_mod_level, dbg_rpc_get_mod_level_doc,
+				0},
+		{"dbg.get_mod_facility", dbg_rpc_get_mod_facility,
+				dbg_rpc_get_mod_facility_doc, 0},
+		{"dbg.reset_msgid", dbg_rpc_reset_msgid, dbg_rpc_reset_msgid_doc, 0},
+		{0, 0, 0, 0}};
 
 /**
  *
  */
 int dbg_init_rpc(void)
 {
-	if (rpc_register_array(dbg_rpc)!=0)
-	{
+	if(rpc_register_array(dbg_rpc) != 0) {
 		LM_ERR("failed to register RPC commands\n");
 		return -1;
 	}
 	return 0;
 }
 
-typedef struct _dbg_mod_level {
+typedef struct _dbg_mod_level
+{
 	str name;
 	unsigned int hashid;
 	int level;
 	struct _dbg_mod_level *next;
 } dbg_mod_level_t;
 
-typedef struct _dbg_mod_facility {
+typedef struct _dbg_mod_facility
+{
 	str name;
 	unsigned int hashid;
 	int facility;
@@ -1203,29 +1066,26 @@ static unsigned int _dbg_mod_table_size = 0;
 int dbg_init_mod_levels(int dbg_mod_hash_size)
 {
 	int i;
-	if(dbg_mod_hash_size<=0)
+	if(dbg_mod_hash_size <= 0)
 		return 0;
-	if(_dbg_mod_table!=NULL)
+	if(_dbg_mod_table != NULL)
 		return 0;
 	_dbg_mod_table_size = 1 << dbg_mod_hash_size;
-	_dbg_mod_table = (dbg_mod_slot_t*)shm_malloc(_dbg_mod_table_size*sizeof(dbg_mod_slot_t));
-	if(_dbg_mod_table==NULL)
-	{
+	_dbg_mod_table = (dbg_mod_slot_t *)shm_malloc(
+			_dbg_mod_table_size * sizeof(dbg_mod_slot_t));
+	if(_dbg_mod_table == NULL) {
 		SHM_MEM_ERROR;
 		return -1;
 	}
-	memset(_dbg_mod_table, 0, _dbg_mod_table_size*sizeof(dbg_mod_slot_t));
+	memset(_dbg_mod_table, 0, _dbg_mod_table_size * sizeof(dbg_mod_slot_t));
 	LM_DBG("Created _dbg_mod_table, size %d\n", _dbg_mod_table_size);
 
-	for(i=0; i<_dbg_mod_table_size; i++)
-	{
-		if(lock_init(&_dbg_mod_table[i].lock)==0 ||
-		   lock_init(&_dbg_mod_table[i].lock_ft)==0)
-		{
+	for(i = 0; i < _dbg_mod_table_size; i++) {
+		if(lock_init(&_dbg_mod_table[i].lock) == 0
+				|| lock_init(&_dbg_mod_table[i].lock_ft) == 0) {
 			LM_ERR("cannot initialize lock[%d]\n", i);
 			i--;
-			while(i>=0)
-			{
+			while(i >= 0) {
 				lock_destroy(&_dbg_mod_table[i].lock);
 				lock_destroy(&_dbg_mod_table[i].lock_ft);
 				i--;
@@ -1250,17 +1110,17 @@ int dbg_destroy_mod_levels()
 	dbg_mod_facility_t *itf = NULL;
 	dbg_mod_facility_t *itfp = NULL;
 
-	if (_dbg_mod_table_size <= 0)
+	if(_dbg_mod_table_size <= 0)
 		return 0;
 
-	if (_dbg_mod_table == NULL)
+	if(_dbg_mod_table == NULL)
 		return 0;
 
-	for (i = 0; i < _dbg_mod_table_size; i++) {
+	for(i = 0; i < _dbg_mod_table_size; i++) {
 		// destroy level list
 		lock_get(&_dbg_mod_table[i].lock);
 		itl = _dbg_mod_table[i].first;
-		while (itl) {
+		while(itl) {
 			itlp = itl;
 			itl = itl->next;
 			shm_free(itlp);
@@ -1270,7 +1130,7 @@ int dbg_destroy_mod_levels()
 		// destroy facility list
 		lock_get(&_dbg_mod_table[i].lock_ft);
 		itf = _dbg_mod_table[i].first_ft;
-		while (itf) {
+		while(itf) {
 			itfp = itf;
 			itf = itf->next;
 			shm_free(itfp);
@@ -1301,27 +1161,30 @@ int dbg_destroy_mod_levels()
  * - s1len - len of s1
  * return computed hash id
  */
-#define dbg_ch_h_inc h+=v^(v>>3)
-#define dbg_ch_icase(_c) (((_c)>='A'&&(_c)<='Z')?((_c)|0x20):(_c))
+#define dbg_ch_h_inc h += v ^ (v >> 3)
+#define dbg_ch_icase(_c) (((_c) >= 'A' && (_c) <= 'Z') ? ((_c) | 0x20) : (_c))
 static inline unsigned int dbg_compute_hash(char *s1, int s1len)
 {
 	char *p, *end;
 	register unsigned v;
 	register unsigned h;
 
-	h=0;
+	h = 0;
 
-	end=s1+s1len;
-	for ( p=s1 ; p<=(end-4) ; p+=4 ){
-		v=(dbg_ch_icase(*p)<<24)+(dbg_ch_icase(p[1])<<16)+(dbg_ch_icase(p[2])<<8)
-			+ dbg_ch_icase(p[3]);
+	end = s1 + s1len;
+	for(p = s1; p <= (end - 4); p += 4) {
+		v = (dbg_ch_icase(*p) << 24) + (dbg_ch_icase(p[1]) << 16)
+			+ (dbg_ch_icase(p[2]) << 8) + dbg_ch_icase(p[3]);
 		dbg_ch_h_inc;
 	}
-	v=0;
-	for (; p<end ; p++){ v<<=8; v+=dbg_ch_icase(*p);}
+	v = 0;
+	for(; p < end; p++) {
+		v <<= 8;
+		v += dbg_ch_icase(*p);
+	}
 	dbg_ch_h_inc;
 
-	h=((h)+(h>>11))+((h>>13)+(h>>23));
+	h = ((h) + (h >> 11)) + ((h >> 13) + (h >> 23));
 	return h;
 }
 
@@ -1333,28 +1196,25 @@ int dbg_set_mod_debug_level(char *mname, int mnlen, int *mlevel)
 	dbg_mod_level_t *itp;
 	dbg_mod_level_t *itn;
 
-	if(_dbg_mod_table==NULL)
+	if(_dbg_mod_table == NULL)
 		return -1;
 
 	hid = dbg_compute_hash(mname, mnlen);
-	idx = hid&(_dbg_mod_table_size-1);
+	idx = hid & (_dbg_mod_table_size - 1);
 
 	lock_get(&_dbg_mod_table[idx].lock);
 	it = _dbg_mod_table[idx].first;
 	itp = NULL;
-	while(it!=NULL && it->hashid < hid) {
+	while(it != NULL && it->hashid < hid) {
 		itp = it;
 		it = it->next;
 	}
-	while(it!=NULL && it->hashid==hid)
-	{
-		if(mnlen==it->name.len
-				&& strncmp(mname, it->name.s, mnlen)==0)
-		{
+	while(it != NULL && it->hashid == hid) {
+		if(mnlen == it->name.len && strncmp(mname, it->name.s, mnlen) == 0) {
 			/* found */
-			if(mlevel==NULL) {
+			if(mlevel == NULL) {
 				/* remove */
-				if(itp!=NULL) {
+				if(itp != NULL) {
 					itp->next = it->next;
 				} else {
 					_dbg_mod_table[idx].first = it->next;
@@ -1372,25 +1232,25 @@ int dbg_set_mod_debug_level(char *mname, int mnlen, int *mlevel)
 	}
 	lock_release(&_dbg_mod_table[idx].lock);
 	/* not found - add */
-	if(mlevel==NULL) {
+	if(mlevel == NULL) {
 		return 0;
 	}
-	itn = (dbg_mod_level_t*)shm_malloc(sizeof(dbg_mod_level_t) + (mnlen+1)*sizeof(char));
-	if(itn==NULL)
-	{
+	itn = (dbg_mod_level_t *)shm_malloc(
+			sizeof(dbg_mod_level_t) + (mnlen + 1) * sizeof(char));
+	if(itn == NULL) {
 		SHM_MEM_ERROR;
 		return -1;
 	}
-	memset(itn, 0, sizeof(dbg_mod_level_t) + (mnlen+1)*sizeof(char));
-	itn->level    = *mlevel;
-	itn->hashid   = hid;
-	itn->name.s   = (char*)(itn) + sizeof(dbg_mod_level_t);
+	memset(itn, 0, sizeof(dbg_mod_level_t) + (mnlen + 1) * sizeof(char));
+	itn->level = *mlevel;
+	itn->hashid = hid;
+	itn->name.s = (char *)(itn) + sizeof(dbg_mod_level_t);
 	itn->name.len = mnlen;
 	strncpy(itn->name.s, mname, mnlen);
 	itn->name.s[itn->name.len] = '\0';
 
 	lock_get(&_dbg_mod_table[idx].lock);
-	if(itp==NULL) {
+	if(itp == NULL) {
 		itn->next = _dbg_mod_table[idx].first;
 		_dbg_mod_table[idx].first = itn;
 	} else {
@@ -1399,7 +1259,6 @@ int dbg_set_mod_debug_level(char *mname, int mnlen, int *mlevel)
 	}
 	lock_release(&_dbg_mod_table[idx].lock);
 	return 0;
-
 }
 
 int dbg_set_mod_debug_facility(char *mname, int mnlen, int *mfacility)
@@ -1410,28 +1269,25 @@ int dbg_set_mod_debug_facility(char *mname, int mnlen, int *mfacility)
 	dbg_mod_facility_t *itp;
 	dbg_mod_facility_t *itn;
 
-	if(_dbg_mod_table==NULL)
+	if(_dbg_mod_table == NULL)
 		return -1;
 
 	hid = dbg_compute_hash(mname, mnlen);
-	idx = hid&(_dbg_mod_table_size-1);
+	idx = hid & (_dbg_mod_table_size - 1);
 
 	lock_get(&_dbg_mod_table[idx].lock_ft);
 	it = _dbg_mod_table[idx].first_ft;
 	itp = NULL;
-	while(it!=NULL && it->hashid < hid) {
+	while(it != NULL && it->hashid < hid) {
 		itp = it;
 		it = it->next;
 	}
-	while(it!=NULL && it->hashid==hid)
-	{
-		if(mnlen==it->name.len
-				&& strncmp(mname, it->name.s, mnlen)==0)
-		{
+	while(it != NULL && it->hashid == hid) {
+		if(mnlen == it->name.len && strncmp(mname, it->name.s, mnlen) == 0) {
 			/* found */
-			if(mfacility==NULL) {
+			if(mfacility == NULL) {
 				/* remove */
-				if(itp!=NULL) {
+				if(itp != NULL) {
 					itp->next = it->next;
 				} else {
 					_dbg_mod_table[idx].first_ft = it->next;
@@ -1449,24 +1305,25 @@ int dbg_set_mod_debug_facility(char *mname, int mnlen, int *mfacility)
 	}
 	lock_release(&_dbg_mod_table[idx].lock_ft);
 	/* not found - add */
-	if(mfacility==NULL) {
+	if(mfacility == NULL) {
 		return 0;
 	}
-	itn = (dbg_mod_facility_t*)shm_malloc(sizeof(dbg_mod_facility_t) + (mnlen+1)*sizeof(char));
-	if(itn==NULL) {
+	itn = (dbg_mod_facility_t *)shm_malloc(
+			sizeof(dbg_mod_facility_t) + (mnlen + 1) * sizeof(char));
+	if(itn == NULL) {
 		SHM_MEM_ERROR;
 		return -1;
 	}
-	memset(itn, 0, sizeof(dbg_mod_facility_t) + (mnlen+1)*sizeof(char));
+	memset(itn, 0, sizeof(dbg_mod_facility_t) + (mnlen + 1) * sizeof(char));
 	itn->facility = *mfacility;
-	itn->hashid   = hid;
-	itn->name.s   = (char*)(itn) + sizeof(dbg_mod_facility_t);
+	itn->hashid = hid;
+	itn->name.s = (char *)(itn) + sizeof(dbg_mod_facility_t);
 	itn->name.len = mnlen;
 	strncpy(itn->name.s, mname, mnlen);
 	itn->name.s[itn->name.len] = '\0';
 
 	lock_get(&_dbg_mod_table[idx].lock_ft);
-	if(itp==NULL) {
+	if(itp == NULL) {
 		itn->next = _dbg_mod_table[idx].first_ft;
 		_dbg_mod_table[idx].first_ft = itn;
 	} else {
@@ -1475,7 +1332,6 @@ int dbg_set_mod_debug_facility(char *mname, int mnlen, int *mfacility)
 	}
 	lock_release(&_dbg_mod_table[idx].lock_ft);
 	return 0;
-
 }
 
 static int _dbg_get_mod_debug_level = 0;
@@ -1487,31 +1343,28 @@ int dbg_get_mod_debug_level(char *mname, int mnlen, int *mlevel)
 	/* no LOG*() usage in this function and those executed inside it
 	 * - use fprintf(stderr, ...) if need for troubleshooting
 	 * - it will loop otherwise */
-	if(_dbg_mod_table==NULL)
+	if(_dbg_mod_table == NULL)
 		return -1;
 
-	if (!dbg_cfg) {
+	if(!dbg_cfg) {
 		return -1;
 	}
 
-	if(cfg_get(dbg, dbg_cfg, mod_level_mode)==0)
+	if(cfg_get(dbg, dbg_cfg, mod_level_mode) == 0)
 		return -1;
 
-	if(_dbg_get_mod_debug_level!=0)
+	if(_dbg_get_mod_debug_level != 0)
 		return -1;
 	_dbg_get_mod_debug_level = 1;
 
 	hid = dbg_compute_hash(mname, mnlen);
-	idx = hid&(_dbg_mod_table_size-1);
+	idx = hid & (_dbg_mod_table_size - 1);
 	lock_get(&_dbg_mod_table[idx].lock);
 	it = _dbg_mod_table[idx].first;
-	while(it!=NULL && it->hashid < hid)
+	while(it != NULL && it->hashid < hid)
 		it = it->next;
-	while(it!=NULL && it->hashid == hid)
-	{
-		if(mnlen==it->name.len
-				&& strncmp(mname, it->name.s, mnlen)==0)
-		{
+	while(it != NULL && it->hashid == hid) {
+		if(mnlen == it->name.len && strncmp(mname, it->name.s, mnlen) == 0) {
 			/* found */
 			*mlevel = it->level;
 			lock_release(&_dbg_mod_table[idx].lock);
@@ -1534,34 +1387,31 @@ int dbg_get_mod_debug_facility(char *mname, int mnlen, int *mfacility)
 	/* no LOG*() usage in this function and those executed inside it
 	 * - use fprintf(stderr, ...) if need for troubleshooting
 	 * - it will loop otherwise */
-	if(_dbg_mod_table==NULL)
+	if(_dbg_mod_table == NULL)
 		return -1;
 
-	if (!dbg_cfg) {
+	if(!dbg_cfg) {
 		return -1;
 	}
 
-	if(cfg_get(dbg, dbg_cfg, mod_facility_mode)==0)
+	if(cfg_get(dbg, dbg_cfg, mod_facility_mode) == 0)
 		return -1;
 
-	if(_dbg_get_mod_debug_facility!=0)
+	if(_dbg_get_mod_debug_facility != 0)
 		return -1;
 	_dbg_get_mod_debug_facility = 1;
 
 	hid = dbg_compute_hash(mname, mnlen);
-	idx = hid&(_dbg_mod_table_size-1);
+	idx = hid & (_dbg_mod_table_size - 1);
 	lock_get(&_dbg_mod_table[idx].lock_ft);
 	it = _dbg_mod_table[idx].first_ft;
-	while(it!=NULL && it->hashid < hid)
+	while(it != NULL && it->hashid < hid)
 		it = it->next;
-	while(it!=NULL && it->hashid == hid)
-	{
-		if(mnlen==it->name.len
-				&& strncmp(mname, it->name.s, mnlen)==0)
-		{
+	while(it != NULL && it->hashid == hid) {
+		if(mnlen == it->name.len && strncmp(mname, it->name.s, mnlen) == 0) {
 			/* found */
 			*mfacility = it->facility;
-		    lock_release(&_dbg_mod_table[idx].lock_ft);
+			lock_release(&_dbg_mod_table[idx].lock_ft);
 			_dbg_get_mod_debug_facility = 0;
 			return 0;
 		}
@@ -1577,21 +1427,22 @@ int dbg_get_mod_debug_facility(char *mname, int mnlen, int *mfacility)
  */
 void dbg_enable_mod_levels(void)
 {
-	if(_dbg_mod_table==NULL)
+	if(_dbg_mod_table == NULL)
 		return;
 	set_module_debug_level_cb(dbg_get_mod_debug_level);
 }
 
 void dbg_enable_mod_facilities(void)
 {
-	if(_dbg_mod_table==NULL)
+	if(_dbg_mod_table == NULL)
 		return;
 	set_module_debug_facility_cb(dbg_get_mod_debug_facility);
 }
 
 #define DBG_PVCACHE_SIZE 32
 
-typedef struct _dbg_pvcache {
+typedef struct _dbg_pvcache
+{
 	pv_spec_t *spec;
 	str *pvname;
 	struct _dbg_pvcache *next;
@@ -1601,13 +1452,13 @@ static dbg_pvcache_t **_dbg_pvcache = NULL;
 
 int dbg_init_pvcache()
 {
-	_dbg_pvcache = (dbg_pvcache_t**)pkg_malloc(sizeof(dbg_pvcache_t*)*DBG_PVCACHE_SIZE);
-	if(_dbg_pvcache==NULL)
-	{
+	_dbg_pvcache = (dbg_pvcache_t **)pkg_malloc(
+			sizeof(dbg_pvcache_t *) * DBG_PVCACHE_SIZE);
+	if(_dbg_pvcache == NULL) {
 		SHM_MEM_ERROR;
 		return -1;
 	}
-	memset(_dbg_pvcache, 0, sizeof(dbg_pvcache_t*)*DBG_PVCACHE_SIZE);
+	memset(_dbg_pvcache, 0, sizeof(dbg_pvcache_t *) * DBG_PVCACHE_SIZE);
 	return 0;
 }
 
@@ -1616,31 +1467,26 @@ int dbg_assign_add(str *name, pv_spec_t *spec)
 	dbg_pvcache_t *pvn, *last, *next;
 	unsigned int pvid;
 
-	if(name==NULL||spec==NULL)
+	if(name == NULL || spec == NULL)
 		return -1;
 
-	if(_dbg_pvcache==NULL)
+	if(_dbg_pvcache == NULL)
 		return -1;
 
-	pvid = get_hash1_raw((char *)&spec, sizeof(pv_spec_t*));
-	pvn = (dbg_pvcache_t*)pkg_malloc(sizeof(dbg_pvcache_t));
-	if(pvn==NULL)
-	{
+	pvid = get_hash1_raw((char *)&spec, sizeof(pv_spec_t *));
+	pvn = (dbg_pvcache_t *)pkg_malloc(sizeof(dbg_pvcache_t));
+	if(pvn == NULL) {
 		SHM_MEM_ERROR;
 		return -1;
 	}
 	memset(pvn, 0, sizeof(dbg_pvcache_t));
 	pvn->pvname = name;
 	pvn->spec = spec;
-	next = _dbg_pvcache[pvid%DBG_PVCACHE_SIZE];
-	if(next==NULL)
-	{
-		_dbg_pvcache[pvid%DBG_PVCACHE_SIZE] = pvn;
-	}
-	else
-	{
-		while(next)
-		{
+	next = _dbg_pvcache[pvid % DBG_PVCACHE_SIZE];
+	if(next == NULL) {
+		_dbg_pvcache[pvid % DBG_PVCACHE_SIZE] = pvn;
+	} else {
+		while(next) {
 			last = next;
 			next = next->next;
 		}
@@ -1655,82 +1501,76 @@ str *_dbg_pvcache_lookup(pv_spec_t *spec)
 	unsigned int pvid;
 	str *name = NULL;
 
-	if(spec==NULL)
+	if(spec == NULL)
 		return NULL;
 
-	if(_dbg_pvcache==NULL)
+	if(_dbg_pvcache == NULL)
 		return NULL;
 
-	pvid = get_hash1_raw((char *)&spec, sizeof(pv_spec_t*));
-	pvi = _dbg_pvcache[pvid%DBG_PVCACHE_SIZE];
-	while(pvi)
-	{
-		if(pvi->spec==spec) {
+	pvid = get_hash1_raw((char *)&spec, sizeof(pv_spec_t *));
+	pvi = _dbg_pvcache[pvid % DBG_PVCACHE_SIZE];
+	while(pvi) {
+		if(pvi->spec == spec) {
 			return pvi->pvname;
 		}
 		pvi = pvi->next;
 	}
 	name = pv_cache_get_name(spec);
-	if(name!=NULL)
-	{
+	if(name != NULL) {
 		/*LM_DBG("Add name[%.*s] to pvcache\n", name->len, name->s);*/
 		dbg_assign_add(name, spec);
 	}
 	return name;
 }
 
-int _dbg_log_assign_action_avp(struct sip_msg* msg, struct lvalue* lv)
+int _dbg_log_assign_action_avp(struct sip_msg *msg, struct lvalue *lv)
 {
 	int_str avp_val;
-	avp_t* avp;
-	avp_spec_t* avp_s = &lv->lv.avps;
-	avp = search_avp_by_index(avp_s->type, avp_s->name,
-				&avp_val, avp_s->index);
-	if (likely(avp)){
-		if (avp->flags&(AVP_VAL_STR)){
+	avp_t *avp;
+	avp_spec_t *avp_s = &lv->lv.avps;
+	avp = search_avp_by_index(avp_s->type, avp_s->name, &avp_val, avp_s->index);
+	if(likely(avp)) {
+		if(avp->flags & (AVP_VAL_STR)) {
 			LM_DBG("%.*s:\"%.*s\"\n", avp_s->name.s.len, avp_s->name.s.s,
-				avp_val.s.len, avp_val.s.s);
-		}else{
-			LM_DBG("%.*s:%ld\n", avp_s->name.s.len, avp_s->name.s.s,
-				avp_val.n);
+					avp_val.s.len, avp_val.s.s);
+		} else {
+			LM_DBG("%.*s:%ld\n", avp_s->name.s.len, avp_s->name.s.s, avp_val.n);
 		}
 	}
 	return 0;
 }
 
-int _dbg_log_assign_action_pvar(struct sip_msg* msg, struct lvalue* lv)
+int _dbg_log_assign_action_pvar(struct sip_msg *msg, struct lvalue *lv)
 {
 	pv_value_t value;
-	pv_spec_t* pvar = lv->lv.pvs;
+	pv_spec_t *pvar = lv->lv.pvs;
 	str def_name = {"unknown", 7};
 	str *name = _dbg_pvcache_lookup(pvar);
 
-	if(name==NULL)
+	if(name == NULL)
 		name = &def_name;
-	if(pv_get_spec_value(msg, pvar, &value)!=0)
-	{
+	if(pv_get_spec_value(msg, pvar, &value) != 0) {
 		LM_ERR("can't get value\n");
 		return -1;
 	}
 
-	if(value.flags&(PV_VAL_NULL|PV_VAL_EMPTY|PV_VAL_NONE)){
+	if(value.flags & (PV_VAL_NULL | PV_VAL_EMPTY | PV_VAL_NONE)) {
 		LM_DBG("%.*s: $null\n", name->len, name->s);
-	}else if(value.flags&(PV_VAL_INT)){
+	} else if(value.flags & (PV_VAL_INT)) {
 		LM_DBG("%.*s:%ld\n", name->len, name->s, value.ri);
-	}else if(value.flags&(PV_VAL_STR)){
+	} else if(value.flags & (PV_VAL_STR)) {
 		LM_DBG("%.*s:\"%.*s\"\n", name->len, name->s, value.rs.len, value.rs.s);
 	}
 	return 0;
 }
 
-int dbg_log_assign(struct sip_msg* msg, struct lvalue *lv)
+int dbg_log_assign(struct sip_msg *msg, struct lvalue *lv)
 {
-	if(lv==NULL)
-	{
+	if(lv == NULL) {
 		LM_ERR("left value is NULL\n");
 		return -1;
 	}
-	switch(lv->type){
+	switch(lv->type) {
 		case LV_AVP:
 			return _dbg_log_assign_action_avp(msg, lv);
 			break;
@@ -1745,15 +1585,15 @@ int dbg_log_assign(struct sip_msg* msg, struct lvalue *lv)
 
 void dbg_enable_log_assign(void)
 {
-	if(_dbg_pvcache==NULL)
+	if(_dbg_pvcache == NULL)
 		return;
 	set_log_assign_action_cb(dbg_log_assign);
 }
 
-int dbg_mode_fixup(void *temp_handle,
-	str *group_name, str *var_name, void **value){
-	if(_dbg_mod_table==NULL)
-	{
+int dbg_mode_fixup(
+		void *temp_handle, str *group_name, str *var_name, void **value)
+{
+	if(_dbg_mod_table == NULL) {
 		LM_ERR("mod_hash_size must be set on start\n");
 		return -1;
 	}
diff --git a/src/modules/debugger/debugger_api.h b/src/modules/debugger/debugger_api.h
index 8d140404b71..58390912e0e 100644
--- a/src/modules/debugger/debugger_api.h
+++ b/src/modules/debugger/debugger_api.h
@@ -21,7 +21,7 @@
  *
  */
 
-		       
+
 #ifndef _DEBUGGER_API_H_
 #define _DEBUGGER_API_H_
 
@@ -53,12 +53,11 @@ void dbg_enable_log_assign(void);
  */
 int dbg_msgid_filter(struct sip_msg *msg, unsigned int flags, void *bar);
 
-#define DBG_DP_NULL			1
-#define DBG_DP_AVP			2
-#define DBG_DP_SCRIPTVAR	4
-#define DBG_DP_XAVP			8
-#define DBG_DP_OTHER		16
-#define DBG_DP_ALL			31
+#define DBG_DP_NULL 1
+#define DBG_DP_AVP 2
+#define DBG_DP_SCRIPTVAR 4
+#define DBG_DP_XAVP 8
+#define DBG_DP_OTHER 16
+#define DBG_DP_ALL 31
 
 #endif
-
diff --git a/src/modules/debugger/debugger_config.c b/src/modules/debugger/debugger_config.c
index 2c6dd38ccc4..e12b81a4fff 100644
--- a/src/modules/debugger/debugger_config.c
+++ b/src/modules/debugger/debugger_config.c
@@ -30,23 +30,22 @@
 
 #include "debugger_config.h"
 
-struct cfg_group_dbg	default_dbg_cfg = {
-	0, /* level_mode */
-	0, /* facility_mode */
-	0  /* hash_size */
+struct cfg_group_dbg default_dbg_cfg = {
+		0, /* level_mode */
+		0, /* facility_mode */
+		0  /* hash_size */
 };
 
 void *dbg_cfg = &default_dbg_cfg;
 
 cfg_def_t dbg_cfg_def[] = {
-	{"mod_level_mode", CFG_VAR_INT|CFG_ATOMIC, 0, 1,
-		dbg_mode_fixup, 0,
-		"Enable or disable per module log level (0 - disabled, 1 - enabled)"},
-	{"mod_facility_mode", CFG_VAR_INT|CFG_ATOMIC, 0, 1,
-		dbg_mode_fixup, 0,
-		"Enable or disable per module log facility (0 - disabled, 1 - enabled)"},
-	{"mod_hash_size", CFG_VAR_INT|CFG_READONLY, 0, 0,
-		0, 0,
-		"power of two as size of internal hash table to store levels per module"},
-	{0, 0, 0, 0, 0, 0}
-};
+		{"mod_level_mode", CFG_VAR_INT | CFG_ATOMIC, 0, 1, dbg_mode_fixup, 0,
+				"Enable or disable per module log level (0 - disabled, 1 - "
+				"enabled)"},
+		{"mod_facility_mode", CFG_VAR_INT | CFG_ATOMIC, 0, 1, dbg_mode_fixup, 0,
+				"Enable or disable per module log facility (0 - disabled, 1 - "
+				"enabled)"},
+		{"mod_hash_size", CFG_VAR_INT | CFG_READONLY, 0, 0, 0, 0,
+				"power of two as size of internal hash table to store levels "
+				"per module"},
+		{0, 0, 0, 0, 0, 0}};
diff --git a/src/modules/debugger/debugger_config.h b/src/modules/debugger/debugger_config.h
index 895b76b4d5b..9ea18319f98 100644
--- a/src/modules/debugger/debugger_config.h
+++ b/src/modules/debugger/debugger_config.h
@@ -32,16 +32,17 @@
 #include "../../core/cfg/cfg.h"
 #include "../../core/str.h"
 
-struct cfg_group_dbg {
+struct cfg_group_dbg
+{
 	unsigned int mod_level_mode;
 	unsigned int mod_facility_mode;
 	unsigned int mod_hash_size;
 };
 
-extern struct cfg_group_dbg	default_dbg_cfg;
-extern void	*dbg_cfg;
+extern struct cfg_group_dbg default_dbg_cfg;
+extern void *dbg_cfg;
 extern cfg_def_t dbg_cfg_def[];
 
-extern int dbg_mode_fixup(void *temp_handle,
-	str *group_name, str *var_name, void **value);
+extern int dbg_mode_fixup(
+		void *temp_handle, str *group_name, str *var_name, void **value);
 #endif
diff --git a/src/modules/debugger/debugger_json.c b/src/modules/debugger/debugger_json.c
index 638c7baf1db..d25ca862549 100644
--- a/src/modules/debugger/debugger_json.c
+++ b/src/modules/debugger/debugger_json.c
@@ -29,9 +29,8 @@
 #include "debugger_api.h"
 #include "debugger_json.h"
 
-int _dbg_get_array_avp_vals(struct sip_msg *msg,
-		pv_param_t *param, srjson_doc_t *jdoc, srjson_t **jobj,
-		str *item_name)
+int _dbg_get_array_avp_vals(struct sip_msg *msg, pv_param_t *param,
+		srjson_doc_t *jdoc, srjson_t **jobj, str *item_name)
 {
 	struct usr_avp *avp;
 	unsigned short name_type;
@@ -41,69 +40,60 @@ int _dbg_get_array_avp_vals(struct sip_msg *msg,
 	srjson_t *jobjt;
 	memset(&state, 0, sizeof(struct search_state));
 
-	if(pv_get_avp_name(msg, param, &avp_name, &name_type)!=0)
-	{
+	if(pv_get_avp_name(msg, param, &avp_name, &name_type) != 0) {
 		LM_ERR("invalid name\n");
 		return -1;
 	}
 	*jobj = srjson_CreateArray(jdoc);
-	if(*jobj==NULL)
-	{
+	if(*jobj == NULL) {
 		LM_ERR("cannot create json object\n");
 		return -1;
 	}
-	if ((avp=search_first_avp(name_type, avp_name, &avp_value, &state))==0)
-	{
+	if((avp = search_first_avp(name_type, avp_name, &avp_value, &state)) == 0) {
 		goto ok;
 	}
-	do
-	{
-		if(avp->flags & AVP_VAL_STR)
-		{
+	do {
+		if(avp->flags & AVP_VAL_STR) {
 			jobjt = srjson_CreateStr(jdoc, avp_value.s.s, avp_value.s.len);
-			if(jobjt==NULL)
-			{
+			if(jobjt == NULL) {
 				LM_ERR("cannot create json object\n");
 				return -1;
 			}
 		} else {
 			jobjt = srjson_CreateNumber(jdoc, avp_value.n);
-			if(jobjt==NULL)
-			{
+			if(jobjt == NULL) {
 				LM_ERR("cannot create json object\n");
 				return -1;
 			}
 		}
 		srjson_AddItemToArray(jdoc, *jobj, jobjt);
-	} while ((avp=search_next_avp(&state, &avp_value))!=0);
+	} while((avp = search_next_avp(&state, &avp_value)) != 0);
 ok:
 	item_name->s = avp_name.s.s;
 	item_name->len = avp_name.s.len;
 	return 0;
 }
 #define DBG_XAVP_DUMP_SIZE 32
-static str* _dbg_xavp_dump[DBG_XAVP_DUMP_SIZE];
+static str *_dbg_xavp_dump[DBG_XAVP_DUMP_SIZE];
 int _dbg_xavp_dump_lookup(pv_param_t *param)
 {
 	unsigned int i = 0;
 	pv_xavp_name_t *xname;
 
-	if(param==NULL)
+	if(param == NULL)
 		return -1;
 
-	xname = (pv_xavp_name_t*)param->pvn.u.dname;
+	xname = (pv_xavp_name_t *)param->pvn.u.dname;
 
-	while(i<DBG_XAVP_DUMP_SIZE && _dbg_xavp_dump[i]!=NULL)
-	{
-		if(_dbg_xavp_dump[i]->len==xname->name.len)
-		{
-			if(strncmp(_dbg_xavp_dump[i]->s, xname->name.s, xname->name.len)==0)
+	while(i < DBG_XAVP_DUMP_SIZE && _dbg_xavp_dump[i] != NULL) {
+		if(_dbg_xavp_dump[i]->len == xname->name.len) {
+			if(strncmp(_dbg_xavp_dump[i]->s, xname->name.s, xname->name.len)
+					== 0)
 				return 1; /* already dump before */
 		}
 		i++;
 	}
-	if(i==DBG_XAVP_DUMP_SIZE)
-	{
+	if(i == DBG_XAVP_DUMP_SIZE) {
 		LM_WARN("full _dbg_xavp_dump cache array\n");
 		return 0; /* end cache names */
 	}
@@ -119,58 +109,56 @@ void _dbg_get_obj_xavp_val(sr_xavp_t *avp, srjson_doc_t *jdoc, srjson_t **jobj)
 	switch(avp->val.type) {
 		case SR_XTYPE_NULL:
 			*jobj = srjson_CreateNull(jdoc);
-		break;
+			break;
 		case SR_XTYPE_LONG:
 			*jobj = srjson_CreateNumber(jdoc, avp->val.v.l);
-		break;
+			break;
 		case SR_XTYPE_STR:
 			*jobj = srjson_CreateStr(jdoc, avp->val.v.s.s, avp->val.v.s.len);
-		break;
+			break;
 		case SR_XTYPE_TIME:
-			result = snprintf(_pv_xavp_buf, 128, "%lu", (long unsigned)avp->val.v.t);
-		break;
+			result = snprintf(
+					_pv_xavp_buf, 128, "%lu", (long unsigned)avp->val.v.t);
+			break;
 		case SR_XTYPE_LLONG:
 			result = snprintf(_pv_xavp_buf, 128, "%lld", avp->val.v.ll);
-		break;
+			break;
 		case SR_XTYPE_XAVP:
-			result = snprintf(_pv_xavp_buf, 128, "<<xavp:%p>>", avp->val.v.xavp);
-		break;
+			result =
+					snprintf(_pv_xavp_buf, 128, "<<xavp:%p>>", avp->val.v.xavp);
+			break;
 		case SR_XTYPE_DATA:
-			result = snprintf(_pv_xavp_buf, 128, "<<data:%p>>", avp->val.v.data);
-		break;
+			result =
+					snprintf(_pv_xavp_buf, 128, "<<data:%p>>", avp->val.v.data);
+			break;
 		default:
 			LM_WARN("unknown data type\n");
 			*jobj = srjson_CreateNull(jdoc);
 	}
-	if(result<0)
-	{
+	if(result < 0) {
 		LM_ERR("cannot convert to str\n");
 		*jobj = srjson_CreateNull(jdoc);
-	}
-	else if(*jobj==NULL)
-	{
+	} else if(*jobj == NULL) {
 		*jobj = srjson_CreateStr(jdoc, _pv_xavp_buf, 128);
 	}
 }
 
-int _dbg_get_obj_avp_vals(str name, sr_xavp_t *xavp, srjson_doc_t *jdoc, srjson_t **jobj)
+int _dbg_get_obj_avp_vals(
+		str name, sr_xavp_t *xavp, srjson_doc_t *jdoc, srjson_t **jobj)
 {
 	sr_xavp_t *avp = NULL;
 	srjson_t *jobjt = NULL;
 
 	*jobj = srjson_CreateArray(jdoc);
-	if(*jobj==NULL)
-	{
+	if(*jobj == NULL) {
 		LM_ERR("cannot create json object\n");
 		return -1;
 	}
 	avp = xavp;
-	while(avp!=NULL&&!STR_EQ(avp->name,name))
-	{
+	while(avp != NULL && !STR_EQ(avp->name, name)) {
 		avp = avp->next;
 	}
-	while(avp!=NULL)
-	{
+	while(avp != NULL) {
 		_dbg_get_obj_xavp_val(avp, jdoc, &jobjt);
 		srjson_AddItemToArray(jdoc, *jobj, jobjt);
 		jobjt = NULL;
@@ -180,11 +168,10 @@ int _dbg_get_obj_avp_vals(str name, sr_xavp_t *xavp, srjson_doc_t *jdoc, srjson_
 	return 0;
 }
 
-int _dbg_get_obj_xavp_vals(struct sip_msg *msg,
-		pv_param_t *param, srjson_doc_t *jdoc, srjson_t **jobjr,
-		str *item_name)
+int _dbg_get_obj_xavp_vals(struct sip_msg *msg, pv_param_t *param,
+		srjson_doc_t *jdoc, srjson_t **jobjr, str *item_name)
 {
-	pv_xavp_name_t *xname = (pv_xavp_name_t*)param->pvn.u.dname;
+	pv_xavp_name_t *xname = (pv_xavp_name_t *)param->pvn.u.dname;
 	sr_xavp_t *xavp = NULL;
 	sr_xavp_t *avp = NULL;
 	srjson_t *jobj = NULL;
@@ -193,8 +180,7 @@ int _dbg_get_obj_xavp_vals(struct sip_msg *msg,
 	struct str_list *k;
 
 	*jobjr = srjson_CreateArray(jdoc);
-	if(*jobjr==NULL)
-	{
+	if(*jobjr == NULL) {
 		LM_ERR("cannot create json object\n");
 		return -1;
 	}
@@ -202,49 +188,42 @@ int _dbg_get_obj_xavp_vals(struct sip_msg *msg,
 	item_name->s = xname->name.s;
 	item_name->len = xname->name.len;
 	xavp = xavp_get_by_index(&xname->name, 0, NULL);
-	if(xavp==NULL)
-	{
+	if(xavp == NULL) {
 		return 0; /* empty */
 	}
 
-	do
-	{
-		if(xavp->val.type==SR_XTYPE_XAVP)
-		{
+	do {
+		if(xavp->val.type == SR_XTYPE_XAVP) {
 			avp = xavp->val.v.xavp;
 			jobj = srjson_CreateObject(jdoc);
-			if(jobj==NULL)
-			{
+			if(jobj == NULL) {
 				LM_ERR("cannot create json object\n");
 				return -1;
 			}
 			keys = xavp_get_list_key_names(xavp);
-			if(keys!=NULL)
-			{
-				do
-				{
+			if(keys != NULL) {
+				do {
 					_dbg_get_obj_avp_vals(keys->s, avp, jdoc, &jobjt);
-					srjson_AddStrItemToObject(jdoc, jobj, keys->s.s,
-						keys->s.len, jobjt);
+					srjson_AddStrItemToObject(
+							jdoc, jobj, keys->s.s, keys->s.len, jobjt);
 					k = keys;
 					keys = keys->next;
 					pkg_free(k);
 					jobjt = NULL;
-				}while(keys!=NULL);
+				} while(keys != NULL);
 			}
 		}
-		if(jobj!=NULL)
-		{
+		if(jobj != NULL) {
 			srjson_AddItemToArray(jdoc, *jobjr, jobj);
 			jobj = NULL;
 		}
-	}while((xavp = xavp_get_next(xavp))!=0);
+	} while((xavp = xavp_get_next(xavp)) != 0);
 
 	return 0;
 }
 
-int dbg_get_json(struct sip_msg* msg, unsigned int mask, srjson_doc_t *jdoc,
-	srjson_t *head)
+int dbg_get_json(struct sip_msg *msg, unsigned int mask, srjson_doc_t *jdoc,
+		srjson_t *head)
 {
 	int i;
 	pv_value_t value;
@@ -254,36 +233,33 @@ int dbg_get_json(struct sip_msg* msg, unsigned int mask, srjson_doc_t *jdoc,
 	str item_name = STR_NULL;
 	static char iname[128];
 
-	if(_pv_cache==NULL)
-	{
+	if(_pv_cache == NULL) {
 		LM_ERR("cannot access pv_cache\n");
 		return -1;
 	}
-	if(jdoc==NULL){
+	if(jdoc == NULL) {
 		LM_ERR("jdoc is null\n");
 		return -1;
 	}
-	if(head==NULL){
+	if(head == NULL) {
 		LM_ERR("head is null\n");
 		return -1;
 	}
 
-	memset(_dbg_xavp_dump, 0, sizeof(str*)*DBG_XAVP_DUMP_SIZE);
-	for(i=0;i<PV_CACHE_SIZE;i++)
-	{
+	memset(_dbg_xavp_dump, 0, sizeof(str *) * DBG_XAVP_DUMP_SIZE);
+	for(i = 0; i < PV_CACHE_SIZE; i++) {
 		el = _pv_cache[i];
-		while(el)
-		{
-			if(!(el->spec.type==PVT_AVP||
-				el->spec.type==PVT_SCRIPTVAR||
-				el->spec.type==PVT_XAVP||
-				el->spec.type==PVT_OTHER)||
-				!((el->spec.type==PVT_AVP&&mask&DBG_DP_AVP)||
-				(el->spec.type==PVT_XAVP&&mask&DBG_DP_XAVP)||
-				(el->spec.type==PVT_SCRIPTVAR&&mask&DBG_DP_SCRIPTVAR)||
-				(el->spec.type==PVT_OTHER&&mask&DBG_DP_OTHER))||
-				(el->spec.trans!=NULL))
-			{
+		while(el) {
+			if(!(el->spec.type == PVT_AVP || el->spec.type == PVT_SCRIPTVAR
+					   || el->spec.type == PVT_XAVP
+					   || el->spec.type == PVT_OTHER)
+					|| !((el->spec.type == PVT_AVP && mask & DBG_DP_AVP)
+							|| (el->spec.type == PVT_XAVP && mask & DBG_DP_XAVP)
+							|| (el->spec.type == PVT_SCRIPTVAR
+									&& mask & DBG_DP_SCRIPTVAR)
+							|| (el->spec.type == PVT_OTHER
+									&& mask & DBG_DP_OTHER))
+					|| (el->spec.trans != NULL)) {
 				el = el->next;
 				continue;
 			}
@@ -291,89 +267,80 @@ int dbg_get_json(struct sip_msg* msg, unsigned int mask, srjson_doc_t *jdoc,
 			item_name.len = 0;
 			item_name.s = 0;
 			iname[0] = '\0';
-			if(el->spec.type==PVT_AVP)
-			{
-				if(el->spec.pvp.pvi.type==PV_IDX_ALL||
-					(el->spec.pvp.pvi.type==PV_IDX_INT&&el->spec.pvp.pvi.u.ival!=0))
-				{
+			if(el->spec.type == PVT_AVP) {
+				if(el->spec.pvp.pvi.type == PV_IDX_ALL
+						|| (el->spec.pvp.pvi.type == PV_IDX_INT
+								&& el->spec.pvp.pvi.u.ival != 0)) {
 					el = el->next;
 					continue;
-				}
-				else
-				{
-					if(_dbg_get_array_avp_vals(msg, &el->spec.pvp, jdoc, &jobj, &item_name)!=0)
-					{
-						LM_WARN("can't get value[%.*s]\n", el->pvname.len, el->pvname.s);
+				} else {
+					if(_dbg_get_array_avp_vals(
+							   msg, &el->spec.pvp, jdoc, &jobj, &item_name)
+							!= 0) {
+						LM_WARN("can't get value[%.*s]\n", el->pvname.len,
+								el->pvname.s);
 						el = el->next;
 						continue;
 					}
-					if(srjson_GetArraySize(jdoc, jobj)==0 && !(mask&DBG_DP_NULL))
-					{
+					if(srjson_GetArraySize(jdoc, jobj) == 0
+							&& !(mask & DBG_DP_NULL)) {
 						el = el->next;
 						continue;
 					}
-					snprintf(iname, 128, "$avp(%.*s)", item_name.len, item_name.s);
+					snprintf(iname, 128, "$avp(%.*s)", item_name.len,
+							item_name.s);
 				}
-			}
-			else if(el->spec.type==PVT_XAVP)
-			{
-				if(_dbg_xavp_dump_lookup(&el->spec.pvp)!=0)
-				{
+			} else if(el->spec.type == PVT_XAVP) {
+				if(_dbg_xavp_dump_lookup(&el->spec.pvp) != 0) {
 					el = el->next;
 					continue;
 				}
-				if(_dbg_get_obj_xavp_vals(msg, &el->spec.pvp, jdoc, &jobj, &item_name)!=0)
-				{
-					LM_WARN("can't get value[%.*s]\n", el->pvname.len, el->pvname.s);
+				if(_dbg_get_obj_xavp_vals(
+						   msg, &el->spec.pvp, jdoc, &jobj, &item_name)
+						!= 0) {
+					LM_WARN("can't get value[%.*s]\n", el->pvname.len,
+							el->pvname.s);
 					el = el->next;
 					continue;
 				}
-				if(srjson_GetArraySize(jdoc, jobj)==0 && !(mask&DBG_DP_NULL))
-				{
+				if(srjson_GetArraySize(jdoc, jobj) == 0
+						&& !(mask & DBG_DP_NULL)) {
 					el = el->next;
 					continue;
 				}
 				snprintf(iname, 128, "$xavp(%.*s)", item_name.len, item_name.s);
-			}
-			else
-			{
-				if(pv_get_spec_value(msg, &el->spec, &value)!=0)
-				{
-					LM_WARN("can't get value[%.*s]\n", el->pvname.len, el->pvname.s);
+			} else {
+				if(pv_get_spec_value(msg, &el->spec, &value) != 0) {
+					LM_WARN("can't get value[%.*s]\n", el->pvname.len,
+							el->pvname.s);
 					el = el->next;
 					continue;
 				}
-				if(value.flags&(PV_VAL_NULL|PV_VAL_EMPTY|PV_VAL_NONE))
-				{
-					if(mask&DBG_DP_NULL)
-					{
+				if(value.flags & (PV_VAL_NULL | PV_VAL_EMPTY | PV_VAL_NONE)) {
+					if(mask & DBG_DP_NULL) {
 						jobj = srjson_CreateNull(jdoc);
-					}
-					else
-					{
+					} else {
 						el = el->next;
 						continue;
 					}
-				}else if(value.flags&(PV_VAL_INT)){
+				} else if(value.flags & (PV_VAL_INT)) {
 					jobj = srjson_CreateNumber(jdoc, value.ri);
-				}else if(value.flags&(PV_VAL_STR)){
+				} else if(value.flags & (PV_VAL_STR)) {
 					jobj = srjson_CreateStr(jdoc, value.rs.s, value.rs.len);
-				}else {
-					LM_WARN("el->pvname[%.*s] value[%d] unhandled\n", el->pvname.len, el->pvname.s,
-						value.flags);
+				} else {
+					LM_WARN("el->pvname[%.*s] value[%d] unhandled\n",
+							el->pvname.len, el->pvname.s, value.flags);
 					el = el->next;
 					continue;
 				}
-				if(jobj==NULL)
-				{
-					LM_ERR("el->pvname[%.*s] empty json object\n", el->pvname.len,
-						el->pvname.s);
+				if(jobj == NULL) {
+					LM_ERR("el->pvname[%.*s] empty json object\n",
+							el->pvname.len, el->pvname.s);
 					goto error;
 				}
 				snprintf(iname, 128, "%.*s", el->pvname.len, el->pvname.s);
 			}
-			if(jobj!=NULL)
-			{
+			if(jobj != NULL) {
 				srjson_AddItemToObject(jdoc, head, iname, jobj);
 			}
 			el = el->next;
@@ -386,26 +353,24 @@ int dbg_get_json(struct sip_msg* msg, unsigned int mask, srjson_doc_t *jdoc,
 	return -1;
 }
 
-int dbg_dump_json(struct sip_msg* msg, unsigned int mask, int level)
+int dbg_dump_json(struct sip_msg *msg, unsigned int mask, int level)
 {
 	char *output = NULL;
 	srjson_doc_t jdoc;
 
 	srjson_InitDoc(&jdoc, NULL);
-	if(jdoc.root==NULL)
-	{
+	if(jdoc.root == NULL) {
 		jdoc.root = srjson_CreateObject(&jdoc);
-		if(jdoc.root==NULL)
-		{
+		if(jdoc.root == NULL) {
 			LM_ERR("cannot create json root\n");
 			goto error;
 		}
 	}
 
-	if(dbg_get_json(msg, mask, &jdoc, jdoc.root)<0) goto error;
+	if(dbg_get_json(msg, mask, &jdoc, jdoc.root) < 0)
+		goto error;
 	output = srjson_PrintUnformatted(&jdoc, jdoc.root);
-	if(output==NULL)
-	{
+	if(output == NULL) {
 		LM_ERR("cannot print json doc\n");
 		srjson_DestroyDoc(&jdoc);
 	}
diff --git a/src/modules/debugger/debugger_json.h b/src/modules/debugger/debugger_json.h
index 31bc7cc3114..e3b753c4e23 100644
--- a/src/modules/debugger/debugger_json.h
+++ b/src/modules/debugger/debugger_json.h
@@ -26,7 +26,7 @@
 #include "../../core/utils/srjson.h"
 #include "../../core/route_struct.h"
 
-int dbg_get_json(struct sip_msg* msg, unsigned int mask, srjson_doc_t *jdoc,
-	srjson_t *head);
-int dbg_dump_json(struct sip_msg* msg, unsigned int mask, int level);
+int dbg_get_json(struct sip_msg *msg, unsigned int mask, srjson_doc_t *jdoc,
+		srjson_t *head);
+int dbg_dump_json(struct sip_msg *msg, unsigned int mask, int level);
 #endif
diff --git a/src/modules/debugger/debugger_mod.c b/src/modules/debugger/debugger_mod.c
index b586bb54da8..85ef5517ab0 100644
--- a/src/modules/debugger/debugger_mod.c
+++ b/src/modules/debugger/debugger_mod.c
@@ -46,19 +46,19 @@ static int mod_init(void);
 static int child_init(int rank);
 static void mod_destroy(void);
 
-static int w_dbg_breakpoint(struct sip_msg* msg, char* point, char* str2);
-static int fixup_dbg_breakpoint(void** param, int param_no);
+static int w_dbg_breakpoint(struct sip_msg *msg, char *point, char *str2);
+static int fixup_dbg_breakpoint(void **param, int param_no);
 static int dbg_mod_level_param(modparam_t type, void *val);
 static int dbg_mod_facility_param(modparam_t type, void *val);
 
-static int fixup_dbg_pv_dump(void** param, int param_no);
-static int w_dbg_dump(struct sip_msg* msg, char* mask, char* level);
+static int fixup_dbg_pv_dump(void **param, int param_no);
+static int w_dbg_dump(struct sip_msg *msg, char *mask, char *level);
 
 static struct action *dbg_fixup_get_action(void **param, int param_no);
-static int fixup_dbg_sip_msg(void** param, int param_no);
-static int w_dbg_sip_msg(struct sip_msg* msg, char *level, char *facility);
+static int fixup_dbg_sip_msg(void **param, int param_no);
+static int w_dbg_sip_msg(struct sip_msg *msg, char *level, char *facility);
 
-extern char* dump_lump_list(struct lump *list, int s_offset, char *s_buf);
+extern char *dump_lump_list(struct lump *list, int s_offset, char *s_buf);
 
 /* parameters */
 extern int _dbg_cfgtrace;
@@ -78,60 +78,57 @@ extern int _dbg_cfgtest;
 extern cfgt_api_t _dbg_cfgt;
 
 static int _dbg_sip_msg_cline;
-static char * _dbg_cfgtrace_facility_str = 0;
+static char *_dbg_cfgtrace_facility_str = 0;
 static int _dbg_log_assign = 0;
 
-static cmd_export_t cmds[]={
-	{"dbg_breakpoint", (cmd_function)w_dbg_breakpoint, 1,
-		fixup_dbg_breakpoint, 0, ANY_ROUTE},
-	{"dbg_pv_dump", (cmd_function)w_dbg_dump, 0,
-		fixup_dbg_pv_dump, 0, ANY_ROUTE},
-	{"dbg_pv_dump", (cmd_function)w_dbg_dump, 1,
-		fixup_dbg_pv_dump, 0, ANY_ROUTE},
-	{"dbg_pv_dump", (cmd_function)w_dbg_dump, 2,
-		fixup_dbg_pv_dump, 0, ANY_ROUTE},
-	{"dbg_sip_msg", (cmd_function)w_dbg_sip_msg, 0,
-		fixup_dbg_sip_msg, 0, REQUEST_ROUTE|ONREPLY_ROUTE},
-	{"dbg_sip_msg", (cmd_function)w_dbg_sip_msg, 1,
-		fixup_dbg_sip_msg, 0, REQUEST_ROUTE|ONREPLY_ROUTE},
-	{"dbg_sip_msg", (cmd_function)w_dbg_sip_msg, 2,
-		fixup_dbg_sip_msg, 0, REQUEST_ROUTE|ONREPLY_ROUTE},
-	{0, 0, 0, 0, 0, 0}
-};
-
-static param_export_t params[]={
-	{"cfgtrace",          INT_PARAM, &_dbg_cfgtrace},
-	{"cfgtrace_format",   INT_PARAM, &_dbg_cfgtrace_format},
-	{"breakpoint",        INT_PARAM, &_dbg_breakpoint},
-	{"log_level",         INT_PARAM, &_dbg_cfgtrace_level},
-	{"log_facility",      PARAM_STRING, &_dbg_cfgtrace_facility_str},
-	{"log_prefix",        PARAM_STRING, &_dbg_cfgtrace_prefix},
-	{"log_level_name",    PARAM_STRING, &_dbg_cfgtrace_lname},
-	{"log_assign",        INT_PARAM, &_dbg_log_assign},
-	{"step_usleep",       INT_PARAM, &_dbg_step_usleep},
-	{"step_loops",        INT_PARAM, &_dbg_step_loops},
-	{"mod_hash_size",     INT_PARAM, &default_dbg_cfg.mod_hash_size},
-	{"mod_level_mode",    INT_PARAM, &default_dbg_cfg.mod_level_mode},
-	{"mod_level",         PARAM_STRING|USE_FUNC_PARAM, (void*)dbg_mod_level_param},
-	{"mod_facility_mode", INT_PARAM, &default_dbg_cfg.mod_facility_mode},
-	{"mod_facility",      PARAM_STRING|USE_FUNC_PARAM, (void*)dbg_mod_facility_param},
-	{"reset_msgid",       INT_PARAM, &_dbg_reset_msgid},
-	{"cfgpkgcheck",       INT_PARAM, &_dbg_cfgpkgcheck},
-	{"cfgtest",           INT_PARAM, &_dbg_cfgtest},
-	{0, 0, 0}
-};
+static cmd_export_t cmds[] = {{"dbg_breakpoint", (cmd_function)w_dbg_breakpoint,
+									  1, fixup_dbg_breakpoint, 0, ANY_ROUTE},
+		{"dbg_pv_dump", (cmd_function)w_dbg_dump, 0, fixup_dbg_pv_dump, 0,
+				ANY_ROUTE},
+		{"dbg_pv_dump", (cmd_function)w_dbg_dump, 1, fixup_dbg_pv_dump, 0,
+				ANY_ROUTE},
+		{"dbg_pv_dump", (cmd_function)w_dbg_dump, 2, fixup_dbg_pv_dump, 0,
+				ANY_ROUTE},
+		{"dbg_sip_msg", (cmd_function)w_dbg_sip_msg, 0, fixup_dbg_sip_msg, 0,
+				REQUEST_ROUTE | ONREPLY_ROUTE},
+		{"dbg_sip_msg", (cmd_function)w_dbg_sip_msg, 1, fixup_dbg_sip_msg, 0,
+				REQUEST_ROUTE | ONREPLY_ROUTE},
+		{"dbg_sip_msg", (cmd_function)w_dbg_sip_msg, 2, fixup_dbg_sip_msg, 0,
+				REQUEST_ROUTE | ONREPLY_ROUTE},
+		{0, 0, 0, 0, 0, 0}};
+
+static param_export_t params[] = {{"cfgtrace", INT_PARAM, &_dbg_cfgtrace},
+		{"cfgtrace_format", INT_PARAM, &_dbg_cfgtrace_format},
+		{"breakpoint", INT_PARAM, &_dbg_breakpoint},
+		{"log_level", INT_PARAM, &_dbg_cfgtrace_level},
+		{"log_facility", PARAM_STRING, &_dbg_cfgtrace_facility_str},
+		{"log_prefix", PARAM_STRING, &_dbg_cfgtrace_prefix},
+		{"log_level_name", PARAM_STRING, &_dbg_cfgtrace_lname},
+		{"log_assign", INT_PARAM, &_dbg_log_assign},
+		{"step_usleep", INT_PARAM, &_dbg_step_usleep},
+		{"step_loops", INT_PARAM, &_dbg_step_loops},
+		{"mod_hash_size", INT_PARAM, &default_dbg_cfg.mod_hash_size},
+		{"mod_level_mode", INT_PARAM, &default_dbg_cfg.mod_level_mode},
+		{"mod_level", PARAM_STRING | USE_FUNC_PARAM,
+				(void *)dbg_mod_level_param},
+		{"mod_facility_mode", INT_PARAM, &default_dbg_cfg.mod_facility_mode},
+		{"mod_facility", PARAM_STRING | USE_FUNC_PARAM,
+				(void *)dbg_mod_facility_param},
+		{"reset_msgid", INT_PARAM, &_dbg_reset_msgid},
+		{"cfgpkgcheck", INT_PARAM, &_dbg_cfgpkgcheck},
+		{"cfgtest", INT_PARAM, &_dbg_cfgtest}, {0, 0, 0}};
 
 struct module_exports exports = {
-	"debugger",      /* module name */
-	DEFAULT_DLFLAGS, /* dlopen flags */
-	cmds,            /* cmd (cfg function) exports */
-	params,          /* param exports */
-	0,               /* RPC method exports */
-	0,               /* pseudo-variables exports */
-	0,               /* response handling function */
-	mod_init,        /* module init function */
-	child_init,      /* per-child init function */
-	mod_destroy      /* module destroy function */
+		"debugger",		 /* module name */
+		DEFAULT_DLFLAGS, /* dlopen flags */
+		cmds,			 /* cmd (cfg function) exports */
+		params,			 /* param exports */
+		0,				 /* RPC method exports */
+		0,				 /* pseudo-variables exports */
+		0,				 /* response handling function */
+		mod_init,		 /* module init function */
+		child_init,		 /* per-child init function */
+		mod_destroy		 /* module destroy function */
 };
 
 
@@ -143,11 +140,9 @@ static int mod_init(void)
 	int fl;
 	bind_cfgt_t bind_cfgt;
 
-	if (_dbg_cfgtrace_facility_str!=NULL)
-	{
+	if(_dbg_cfgtrace_facility_str != NULL) {
 		fl = str2facility(_dbg_cfgtrace_facility_str);
-		if (fl != -1)
-		{
+		if(fl != -1) {
 			_dbg_cfgtrace_facility = fl;
 		} else {
 			LM_ERR("invalid log facility configured");
@@ -155,60 +150,55 @@ static int mod_init(void)
 		}
 	}
 
-	if(dbg_init_rpc()!=0)
-	{
+	if(dbg_init_rpc() != 0) {
 		LM_ERR("failed to register RPC commands\n");
 		return -1;
 	}
 
-	if(cfg_declare("dbg", dbg_cfg_def, &default_dbg_cfg, cfg_sizeof(dbg), &dbg_cfg))
-	{
+	if(cfg_declare("dbg", dbg_cfg_def, &default_dbg_cfg, cfg_sizeof(dbg),
+			   &dbg_cfg)) {
 		LM_ERR("Fail to declare the configuration\n");
 		return -1;
 	}
 
 	/* anyhow, should fail before */
-	if (!dbg_cfg) {
+	if(!dbg_cfg) {
 		return -1;
 	}
 
 	LM_DBG("cfg level_mode:%d facility_mode:%d hash_size:%d\n",
-		cfg_get(dbg, dbg_cfg, mod_level_mode),
-		cfg_get(dbg, dbg_cfg, mod_facility_mode),
-		cfg_get(dbg, dbg_cfg, mod_hash_size));
+			cfg_get(dbg, dbg_cfg, mod_level_mode),
+			cfg_get(dbg, dbg_cfg, mod_facility_mode),
+			cfg_get(dbg, dbg_cfg, mod_hash_size));
 
-	if(dbg_init_mod_levels(cfg_get(dbg, dbg_cfg, mod_hash_size))<0)
-	{
+	if(dbg_init_mod_levels(cfg_get(dbg, dbg_cfg, mod_hash_size)) < 0) {
 		LM_ERR("failed to init per module log level\n");
 		return -1;
 	}
 
-	if(_dbg_log_assign>0)
-	{
-		if(dbg_init_pvcache()!=0)
-		{
+	if(_dbg_log_assign > 0) {
+		if(dbg_init_pvcache() != 0) {
 			LM_ERR("failed to create pvcache\n");
 			return -1;
 		}
 	}
-	if(_dbg_reset_msgid==1)
-	{
-		unsigned int ALL = REQUEST_CB+FAILURE_CB+ONREPLY_CB
-		  +BRANCH_CB+ONSEND_CB+ERROR_CB+LOCAL_CB+EVENT_CB+BRANCH_FAILURE_CB;
-		if (register_script_cb(dbg_msgid_filter, PRE_SCRIPT_CB|ALL, 0) != 0) {
+	if(_dbg_reset_msgid == 1) {
+		unsigned int ALL = REQUEST_CB + FAILURE_CB + ONREPLY_CB + BRANCH_CB
+						   + ONSEND_CB + ERROR_CB + LOCAL_CB + EVENT_CB
+						   + BRANCH_FAILURE_CB;
+		if(register_script_cb(dbg_msgid_filter, PRE_SCRIPT_CB | ALL, 0) != 0) {
 			LM_ERR("could not insert callback");
 			return -1;
 		}
 	}
-	if(_dbg_cfgtest==1)
-	{
+	if(_dbg_cfgtest == 1) {
 		bind_cfgt = (bind_cfgt_t)find_export("cfgt_bind_cfgt", 1, 0);
-		if (!bind_cfgt) {
+		if(!bind_cfgt) {
 			LM_ERR("can't find cfgt module\n");
 			return -1;
 		}
 
-		if (bind_cfgt(&_dbg_cfgt) < 0) {
+		if(bind_cfgt(&_dbg_cfgt) < 0) {
 			return -1;
 		}
 		LM_INFO("bind to cfgt module\n");
@@ -222,7 +212,7 @@ static int mod_init(void)
 static int child_init(int rank)
 {
 	LM_DBG("rank is (%d)\n", rank);
-	if (rank==PROC_INIT) {
+	if(rank == PROC_INIT) {
 		dbg_enable_mod_levels();
 		dbg_enable_mod_facilities();
 		dbg_enable_log_assign();
@@ -243,7 +233,7 @@ static void mod_destroy(void)
 /**
  * cfg wrapper to set breakpoint (not implemented yet)
  */
-static int w_dbg_breakpoint(struct sip_msg* msg, char* point, char* str2)
+static int w_dbg_breakpoint(struct sip_msg *msg, char *point, char *str2)
 {
 	return 1;
 }
@@ -251,39 +241,53 @@ static int w_dbg_breakpoint(struct sip_msg* msg, char* point, char* str2)
 /**
  * fixup for cfg dbg_pv_dump
  */
-static int fixup_dbg_pv_dump(void** param, int param_no)
+static int fixup_dbg_pv_dump(void **param, int param_no)
 {
 	unsigned int mask;
 	int level;
 	str s = STR_NULL;
 
-	switch(param_no)
-	{
+	switch(param_no) {
 		case 2:
-			switch(((char*)(*param))[2])
-			{
-				case 'A': level = L_ALERT; break;
-				case 'B': level = L_BUG; break;
-				case 'C': level = L_CRIT2; break;
-				case 'E': level = L_ERR; break;
-				case 'W': level = L_WARN; break;
-				case 'N': level = L_NOTICE; break;
-				case 'I': level = L_INFO; break;
-				case 'D': level = L_DBG; break;
+			switch(((char *)(*param))[2]) {
+				case 'A':
+					level = L_ALERT;
+					break;
+				case 'B':
+					level = L_BUG;
+					break;
+				case 'C':
+					level = L_CRIT2;
+					break;
+				case 'E':
+					level = L_ERR;
+					break;
+				case 'W':
+					level = L_WARN;
+					break;
+				case 'N':
+					level = L_NOTICE;
+					break;
+				case 'I':
+					level = L_INFO;
+					break;
+				case 'D':
+					level = L_DBG;
+					break;
 				default:
 					LM_ERR("unknown log level\n");
 					return E_UNSPEC;
 			}
-			*param = (void*)(long)level;
-		break;
+			*param = (void *)(long)level;
+			break;
 		case 1:
 			s.s = *param;
 			s.len = strlen(s.s);
 			if(str2int(&s, &mask) == 0) {
-				*param = (void*)(long)mask;
-			}
-			else return E_UNSPEC;
-		break;
+				*param = (void *)(long)mask;
+			} else
+				return E_UNSPEC;
+			break;
 	}
 
 	return 0;
@@ -292,14 +296,14 @@ static int fixup_dbg_pv_dump(void** param, int param_no)
 /**
  * dump pv_cache contents as json
  */
-static int w_dbg_dump(struct sip_msg* msg, char* mask, char* level)
+static int w_dbg_dump(struct sip_msg *msg, char *mask, char *level)
 {
 	unsigned int umask = DBG_DP_ALL;
 	int ilevel = L_DBG;
-	if(level!=NULL){
+	if(level != NULL) {
 		ilevel = (int)(long)level;
 	}
-	if(mask!=NULL){
+	if(mask != NULL) {
 		umask = (unsigned int)(unsigned long)mask;
 	}
 	dbg_dump_json(msg, umask, ilevel);
@@ -314,9 +318,9 @@ static struct action *dbg_fixup_get_action(void **param, int param_no)
 	struct action *ac, ac2;
 	action_u_t *au, au2;
 	/* param points to au->u.string, get pointer to au */
-	au = (void*) ((char *)param - ((char *)&au2.u.string-(char *)&au2));
+	au = (void *)((char *)param - ((char *)&au2.u.string - (char *)&au2));
 	au = au - 1 - param_no;
-	ac = (void*) ((char *)au - ((char *)&ac2.val-(char *)&ac2));
+	ac = (void *)((char *)au - ((char *)&ac2.val - (char *)&ac2));
 	return ac;
 }
 
@@ -324,17 +328,17 @@ static struct action *dbg_fixup_get_action(void **param, int param_no)
 /**
  * fixup for cfg set breakpoint function
  */
-static int fixup_dbg_breakpoint(void** param, int param_no)
+static int fixup_dbg_breakpoint(void **param, int param_no)
 {
 	struct action *a;
 	char *p;
 
-	if(param_no!=1)
+	if(param_no != 1)
 		return -1;
 	a = dbg_fixup_get_action(param, param_no);
-	p = (char*)(*param);
+	p = (char *)(*param);
 
-	return dbg_add_breakpoint(a, (*p=='0')?0:1);
+	return dbg_add_breakpoint(a, (*p == '0') ? 0 : 1);
 }
 
 static int dbg_mod_level_param(modparam_t type, void *val)
@@ -342,46 +346,43 @@ static int dbg_mod_level_param(modparam_t type, void *val)
 	char *p;
 	str s;
 	int l;
-	if(val==NULL)
+	if(val == NULL)
 		return -1;
 
-	p = strchr((char*)val, '=');
-	if(p==NULL) {
-		LM_ERR("invalid parameter value: %s\n", (char*)val);
+	p = strchr((char *)val, '=');
+	if(p == NULL) {
+		LM_ERR("invalid parameter value: %s\n", (char *)val);
 		return -1;
 	}
 	s.s = p + 1;
 	s.len = strlen(s.s);
 
-	if(str2sint(&s, &l)<0) {
-		LM_ERR("invalid parameter - level value: %s\n", (char*)val);
+	if(str2sint(&s, &l) < 0) {
+		LM_ERR("invalid parameter - level value: %s\n", (char *)val);
 		return -1;
 	}
-	s.s = (char*)val;
+	s.s = (char *)val;
 	s.len = p - s.s;
 
-	if (!dbg_cfg) {
+	if(!dbg_cfg) {
 		return -1;
 	}
 
 	LM_DBG("cfg level_mode:%d hash_size:%d\n",
-		cfg_get(dbg, dbg_cfg, mod_level_mode),
-		cfg_get(dbg, dbg_cfg, mod_hash_size));
+			cfg_get(dbg, dbg_cfg, mod_level_mode),
+			cfg_get(dbg, dbg_cfg, mod_hash_size));
 
-	if(dbg_init_mod_levels(cfg_get(dbg, dbg_cfg, mod_hash_size))<0)
-	{
+	if(dbg_init_mod_levels(cfg_get(dbg, dbg_cfg, mod_hash_size)) < 0) {
 		LM_ERR("failed to init per module log level\n");
 		return -1;
 	}
 
-	if(dbg_set_mod_debug_level(s.s, s.len, &l)<0)
-	{
-		LM_ERR("cannot store parameter: %s\n", (char*)val);
+	if(dbg_set_mod_debug_level(s.s, s.len, &l) < 0) {
+		LM_ERR("cannot store parameter: %s\n", (char *)val);
 		return -1;
 	}
 
 	return 0;
-
 }
 
 static int dbg_mod_facility_param(modparam_t type, void *val)
@@ -389,49 +390,47 @@ static int dbg_mod_facility_param(modparam_t type, void *val)
 	char *p;
 	str s;
 	int fl;
-	if(val==NULL)
+	if(val == NULL)
 		return -1;
 
-	p = strchr((char*)val, '=');
-	if(p==NULL) {
-		LM_ERR("invalid parameter value: %s\n", (char*)val);
+	p = strchr((char *)val, '=');
+	if(p == NULL) {
+		LM_ERR("invalid parameter value: %s\n", (char *)val);
 		return -1;
 	}
 	s.s = p + 1;
 	s.len = strlen(s.s);
 
-	if ((fl = str2facility(s.s)) == -1) {
-		LM_ERR("invalid parameter - facility value: %s\n", (char*)val);
+	if((fl = str2facility(s.s)) == -1) {
+		LM_ERR("invalid parameter - facility value: %s\n", (char *)val);
 		return -1;
 	}
 
-	s.s = (char*)val;
+	s.s = (char *)val;
 	s.len = p - s.s;
 
-	if (!dbg_cfg) {
+	if(!dbg_cfg) {
 		return -1;
 	}
 
 	LM_DBG("cfg facility_mode:%d hash_size:%d\n",
-		cfg_get(dbg, dbg_cfg, mod_facility_mode),
-		cfg_get(dbg, dbg_cfg, mod_hash_size));
+			cfg_get(dbg, dbg_cfg, mod_facility_mode),
+			cfg_get(dbg, dbg_cfg, mod_hash_size));
 
-	if(dbg_init_mod_levels(cfg_get(dbg, dbg_cfg, mod_hash_size))<0)
-	{
+	if(dbg_init_mod_levels(cfg_get(dbg, dbg_cfg, mod_hash_size)) < 0) {
 		LM_ERR("failed to init per module log level\n");
 		return -1;
 	}
 
-	if(dbg_set_mod_debug_facility(s.s, s.len, &fl)<0)
-	{
-		LM_ERR("cannot store parameter: %s\n", (char*)val);
+	if(dbg_set_mod_debug_facility(s.s, s.len, &fl) < 0) {
+		LM_ERR("cannot store parameter: %s\n", (char *)val);
 		return -1;
 	}
 
 	return 0;
 }
 
-static int fixup_dbg_sip_msg(void** param, int param_no)
+static int fixup_dbg_sip_msg(void **param, int param_no)
 {
 	int facility;
 	int level;
@@ -439,36 +438,50 @@ static int fixup_dbg_sip_msg(void** param, int param_no)
 
 	LM_DBG("dbg_sip_msg() called with %d params\n", param_no);
 
-	switch(param_no)
-	{
+	switch(param_no) {
 		case 2:
-			facility = str2facility((char*)*(param));
-			if (facility == -1) {
+			facility = str2facility((char *)*(param));
+			if(facility == -1) {
 				LM_ERR("invalid log facility configured");
 				return E_UNSPEC;
 			}
 
-			*param = (void*)(long)facility;
+			*param = (void *)(long)facility;
 			break;
 
 		case 1:
-			switch(((char*)(*param))[2])
-			{
+			switch(((char *)(*param))[2]) {
 				/* add L_OFFSET because L_WARN is consdered null pointer */
-				case 'A': level = L_ALERT + L_OFFSET; break;
-				case 'B': level = L_BUG + L_OFFSET; break;
-				case 'C': level = L_CRIT2 + L_OFFSET; break;
-				case 'E': level = L_ERR + L_OFFSET; break;
-				case 'W': level = L_WARN + L_OFFSET; break;
-				case 'N': level = L_NOTICE + L_OFFSET; break;
-				case 'I': level = L_INFO + L_OFFSET; break;
-				case 'D': level = L_DBG + L_OFFSET; break;
+				case 'A':
+					level = L_ALERT + L_OFFSET;
+					break;
+				case 'B':
+					level = L_BUG + L_OFFSET;
+					break;
+				case 'C':
+					level = L_CRIT2 + L_OFFSET;
+					break;
+				case 'E':
+					level = L_ERR + L_OFFSET;
+					break;
+				case 'W':
+					level = L_WARN + L_OFFSET;
+					break;
+				case 'N':
+					level = L_NOTICE + L_OFFSET;
+					break;
+				case 'I':
+					level = L_INFO + L_OFFSET;
+					break;
+				case 'D':
+					level = L_DBG + L_OFFSET;
+					break;
 				default:
 					LM_ERR("unknown log level\n");
 					return E_UNSPEC;
 			}
 
-			*param = (void*)(long)level;
+			*param = (void *)(long)level;
 			break;
 
 		case 0:
@@ -492,32 +505,36 @@ static int fixup_dbg_sip_msg(void** param, int param_no)
   * dump current SIP message and a diff lump list
   * part of the code taken from msg_apply_changes_f
   */
-static int w_dbg_sip_msg(struct sip_msg* msg, char *level, char *facility)
+static int w_dbg_sip_msg(struct sip_msg *msg, char *level, char *facility)
 {
 	int ilevel = cfg_get(core, core_cfg, debug);
-	int ifacility= cfg_get(core, core_cfg, log_facility);
+	int ifacility = cfg_get(core, core_cfg, log_facility);
 	int flag = FLAG_MSG_LUMPS_ONLY; // copy lumps only, not the whole message
-	unsigned int new_buf_offs=0, orig_offs = 0;
+	unsigned int new_buf_offs = 0, orig_offs = 0;
 	char *hdr_lumps = NULL;
 	char *bdy_lumps = NULL;
-	const char *start_txt = "------------------------- START OF SIP message debug --------------------------\n";
-	const char *hdr_txt =   "------------------------------ SIP header diffs -------------------------------\n";
-	const char *bdy_txt =   "------------------------------- SIP body diffs --------------------------------\n";
-	const char *end_txt =   "-------------------------- END OF SIP message debug ---------------------------\n\n";
+	const char *start_txt = "------------------------- START OF SIP message "
+							"debug --------------------------\n";
+	const char *hdr_txt = "------------------------------ SIP header diffs "
+						  "-------------------------------\n";
+	const char *bdy_txt = "------------------------------- SIP body diffs "
+						  "--------------------------------\n";
+	const char *end_txt = "-------------------------- END OF SIP message debug "
+						  "---------------------------\n\n";
 	struct dest_info send_info;
 	str obuf;
 
-	if (msg->first_line.type != SIP_REPLY && get_route_type() != REQUEST_ROUTE) {
+	if(msg->first_line.type != SIP_REPLY && get_route_type() != REQUEST_ROUTE) {
 		LM_ERR("invalid usage - not in request route\n");
 		return -1;
 	}
 
-	if (level != NULL) {
+	if(level != NULL) {
 		/* substract L_OFFSET previously added */
 		ilevel = (int)(long)level - L_OFFSET;
 	}
 
-	if (facility != NULL) {
+	if(facility != NULL) {
 		ifacility = (int)(long)facility;
 	}
 
@@ -525,22 +542,20 @@ static int w_dbg_sip_msg(struct sip_msg* msg, char *level, char *facility)
 	init_dest_info(&send_info);
 	send_info.proto = PROTO_UDP;
 	if(msg->first_line.type == SIP_REPLY) {
-		obuf.s = generate_res_buf_from_sip_res(msg,
-				(unsigned int*)&obuf.len, BUILD_NO_VIA1_UPDATE);
+		obuf.s = generate_res_buf_from_sip_res(
+				msg, (unsigned int *)&obuf.len, BUILD_NO_VIA1_UPDATE);
 	} else {
-		obuf.s = build_req_buf_from_sip_req(msg,
-				(unsigned int*)&obuf.len, &send_info,
-				BUILD_NO_PATH|BUILD_NO_LOCAL_VIA|BUILD_NO_VIA1_UPDATE);
+		obuf.s = build_req_buf_from_sip_req(msg, (unsigned int *)&obuf.len,
+				&send_info,
+				BUILD_NO_PATH | BUILD_NO_LOCAL_VIA | BUILD_NO_VIA1_UPDATE);
 	}
 
-	if(obuf.s == NULL)
-	{
+	if(obuf.s == NULL) {
 		LM_ERR("couldn't update msg buffer content\n");
 		return -1;
 	}
 
-	if(obuf.len >= BUF_SIZE)
-	{
+	if(obuf.len >= BUF_SIZE) {
 		LM_ERR("new buffer overflow (%d)\n", obuf.len);
 		pkg_free(obuf.s);
 		return -1;
@@ -556,49 +571,42 @@ static int w_dbg_sip_msg(struct sip_msg* msg, char *level, char *facility)
 
 	/* alloc private mem and copy lumps */
 	hdr_lumps = pkg_malloc(BUF_SIZE);
-	if(hdr_lumps==NULL)
-	{
+	if(hdr_lumps == NULL) {
 		PKG_MEM_ERROR;
 		return -1;
 	}
 	bdy_lumps = pkg_malloc(BUF_SIZE);
-	if(hdr_lumps==NULL)
-	{
+	if(hdr_lumps == NULL) {
 		pkg_free(hdr_lumps);
 		PKG_MEM_ERROR;
 		return -1;
 	}
 
 	new_buf_offs = 0;
-	process_lumps(msg, msg->add_rm, hdr_lumps, &new_buf_offs, &orig_offs, &send_info, flag);
+	process_lumps(msg, msg->add_rm, hdr_lumps, &new_buf_offs, &orig_offs,
+			&send_info, flag);
 
 	new_buf_offs = 0;
-	process_lumps(msg, msg->body_lumps, bdy_lumps, &new_buf_offs, &orig_offs, &send_info, flag);
+	process_lumps(msg, msg->body_lumps, bdy_lumps, &new_buf_offs, &orig_offs,
+			&send_info, flag);
 
 	/* do the print */
-	if (_dbg_sip_msg_cline < 0 ) {
+	if(_dbg_sip_msg_cline < 0) {
 		LOG_FC(ifacility, ilevel, "CONFIG LINE unknown\n%s%.*s%s%s%s%s%s",
-			start_txt,
-			obuf.len, obuf.s,
-			hdr_txt, hdr_lumps,
-			bdy_txt, bdy_lumps,
-			end_txt);
+				start_txt, obuf.len, obuf.s, hdr_txt, hdr_lumps, bdy_txt,
+				bdy_lumps, end_txt);
 	} else {
 		LOG_FC(ifacility, ilevel, "CONFIG LINE %d\n%s%.*s%s%s%s%s%s",
-			_dbg_sip_msg_cline,
-			start_txt,
-			obuf.len, obuf.s,
-			hdr_txt, hdr_lumps,
-			bdy_txt, bdy_lumps,
-			end_txt);
+				_dbg_sip_msg_cline, start_txt, obuf.len, obuf.s, hdr_txt,
+				hdr_lumps, bdy_txt, bdy_lumps, end_txt);
 	}
 
 	/* free lumps */
-	if (hdr_lumps) {
+	if(hdr_lumps) {
 		pkg_free(hdr_lumps);
 	}
 
-	if (bdy_lumps) {
+	if(bdy_lumps) {
 		pkg_free(bdy_lumps);
 	}
 
@@ -608,7 +616,7 @@ static int w_dbg_sip_msg(struct sip_msg* msg, char *level, char *facility)
 /**
  * dump pv_cache contents as json with default parameters
  */
-static int ki_dbg_pv_dump(sip_msg_t* msg)
+static int ki_dbg_pv_dump(sip_msg_t *msg)
 {
 	dbg_dump_json(msg, DBG_DP_ALL, L_DBG);
 	return 1;
@@ -617,7 +625,7 @@ static int ki_dbg_pv_dump(sip_msg_t* msg)
 /**
  * dump pv_cache contents as json with explicit parameters
  */
-static int ki_dbg_pv_dump_ex(sip_msg_t* msg, int mask, int level)
+static int ki_dbg_pv_dump_ex(sip_msg_t *msg, int mask, int level)
 {
 	dbg_dump_json(msg, (unsigned int)mask, level);
 	return 1;