@@ -56,12 +56,12 @@ static inline int get_uri_user(struct sip_msg* _m, str** _uri_user)

     if ((REQ_LINE(_m).method.len == 8) && 

 	(memcmp(REQ_LINE(_m).method.s, "REGISTER", 8) == 0)) {

 	if ((puri=parse_to_uri(_m))==NULL) {

-	    LOG(L_ERR, "get_uri_user(): Error while parsing To header\n");

+	    LM_ERR("failed to parse To header\n");

 	    return -1;

 	}

     } else {

 	if ((puri=parse_from_uri(_m))==NULL) {

-	    LOG(L_ERR, "get_uri_user(): Error while parsing From header\n");

+	    LM_ERR("parsing From header\n");

 	    return -1;

 	}

     }

@@ -89,7 +89,7 @@ static inline int authorize(struct sip_msg* _msg, pv_elem_t* _realm,

     /* get pre_auth domain from _realm pvar (if exists) */

     if (_realm) {

 	if (pv_printf_s(_msg, _realm, &domain)!=0) {

-	    LOG(L_ERR,"ERROR:auth_radius:authorize: pv_printf_s failed\n");

+	    LM_ERR("pv_printf_s failed\n");

 	    return AUTH_ERROR;

 	}

     } else {

@@ -114,23 +114,21 @@ static inline int authorize(struct sip_msg* _msg, pv_elem_t* _realm,

 					       &_msg->first_line.u.request.method,

 					       &pv_val.rs);

 	    } else {

-		LOG(L_ERR, "ERROR:auth_radius:authorize: "

-		    "uri_user pvar value is not string\n");

+		LM_ERR("uri_user pvar value is not string\n");

 		return AUTH_ERROR;

 	    }

 	} else {

-	    LOG(L_ERR, "ERROR:auth_radius:authorize: "

-		"cannot get uri_user pvar value\n");

+	    LM_ERR("cannot get uri_user pvar value\n");

 	    return AUTH_ERROR;

 	}

     } else {

 	if (get_uri_user(_msg, &uri_user) < 0) {

-	    LOG(L_ERR, "authorize(): To/From URI not found\n");

+	    LM_ERR("To/From URI not found\n");

 	    return AUTH_ERROR;

 	}

 	user.s = (char *)pkg_malloc(uri_user->len);

 	if (user.s == NULL) {

-	    LOG(L_ERR, "authorize: No memory left for user\n");

+	    LM_ERR("no pkg memory left for user\n");

 	    return AUTH_ERROR;

 	}

 	un_escape(uri_user, &user);

@@ -114,7 +114,7 @@ static int mod_init(void)

 	DICT_VENDOR *vend;

 	bind_auth_t bind_auth;

-	DBG("auth_radius - Initializing\n");

+	LM_INFO("initializing...\n");

 	memset(attrs, 0, sizeof(attrs));

 	memset(vals, 0, sizeof(vals));

@@ -137,30 +137,29 @@ static int mod_init(void)

 	vals[V_SIP_SESSION].n			= "Sip-Session";

 	if ((rh = rc_read_config(radius_config)) == NULL) {

-		LOG(L_ERR, "auth_radius: Error opening configuration file \n");

+		LM_ERR("failed to open configuration file \n");

 		return -1;

 	}

 	if (rc_read_dictionary(rh, rc_conf_str(rh, "dictionary")) != 0) {

-		LOG(L_ERR, "auth_radius: Error opening dictionary file \n");

+		LM_ERR("failed to open dictionary file \n");

 		return -2;

 	}

 	vend = rc_dict_findvend(rh, "Cisco");

 	if (vend == NULL) {

-		DBG("auth_radius: No `Cisco' vendor in Radius "

-			   "dictionary\n");

+		LM_DBG("no `Cisco' vendor in Radius dictionary\n");

 		attrs[A_CISCO_AVPAIR].n = NULL;

 	}

 	bind_auth = (bind_auth_t)find_export("bind_auth", 0, 0);

 	if (!bind_auth) {

-		LOG(L_ERR, "auth_radius: Unable to find bind_auth function\n");

+		LM_ERR("unable to find bind_auth function\n");

 		return -1;

 	}

 	if (bind_auth(&auth_api) < 0) {

-		LOG(L_ERR, "auth_radius: Cannot bind to auth module\n");

+		LM_ERR("cannot bind to auth module\n");

 		return -4;

 	}

@@ -190,8 +189,7 @@ static int auth_fixup(void** param, int param_no)

 		} else {

 			s.len = strlen(s.s);

 			if (pv_parse_format(&s,&model)<0) {

-				LOG(L_ERR, "ERROR:auth_radius:auth_fixup: "

-				    "pv_parse_format failed\n");

+				LM_ERR("pv_parse_format failed\n");

 				return E_OUT_OF_MEM;

 			}

 		}

@@ -201,21 +199,18 @@ static int auth_fixup(void** param, int param_no)

 	if (param_no == 2) { /* URI user (a pvar) */

 		sp = (pv_spec_t*)pkg_malloc(sizeof(pv_spec_t));

 		if (sp == 0) {

-			LOG(L_ERR, "ERROR:auth_radius:auth_fixup(): "

-			    "no pkg memory left\n");

+			LM_ERR("no pkg memory left\n");

 			return -1;

 		}

 		s.s = (char*)*param;

 		s.len = strlen(s.s);

 		if (pv_parse_spec(&s, sp) == 0) {

-			LOG(L_ERR,"ERROR:auth_radius:auth_fixup(): parsing of "

-			    "pseudo variable %s failed!\n", (char*)*param);

+			LM_ERR("parsing of pseudo variable %s failed!\n", (char*)*param);

 			pkg_free(sp);

 			return -1;

 		}

 		if (sp->type == PVT_NULL) {

-			LOG(L_ERR,"ERROR:auth_radius:auth_fixup(): bad pseudo "

-			    "variable\n");

+			LM_ERR("bad pseudo variable\n");

 			pkg_free(sp);

 			return -1;

 		}

@@ -58,8 +58,7 @@ static inline int extract_avp(VALUE_PAIR* vp, unsigned short *flags,

 	p = vp->strvalue;

 	end = vp->strvalue + vp->lvalue;

-	DBG("DEBUG:auth_radius:extract_avp: string is <%.*s>\n",

-		(int)(long)(end-p), p);

+	LM_DBG("string is <%.*s>\n", (int)(long)(end-p), p);

 	/* get name */

 	if (*p!='#') {

@@ -74,12 +73,11 @@ static inline int extract_avp(VALUE_PAIR* vp, unsigned short *flags,

 	while( p<end && *p!=':' && *p!='#')

 		p++;

 	if (names.s==p || p==end) {

-		LOG(L_ERR,"ERROR:auth_radius:extract_avp: empty AVP name\n");

+		LM_ERR("empty AVP name\n");

 		goto error;

 	}

 	names.len = p - names.s;

-	DBG("DEBUG:auth_radius:extract_avp: AVP name is <%.*s>\n",

-		names.len, names.s);

+	LM_DBG("AVP name is <%.*s>\n", names.len, names.s);

 	/* get value */

 	if (*p!='#') {

@@ -89,17 +87,15 @@ static inline int extract_avp(VALUE_PAIR* vp, unsigned short *flags,

 	values.s = ++p;

 	values.len = end-values.s;

 	if (values.len==0) {

-		LOG(L_ERR,"ERROR:auth_radius:extract_avp: empty AVP value\n");

+		LM_ERR("empty AVP value\n");

 		goto error;

 	}

-	DBG("DEBUG:auth_radius:extract_avp: AVP val is <%.*s>\n",

-		values.len, values.s);

+	LM_DBG("AVP val is <%.*s>\n", values.len, values.s);

 	if ( !((*flags)&AVP_NAME_STR) ) {

 		/* convert name to id*/

 		if (str2int(&names,&r)!=0 ) {

-			LOG(L_ERR,"ERROR:auth_radius:extract_avp: invalid AVP ID '%.*s'\n",

-				names.len,names.s);

+			LM_ERR("invalid AVP ID '%.*s'\n", names.len,names.s);

 			goto error;

 		}

 		name->n = (int)r;

@@ -110,8 +106,7 @@ static inline int extract_avp(VALUE_PAIR* vp, unsigned short *flags,

 	if ( !((*flags)&AVP_VAL_STR) ) {

 		/* convert value to integer */

 		if (str2int(&values,&r)!=0 ) {

-			LOG(L_ERR,"ERROR:auth_radius:extract_avp: invalid AVP numrical "

-				"value '%.*s'\n", values.len,values.s);

+			LM_ERR("invalid AVP numrical value '%.*s'\n", values.len,values.s);

 			goto error;

 		}

 		value->n = (int)r;

@@ -136,19 +131,16 @@ static int generate_avps(VALUE_PAIR* received)

 	vp = received;

-	DBG("DEBUG:auth_radius:generate_avps: getting SIP AVPs from avpair %d\n",

-		attrs[A_SIP_AVP].v);

+	LM_DBG("getting SIP AVPs from avpair %d\n",	attrs[A_SIP_AVP].v);

 	for( ; (vp=rc_avpair_get(vp,attrs[A_SIP_AVP].v,0)) ; vp=vp->next) {

 		flags = 0;

 		if (extract_avp( vp, &flags, &name, &val)!=0 )

 			continue;

 		if (add_avp( flags, name, val) < 0) {

-			LOG(L_ERR, "ERROR:auth_radius:generate_avps: Unable to create "

-				"a new AVP\n");

+			LM_ERR("unable to create a new AVP\n");

 		} else {

-			DBG("DEBUG:auth_radius:generate_avps: "

-				"AVP '%.*s'/%d='%.*s'/%d has been added\n",

+			LM_DBG("AVP '%.*s'/%d='%.*s'/%d has been added\n",

 				(flags&AVP_NAME_STR)?name.s.len:4,

 				(flags&AVP_NAME_STR)?name.s.s:"null",

 				(flags&AVP_NAME_STR)?0:name.n,

@@ -167,21 +159,19 @@ static int add_cisco_vsa(VALUE_PAIR** send, struct sip_msg* msg)

 	str callid;

 	if (!msg->callid && parse_headers(msg, HDR_CALLID_F, 0) == -1) {

-		LOG(L_ERR, "ERROR:auth_radius:add_cisco_vsa: Cannot parse "

-			"Call-ID header field\n");

+		LM_ERR("cannot parse Call-ID header field\n");

 		return -1;

 	}

 	if (!msg->callid) {

-		LOG(L_ERR, "ERROR:auth_radius:add_cisco_vsa: Call-ID header "

-			"field not found\n");

+		LM_ERR("call-ID header field not found\n");

 		return -1;

 	}

 	callid.len = msg->callid->body.len + 8;

 	callid.s = pkg_malloc(callid.len);

 	if (callid.s == NULL) {

-		LOG(L_ERR, "ERROR:auth_radius:add_cisco_vsa: No pkg memory left\n");

+		LM_ERR("no pkg memory left\n");

 		return -1;

 	}

@@ -190,8 +180,7 @@ static int add_cisco_vsa(VALUE_PAIR** send, struct sip_msg* msg)

 	if (rc_avpair_add(rh, send, attrs[A_CISCO_AVPAIR].v, callid.s,

 			callid.len, VENDOR(attrs[A_CISCO_AVPAIR].v)) == 0) {

-		LOG(L_ERR, "ERROR:auth_radius:add_cisco_vsa: Unable to add "

-			"Cisco-AVPair attribute\n");

+		LM_ERR("unable to add Cisco-AVPair attribute\n");

 		pkg_free(callid.s);

 		return -1;

 	}

@@ -219,8 +208,7 @@ int radius_authorize_sterman(struct sip_msg* _msg, dig_cred_t* _cred, str* _meth

 	send = received = 0;

 	if (!(_cred && _method && _user)) {

-		LOG(L_ERR, "ERROR:auth_radius:radius_authorize_sterman: "

-			"Invalid parameter value\n");

+		LM_ERR("invalid parameter value\n");

 		return -1;

 	}

@@ -233,16 +221,14 @@ int radius_authorize_sterman(struct sip_msg* _msg, dig_cred_t* _cred, str* _meth

 	 */

 	if (_cred->username.domain.len) {

 		if (!rc_avpair_add(rh, &send, attrs[A_USER_NAME].v, _cred->username.whole.s, _cred->username.whole.len, 0)) {

-			LOG(L_ERR, "ERROR:auth_radius:radius_authorize_sterman: Unable "

-				"to add User-Name attribute\n");

+			LM_ERR("unable to add User-Name attribute\n");

 			goto err;

 		}

 	} else {

 		user_name.len = _cred->username.user.len + _cred->realm.len + 1;

 		user_name.s = pkg_malloc(user_name.len);

 		if (!user_name.s) {

-			LOG(L_ERR, "ERROR:auth_radius:radius_authorize_sterman: "

-				"No pkg memory left\n");

+			LM_ERR("no pkg memory left\n");

 			return -3;

 		}

 		memcpy(user_name.s, _cred->username.whole.s, _cred->username.whole.len);

@@ -251,8 +237,7 @@ int radius_authorize_sterman(struct sip_msg* _msg, dig_cred_t* _cred, str* _meth

 			_cred->realm.len);

 		if (!rc_avpair_add(rh, &send, attrs[A_USER_NAME].v, user_name.s,

 		user_name.len, 0)) {

-			LOG(L_ERR, "ERROR:auth_radius:radius_authorize_sterman: "

-				"Unable to add User-Name attribute\n");

+			LM_ERR("unable to add User-Name attribute\n");

 			pkg_free(user_name.s);

 			goto err;

 		}

@@ -261,34 +246,29 @@ int radius_authorize_sterman(struct sip_msg* _msg, dig_cred_t* _cred, str* _meth

 	if (!rc_avpair_add(rh, &send, attrs[A_DIGEST_USER_NAME].v, 

 	_cred->username.whole.s, _cred->username.whole.len, 0)) {

-		LOG(L_ERR, "ERROR:auth_radius:radius_authorize_sterman: "

-			"Unable to add Digest-User-Name attribute\n");

+		LM_ERR("unable to add Digest-User-Name attribute\n");

 		goto err;

 	}

 	if (!rc_avpair_add(rh, &send, attrs[A_DIGEST_REALM].v, _cred->realm.s,

 	_cred->realm.len, 0)) {

-		LOG(L_ERR, "ERROR:auth_radius:radius_authorize_sterman: Unable "

-			"to add Digest-Realm attribute\n");

+		LM_ERR("unable to add Digest-Realm attribute\n");

 		goto err;

 	}

 	if (!rc_avpair_add(rh, &send, attrs[A_DIGEST_NONCE].v, _cred->nonce.s,

 	_cred->nonce.len, 0)) {

-		LOG(L_ERR, "ERROR:auth_radius:radius_authorize_sterman: Unable "

-			"to add Digest-Nonce attribute\n");

+		LM_ERR("unable to add Digest-Nonce attribute\n");

 		goto err;

 	}

 	if (!rc_avpair_add(rh, &send, attrs[A_DIGEST_URI].v, _cred->uri.s,

 	_cred->uri.len, 0)) {

-		LOG(L_ERR, "ERROR:auth_radius:radius_authorize_sterman: Unable "

-				"to add Digest-URI attribute\n");

+		LM_ERR("unable to add Digest-URI attribute\n");

 		goto err;

 	}

 	if (!rc_avpair_add(rh, &send, attrs[A_DIGEST_METHOD].v, method.s,

 	method.len, 0)) {

-		LOG(L_ERR, "ERROR:auth_radius:radius_authorize_sterman: Unable "

-			"to add Digest-Method attribute\n");

+		LM_ERR("unable to add Digest-Method attribute\n");

 		goto err;

 	}

@@ -297,45 +277,38 @@ int radius_authorize_sterman(struct sip_msg* _msg, dig_cred_t* _cred, str* _meth

 	 */

 	if (_cred->qop.qop_parsed == QOP_AUTH) {

 		if (!rc_avpair_add(rh, &send, attrs[A_DIGEST_QOP].v, "auth", 4, 0)) {

-			LOG(L_ERR, "ERROR:auth_radius:radius_authorize_sterman: "

-				"Unable to add Digest-QOP attribute\n");

+			LM_ERR("unable to add Digest-QOP attribute\n");

 			goto err;

 		}

 		if (!rc_avpair_add(rh, &send, attrs[A_DIGEST_NONCE_COUNT].v, 

 		_cred->nc.s, _cred->nc.len, 0)) {

-			LOG(L_ERR, "ERROR:auth_radius:radius_authorize_sterman: Unable "

-				"to add Digest-CNonce-Count attribute\n");

+			LM_ERR("unable to add Digest-CNonce-Count attribute\n");

 			goto err;

 		}

 		if (!rc_avpair_add(rh, &send, attrs[A_DIGEST_CNONCE].v, 

 		_cred->cnonce.s, _cred->cnonce.len, 0)) {

-			LOG(L_ERR, "ERROR:auth_radius:radius_authorize_sterman: Unable "

-				"to add Digest-CNonce attribute\n");

+			LM_ERR("unable to add Digest-CNonce attribute\n");

 			goto err;

 		}

 	} else if (_cred->qop.qop_parsed == QOP_AUTHINT) {

 		if (!rc_avpair_add(rh, &send, attrs[A_DIGEST_QOP].v,

 		"auth-int", 8, 0)) {

-			LOG(L_ERR, "ERROR:auth_radius:radius_authorize_sterman: Unable "

-				"to add Digest-QOP attribute\n");

+			LM_ERR("unable to add Digest-QOP attribute\n");

 			goto err;

 		}

 		if (!rc_avpair_add(rh, &send, attrs[A_DIGEST_NONCE_COUNT].v,

 		_cred->nc.s, _cred->nc.len, 0)) {

-			LOG(L_ERR, "ERROR:auth_radius:radius_authorize_sterman: Unable "

-				"to add Digest-Nonce-Count attribute\n");

+			LM_ERR("unable to add Digest-Nonce-Count attribute\n");

 			goto err;

 		}

 		if (!rc_avpair_add(rh, &send, attrs[A_DIGEST_CNONCE].v,

 		_cred->cnonce.s, _cred->cnonce.len, 0)) {

-			LOG(L_ERR, "ERROR:auth_radius:radius_authorize_sterman: Unable "

-				"to add Digest-CNonce attribute\n");

+			LM_ERR("unable to add Digest-CNonce attribute\n");

 			goto err;

 		}

 		if (!rc_avpair_add(rh, &send, attrs[A_DIGEST_BODY_DIGEST].v, 

 		_cred->opaque.s, _cred->opaque.len, 0)) {

-			LOG(L_ERR, "ERROR:auth_radius:radius_authorize_sterman: Unable "

-				"to add Digest-Body-Digest attribute\n");

+			LM_ERR("unable to add Digest-Body-Digest attribute\n");

 			goto err;

 		}

@@ -346,22 +319,20 @@ int radius_authorize_sterman(struct sip_msg* _msg, dig_cred_t* _cred, str* _meth

 	/* Add the response... What to calculate against... */

 	if (!rc_avpair_add(rh, &send, attrs[A_DIGEST_RESPONSE].v, 

 	_cred->response.s, _cred->response.len, 0)) {

-		LOG(L_ERR, "sterman(): Unable to add Digest-Response attribute\n");

+		LM_ERR("unable to add Digest-Response attribute\n");

 		goto err;

 	}

 	/* Indicate the service type, Authenticate only in our case */

 	service = vals[V_SIP_SESSION].v;

 	if (!rc_avpair_add(rh, &send, attrs[A_SERVICE_TYPE].v, &service, -1, 0)) {

-		LOG(L_ERR, "ERROR:auth_radius:radius_authorize_sterman: Unable to "

-			"add Service-Type attribute\n");

+		LM_ERR("unable to add Service-Type attribute\n");

 		goto err;

 	}

 	/* Add SIP URI as a check item */

 	if (!rc_avpair_add(rh,&send,attrs[A_SIP_URI_USER].v,user.s,user.len,0)) {

-		LOG(L_ERR, "ERROR:auth_radius:radius_authorize_sterman: Unable to "

-			"add Sip-URI-User attribute\n");

+		LM_ERR("unable to add Sip-URI-User attribute\n");

 		goto err;

 	}

@@ -373,7 +344,7 @@ int radius_authorize_sterman(struct sip_msg* _msg, dig_cred_t* _cred, str* _meth

 	/* Send request */

 	if ((i = rc_auth(rh, SIP_PORT, send, &received, msg)) == OK_RC) {

-		DBG("DEBUG:auth_radius:radius_authorize_sterman: Success\n");

+		LM_DBG("Success\n");

 		rc_avpair_free(send);

 		send = 0;

@@ -382,8 +353,7 @@ int radius_authorize_sterman(struct sip_msg* _msg, dig_cred_t* _cred, str* _meth

 		rc_avpair_free(received);

 		return 1;

 	} else {

-		LOG(L_ERR,"ERROR:auth_radius:radius_authorize_sterman: "

-			"rc_auth failed\n");

+		LM_ERR("rc_auth failed\n");

 		goto err;

 	}

@@ -169,6 +169,7 @@ static int reset_gflag(struct sip_msg *bar, char *flag, char *foo)

 static int is_gflag(struct sip_msg *bar, char *flag, char *foo)

 {

+	LM_DBG("-------mask %X , flags %X", (*gflags), ((unsigned int)(long)flag));

 	return ( (*gflags) & ((unsigned int)(long)flag)) ? 1 : -1;

 }

@@ -67,20 +67,17 @@ static int mi_sock_check(int fd, char* fname);

 #define mi_create_dtgram_replysocket(_socketfd,_socket_domain, _err) \

 	_socketfd = socket(_socket_domain, SOCK_DGRAM, 0);\

 	if (_socketfd == -1) {\

-		LOG(L_ERR, "ERROR: datagram_fnc: mi_create_dtgram_replysocket"\

-			"cannot create socket: %s\n", strerror(errno));\

+		LM_ERR("cannot create socket: %s\n", strerror(errno));\

 		goto _err;\

 	}\

 	/* Turn non-blocking mode on for tx*/\

 	flags = fcntl(_socketfd, F_GETFL);\

 	if (flags == -1){\

-		LOG(L_ERR, "ERROR: datagram_fnc: mi_create_dtgram_replysocket: "\

-		"fcntl failed: %s\n", strerror(errno));\

+		LM_ERR("fcntl failed: %s\n", strerror(errno));\

 		goto _err;\

 	}\

 	if (fcntl(_socketfd, F_SETFL, flags | O_NONBLOCK) == -1) {\

-		LOG(L_ERR, "ERROR: datagram_fnc: mi_create_dtgram_replysocket:"\

-		"fcntl: set non-blocking failed: %s\n", strerror(errno));\

+		LM_ERR("fcntl: set non-blocking failed: %s\n", strerror(errno));\

 		goto _err;\

 	}

@@ -97,21 +94,18 @@ int  mi_init_datagram_server(sockaddr_dtgram *addr, unsigned int socket_domain,

 	socks->rx_sock = socket(socket_domain, SOCK_DGRAM, 0);

 	if (socks->rx_sock == -1) {

-		LOG(L_ERR, "ERROR: datagram_fnc: mi_init_datagram_server: "

-			"Cannot create RX socket: %s\n", strerror(errno));

+		LM_ERR("cannot create RX socket: %s\n", strerror(errno));

 		return -1;

 	}

 	switch(socket_domain)

 	{

 	case AF_LOCAL:

-			DBG("DBG:datagram_fnc:mi_init_datagram_server: we have a "

-				"unix socket, socket_name is %s\n",addr->unix_addr.sun_path);

+			LM_DBG("we have a unix socket: %s\n", addr->unix_addr.sun_path);

 			socket_name = addr->unix_addr.sun_path;

 			if(bind(socks->rx_sock,(struct sockaddr*)&addr->unix_addr, 

 					SUN_LEN(&addr->unix_addr))< 0) {

-				LOG(L_ERR, "ERROR: datagram_fnc: mi_init_datagram_server: "

-				"bind: %s\n", strerror(errno));

+				LM_ERR("bind: %s\n", strerror(errno));

 				goto err_rx;

 			}

 			if(mi_sock_check(socks->rx_sock, socket_name)!=0)

@@ -119,18 +113,16 @@ int  mi_init_datagram_server(sockaddr_dtgram *addr, unsigned int socket_domain,

 			/* change permissions */

 			if (mode){

 				if (chmod(socket_name, mode)<0){

-					LOG(L_ERR, "ERROR: datagram_fnc: mi_mod_init: failed to "

-						"change the permissions for %s to %04o: %s[%d]\n",

-							socket_name, mode, strerror(errno), errno);

+					LM_ERR("failed to change the permissions for %s to %04o:"

+						"%s[%d]\n",socket_name, mode, strerror(errno), errno);

 					goto err_rx;

 				}

 			}

 			/* change ownership */

 			if ((uid!=-1) || (gid!=-1)){

 				if (chown(socket_name, uid, gid)<0){

-					LOG(L_ERR, "ERROR: datagram_fnc: mi_mod_init: failed to "

-						"change the owner/group for %s  to %d.%d; %s[%d]\n",

-						socket_name, uid, gid, strerror(errno), errno);

+					LM_ERR("failed to change the owner/group for %s  to %d.%d;"

+					"%s[%d]\n",socket_name, uid, gid, strerror(errno), errno);

 					goto err_rx;

 				}

 			}

@@ -139,8 +131,7 @@ int  mi_init_datagram_server(sockaddr_dtgram *addr, unsigned int socket_domain,

 	case AF_INET:

 			if (bind(socks->rx_sock, (struct sockaddr*)&addr->udp_addr.sin,

 						sizeof(addr->udp_addr))	< 0) {

-				LOG(L_ERR, "ERROR: datagram_fnc: mi_init_datagram_server: "

-					"bind: %s\n", strerror(errno));

+				LM_ERR("bind: %s\n", strerror(errno));

 				goto err_rx;

 			}

 			break;

@@ -148,15 +139,13 @@ int  mi_init_datagram_server(sockaddr_dtgram *addr, unsigned int socket_domain,

 	case AF_INET6: 

 			if(bind(socks->rx_sock, (struct sockaddr*)&addr->udp_addr.sin6,

 					sizeof(addr->udp_addr)) < 0) {

-				LOG(L_ERR, "ERROR: datagram_fnc: mi_init_datagram_server: "

-					"bind: %s\n", strerror(errno));

+				LM_ERR("bind: %s\n", strerror(errno));

 				goto err_rx;

 			}

 			break;

 #endif

 	default:

-			LOG(L_ERR, "ERROR: mi_datagram: mi_init_datagram_server: domain "

-				"not supported\n");

+			LM_ERR("domain not supported\n");

 			goto err_both;

 	}

@@ -176,8 +165,7 @@ int mi_init_datagram_buffer(void){

 	mi_buf = pkg_malloc(DATAGRAM_SOCK_BUF_SIZE);

 	if ( mi_buf==NULL) {

-		LOG(L_ERR,"ERROR:datagram_fnc:mi_init_datagram_server: no more "

-		"pkg memory\n");

+		LM_ERR("no more pkg memory\n");

 		return -1;

 	}

 	return 0;

@@ -193,41 +181,38 @@ int mi_sock_check(int fd, char* fname)

 	struct stat lst;

 	if (fstat(fd, &fst)<0){

-		LOG(L_ERR, "ERROR:datagram_fnc:mi_sock_check: fstat failed: %s\n", 

+		LM_ERR("fstat failed: %s\n", 

 		strerror(errno));

 		return -1;

 	}

 	/* check if socket */

 	if (!S_ISSOCK(fst.st_mode)){

-		LOG(L_ERR, "ERROR:datagram_fnc:mi_sock_check: %s is not a sock\n", 

-		fname);

+		LM_ERR("%s is not a sock\n", fname);

 		return -1;

 	}

 	/* check if hard-linked */

 	if (fst.st_nlink>1){

-		LOG(L_ERR, "ERROR:datagram_fnc:mi_sock_check: security: sock_check: "

-			"%s is hard-linked %d times\n", fname, (unsigned)fst.st_nlink);

+		LM_ERR("security: sock_check: %s is hard-linked %d times\n", 

+				fname, (unsigned)fst.st_nlink);

 		return -1;

 	}

 	/* lstat to check for soft links */

 	if (lstat(fname, &lst)<0){

-		LOG(L_ERR, "ERROR:datagram_fnc:mi_sock_check: lstat failed: %s\n",

-				strerror(errno));

+		LM_ERR("lstat failed: %s\n", strerror(errno));

 		return -1;

 	}

 	if (S_ISLNK(lst.st_mode)){

-		LOG(L_ERR, "ERROR:datagram_fnc:mi_sock_check: security: sock_check: "

-			"%s is a soft link\n", fname);

+		LM_ERR("security: sock_check: %s is a soft link\n", fname);

 		return -1;

 	}

 	/* if this is not a symbolic link, check to see if the inode didn't

 	 * change to avoid possible sym.link, rm sym.link & replace w/ sock race

 	 */

-	/*DBG("for %s lst.st_dev %fl fst.st_dev %i lst.st_ino %i fst.st_ino"

+	/*LM_DBG("for %s lst.st_dev %fl fst.st_dev %i lst.st_ino %i fst.st_ino"

 		"%i\n", fname, lst.st_dev, fst.st_dev, lst.st_ino, fst.st_ino);*/

 	/*if ((lst.st_dev!=fst.st_dev)||(lst.st_ino!=fst.st_ino)){

-		LOG(L_ERR, "ERROR:datagram_fnc:mi_sock_check: security: sock_check: "

+		LM_ERR("security: sock_check: "

 			"socket	%s inode/dev number differ: %d %d \n", fname,

 			(int)fst.st_ino, (int)lst.st_ino);

 	}*/

@@ -245,21 +230,19 @@ static int mi_send_dgram(int fd, char* buf, unsigned int len,

 	size_t total_len;

 	total_len = strlen(buf);

-	/*DBG("mi_datagram:mi_send_dgram:response is %s \n tolen is %i "

+	/*LM_DBG("response is %s \n tolen is %i "

 			"and len is %i\n",buf,	tolen,len);*/

 	if(total_len == 0 || tolen ==0)

 		return -1;

-	DBG("DBG: datagram_fnc: mi_send_dgram: datagram_size is %i\n",

-			DATAGRAM_SOCK_BUF_SIZE);

+	

 	if (total_len>DATAGRAM_SOCK_BUF_SIZE)

 	{

-		DBG("DBG: datagram_fnc: mi_send_dgram: datagram too big, "

+		LM_DBG("datagram too big, "

 			"truncking, datagram_size is %i\n",DATAGRAM_SOCK_BUF_SIZE);

 		len = DATAGRAM_SOCK_BUF_SIZE;

 	}

-	/*DBG("DBG:mi_datagram:mi_send_dgram: destination address length "

-			"is %i\n", tolen);*/

+	/*LM_DBG("destination address length is %i\n", tolen);*/

 	n=sendto(fd, buf, len, 0, to, tolen);

 	return n;

 }

@@ -276,49 +259,45 @@ static int identify_command(datagram_stream * dtgram, struct mi_cmd * *f)

 	p= dtgram->start;

 	start = p;

 	if (!p){

-		LOG(L_ERR, "ERR:datagram_fnc:identify_command: null pointer  \n");

+		LM_ERR("null pointer  \n");

 		return -1;

 	}

 	/*if no command*/

 	if ( dtgram->len ==0 ){

-		DBG("DBG:datagram_fnc:identify_command:command empty case1 \n");

+		LM_DBG("command empty case1 \n");

 		goto error;

 	}

 	if (*p != MI_CMD_SEPARATOR){

-		LOG(L_ERR, "ERROR:datagram_fnc:identify_command: command must begin "

-			"with: %c \n", MI_CMD_SEPARATOR);

+		LM_ERR("command must begin with: %c \n", MI_CMD_SEPARATOR);

 		goto error;

 	}

 	command = p+1;

-	DBG("DBG:datagram_fnc:identify_command: the command starts here: "

-				"%s\n", command);

+	LM_DBG("the command starts here: %s\n", command);

 	p=strchr(command, MI_CMD_SEPARATOR );

 	if (!p ){

-		LOG(L_ERR, "ERROR:datagram_fnc:identify_command: empty command \n");

+		LM_ERR("empty command \n");

 		goto error;

 	}

 	if(*(p+1)!='\n'){

-		LOG(L_ERR,"ERROR:datagram_fnc:identify_command: the request first line"

-			"is invalid :no newline after the second %c\n",MI_CMD_SEPARATOR);

+		LM_ERR("the request's first line is invalid :no newline after "

+				"the second %c\n",MI_CMD_SEPARATOR);

 		goto error;

 	}

 	/* make command zero-terminated */

 	*p=0;

-	DBG("DBG:datagram_fnc:identify_command: the command "

-		"is %s\n",command);

+	LM_DBG("the command is %s\n",command);

 	/*search for the appropiate command*/

 	*f=lookup_mi_cmd( command, p-command);

 	if(!*f)

 		goto error;

 	/*the current offset has changed*/

-	DBG("mi_datagram:identify_command: dtgram->len is "

-		"%i\n", dtgram->len);

+	LM_DBG("dtgram->len is %i\n", dtgram->len);

 	dtgram->current = p+2 ;

 	dtgram->len -=p+2 - dtgram->start;

-	DBG("mi_datagram:identify_command: dtgram->len is %i\n",dtgram->len);

+	LM_DBG("dtgram->len is %i\n",dtgram->len);

 	return 0;

 error:

@@ -344,8 +323,7 @@ static void datagram_close_async(struct mi_root *mi_rpl,struct mi_handler *hdl,

 	p = (my_socket_address *)hdl->param;

-	DBG("DEBUG:mi_datagram:datagram_close_async: the socket domain is %i and"

-		"af_local is %i\n", p->domain,AF_LOCAL);

+	LM_DBG("the socket domain is %i and af_local is %i\n", p->domain,AF_LOCAL);

 	mi_create_dtgram_replysocket(reply_sock,p->domain, err);

@@ -356,19 +334,16 @@ static void datagram_close_async(struct mi_root *mi_rpl,struct mi_handler *hdl,

 			/*allocate the response datagram*/	

 			dtgram.start = pkg_malloc(DATAGRAM_SOCK_BUF_SIZE);

 			if(!dtgram.start){

-				LOG(L_ERR, "ERROR: mi_datagram_datagram_close_async: failed"

-					"to allocate the response datagram \n");

+				LM_ERR("no more pkg memory\n");

 				goto err;

 			}

 			/*build the response*/

 			if(mi_datagram_write_tree(&dtgram , mi_rpl) != 0){

-				LOG(L_ERR, "ERROR mi_datagram:datagram_close_async: error"

-					"while building the response \n");	

+				LM_ERR("failed to build the response \n");	

 				goto err1;

 			}

-			DBG("mi_datagram:close_async: the response is %s",

-				dtgram.start);

+			LM_DBG("the response is %s", dtgram.start);

 			/*send the response*/

 			ret = mi_send_dgram(reply_sock, dtgram.start,

@@ -376,12 +351,10 @@ static void datagram_close_async(struct mi_root *mi_rpl,struct mi_handler *hdl,

 							 (struct sockaddr *)&p->address, 

 							 p->address_len, mi_socket_timeout);

 			if (ret>0){

-				DBG("DBG mi_datagram:datagram_close_async : the "

-					"response: %s has been sent in %i octets\n", 

+				LM_DBG("the response: %s has been sent in %i octets\n", 

 					dtgram.start, ret);

 			}else{

-				LOG(L_ERR, "ERROR midatagram:mi_datagram_server: an error "

-				"occured while sending the response, ret is %i\n",ret);

+				LM_ERR("failed to send the response, ret is %i\n",ret);

 			}

 			free_mi_tree( mi_rpl );

 			pkg_free(dtgram.start);

@@ -419,7 +392,7 @@ static inline struct mi_handler* build_async_handler(unsigned int sock_domain,

 	hdl = (struct mi_handler*)shm_malloc( sizeof(struct mi_handler) +

 			sizeof(my_socket_address));

 	if (hdl==0) {

-		LOG(L_ERR,"ERROR:mi_datagram:build_async_handler: no more shm mem\n");

+		LM_ERR("no more shm mem\n");

 		return 0;

 	}

@@ -428,26 +401,24 @@ static inline struct mi_handler* build_async_handler(unsigned int sock_domain,

 	switch(sock_domain)

 	{/*we can have either of these types of sockets*/

-		case AF_LOCAL:	DBG("mi_datagram:mi_datagram_server :"

-							"we have an unix socket\n");

+		case AF_LOCAL:	LM_DBG("we have an unix socket\n");

 						memcpy(&repl_address->address.unix_deb, 

 								(struct sockaddr*)reply_addr, 

 								reply_addr_len);

 						break;

-		case AF_INET:	DBG("mi_datagram:mi_datagram_server :"

-							"we have an IPv4 socket\n");

+		case AF_INET:	LM_DBG("we have an IPv4 socket\n");

 						memcpy(&repl_address->address.inet_v4, 

 								(struct sockaddr*)reply_addr, 

 								reply_addr_len);

 						break;

-		case AF_INET6:	DBG("mi_datagram:mi_datagram_server :"

-						"we have an IPv6 socket\n");

+		case AF_INET6:	LM_DBG("we have an IPv6 socket\n");

 						memcpy(&repl_address->address.inet_v6, 

 								(struct sockaddr*)reply_addr, 

 								reply_addr_len);

 						break;

-		default:		LOG(L_CRIT, "BUG: mi_datagram:build_async_handler :"

-							"socket_domain has an incorrect value\n");

+		default:		LM_CRIT("socket_domain has an incorrect value\n");

+						shm_free(hdl);

+						return 0;

 	}

 	repl_address->domain = sock_domain;

@@ -483,85 +454,73 @@ void mi_datagram_server(int rx_sock, int tx_sock)

 					(struct sockaddr*)&reply_addr, &reply_addr_len);

 		if (ret == -1) {

-			LOG(L_ERR, "datagram_fnc: mi_datagram_server: recvfrom: (%d) %s\n",

-				errno, strerror(errno));

+			LM_ERR("recvfrom: (%d) %s\n", errno, strerror(errno));

 			if ((errno == EINTR) ||

 				(errno == EAGAIN) ||

 				(errno == EWOULDBLOCK) ||

 				(errno == ECONNREFUSED)) {

-				DBG("datagram_fnc:mi_datagram_server: Got %d (%s), going on\n",

-					errno, strerror(errno));

+				LM_DBG("got %d (%s), going on\n", errno, strerror(errno));

 				continue;

 			}

-			DBG("DBG:datagram_fnc:mi_datagram_server: error in recvfrom\n");

+			LM_DBG("error in recvfrom\n");

 			continue;

 		}

 		if(ret == 0)

 			continue;

-		DBG("DBG: mi_datagram: mi_datagram_server: "

-			"process %i has received %.*s\n", getpid(), ret, mi_buf);

+		LM_DBG("received %.*s\n", ret, mi_buf);

 		if(ret> DATAGRAM_SOCK_BUF_SIZE){

-				LOG(L_ERR, "ERROR: mi_datagram:mi_datagram_server: "

-					"buffer overflow\n");

+				LM_ERR("buffer overflow\n");

 				continue;

 		}

-		DBG("DBG:mi-datagram:mi_datagram_server: mi_buf is %s and "

-			"we have received %i bytes\n",mi_buf, ret);

+		LM_DBG("mi_buf is %s and we have received %i bytes\n",mi_buf, ret);

 		dtgram.start 	= mi_buf;

 		dtgram.len 		= ret;

 		dtgram.current 	= dtgram.start;

 		ret = identify_command(&dtgram, &f);

-		DBG("DBG: datagram:mi_datagram_server: the function "

-				"identify_command exited with the value %i\n", ret);

 		/*analyze the command--from the first line*/

 		if(ret != 0)

 		{

-			LOG(L_ERR, "ERROR:datagram_fnc:identify_command: command not "

-				"available\n");

+			LM_ERR("command not available\n");

 			mi_send_dgram(tx_sock, MI_COMMAND_NOT_AVAILABLE, 

 						  MI_COMMAND_AVAILABLE_LEN, 

 						  (struct sockaddr* )&reply_addr, reply_addr_len, 

 						  mi_socket_timeout);

 			continue;

 		}

-		DBG("DBG:datagram_fnc:mi_datagram_server: we have a valid "

-			"command \n");

+		LM_DBG("we have a valid command \n");

 		/* if asyncron cmd, build the async handler */

 		if (f->flags&MI_ASYNC_RPL_FLAG) {

 			hdl = build_async_handler(mi_socket_domain, &reply_addr, 

 										reply_addr_len);

 			if (hdl==0) {

-				LOG(L_ERR, "ERROR:datagram_fnc:mi_datagram_server: failed to "

-					"build async handler\n");

-				mi_send_dgram(tx_sock, MI_INTERNAL_ERROR, MI_INTERNAL_ERROR_LEN, 							(struct sockaddr* )&reply_addr, reply_addr_len, 

-								mi_socket_timeout);

+				LM_ERR("failed to build async handler\n");

+				mi_send_dgram(tx_sock, MI_INTERNAL_ERROR,

+						MI_INTERNAL_ERROR_LEN,(struct sockaddr* )&reply_addr,

+						reply_addr_len, mi_socket_timeout);

 				continue;

 			}

 		} else{

 			hdl = 0;

 		}

-		DBG("DBG:datagram_fnc:mi_datagram_server: after identifing "

-				"the command, the received datagram is  %s\n",dtgram.current);

+		LM_DBG("after identifing the command, the received datagram is  %s\n",

+				dtgram.current);

 		/*if no params required*/

 		if (f->flags&MI_NO_INPUT_FLAG) {

-			DBG("DBG:datagram_fnc:mi_datagram_server: the function "

-					"has no params\n");

+			LM_DBG("the command has no params\n");

 			mi_cmd = 0;

 		} else {

-			DBG("DBG:datagram_fnc:mi_datagram_server: parsing the "

-					"function's params\n");

+			LM_DBG("parsing the command's params\n");