@@ -752,7 +752,7 @@ int do_action(struct run_act_ctx* h, struct action* a, struct sip_msg* msg)

 					len=strlen(a->val[0].u.string);

 					msg->new_uri.s=pkg_malloc(len+1);

 					if (msg->new_uri.s==0){

-						LM_ERR("memory allocation failure\n");

+						PKG_MEM_ERROR;

 						ret=E_OUT_OF_MEM;

 						goto error;

 					}

@@ -802,7 +802,7 @@ int do_action(struct run_act_ctx* h, struct action* a, struct sip_msg* msg)

 				new_uri=pkg_malloc(MAX_URI_SIZE);

 				if (new_uri==0){

-					LM_ERR("memory allocation failure\n");

+					PKG_MEM_ERROR;

 					ret=E_OUT_OF_MEM;

 					goto error;

 				}

@@ -1433,8 +1433,7 @@ static char* addstr(struct str_buf* dst_b, char* src, int len)

 	return dst_b->s;

 error:

-	LM_CRIT("lex: memory allocation error\n");

-	LM_CRIT("lex: try to increase pkg size with -M parameter\n");

+	PKG_MEM_CRITICAL;

 	exit(-1);

 }

@@ -1602,7 +1601,7 @@ static int sr_push_yy_state(char *fin, int mode)

 		newf = (char*)pkg_malloc(x-tmpfiname+strlen(fbuf)+2);

 		if(newf==0)

 		{

-			LM_CRIT("no more pkg\n");

+			PKG_MEM_CRITICAL;

 			return -1;

 		}

 		newf[0] = '\0';

@@ -1664,7 +1663,7 @@ static int sr_push_yy_state(char *fin, int mode)

 		{

 			if(newf!=fbuf)

 				pkg_free(newf);

-			LM_CRIT("no more pkg\n");

+			PKG_MEM_CRITICAL;

 			return -1;

 		}

 		if(newf==fbuf)

@@ -1673,7 +1672,7 @@ static int sr_push_yy_state(char *fin, int mode)

 			if(fn->fname==0)

 			{

 				pkg_free(fn);

-				LM_CRIT("no more pkg!\n");

+				PKG_MEM_CRITICAL;

 				return -1;

 			}

 			strcpy(fn->fname, fbuf);

@@ -1793,7 +1792,7 @@ int pp_define(int len, const char * text)

 	pp_defines[pp_num_defines].name.len = len;

 	pp_defines[pp_num_defines].name.s = (char*)pkg_malloc(len+1);

 	if(pp_defines[pp_num_defines].name.s==NULL) {

-		LM_CRIT("no more memory to define: %.*s\n", len, text);

+		PKG_MEM_CRITICAL;

 		return -1;

 	}

 	memcpy(pp_defines[pp_num_defines].name.s, text, len);

@@ -649,7 +649,7 @@ listen_id:

 			} else {

 				$$=pkg_malloc(strlen(tmp)+1);

 				if ($$==0) {

-					LM_CRIT("cfg. parser: out of memory.\n");

+					PKG_MEM_CRITICAL;

 				} else {

 					strncpy($$, tmp, strlen(tmp)+1);

 				}

@@ -659,7 +659,7 @@ listen_id:

 	| STRING {

 		$$=pkg_malloc(strlen($1)+1);

 		if ($$==0) {

-				LM_CRIT("cfg. parser: out of memory.\n");

+				PKG_MEM_CRITICAL;

 		} else {

 				strncpy($$, $1, strlen($1)+1);

 		}

@@ -668,7 +668,7 @@ listen_id:

 		if ($1){

 			$$=pkg_malloc(strlen($1)+1);

 			if ($$==0) {

-					LM_CRIT("cfg. parser: out of memory.\n");

+					PKG_MEM_CRITICAL;

 			} else {

 					strncpy($$, $1, strlen($1)+1);

 			}

@@ -1470,7 +1470,7 @@ assign_stm:

 	| ADVERTISED_PORT EQUAL NUMBER {

 		tmp=int2str($3, &i_tmp);

 		if ((default_global_port.s=pkg_malloc(i_tmp))==0) {

-			LM_CRIT("cfg. parser: out of memory.\n");

+			PKG_MEM_CRITICAL;

 			default_global_port.len=0;

 		} else {

 			default_global_port.len=i_tmp;

@@ -1789,7 +1789,7 @@ ipv4:

 	NUMBER DOT NUMBER DOT NUMBER DOT NUMBER {

 		$$=pkg_malloc(sizeof(struct ip_addr));

 		if ($$==0) {

-			LM_CRIT("cfg. parser: out of memory.\n");

+			PKG_MEM_CRITICAL;

 		} else {

 			memset($$, 0, sizeof(struct ip_addr));

 			$$->af=AF_INET;

@@ -1818,7 +1818,7 @@ ipv6addr:

 	IPV6ADDR {

 		$$=pkg_malloc(sizeof(struct ip_addr));

 		if ($$==0) {

-			LM_CRIT("cfg. parser: out of memory.\n");

+			PKG_MEM_CRITICAL;

 		} else {

 			memset($$, 0, sizeof(struct ip_addr));

 			$$->af=AF_INET6;

@@ -2271,8 +2271,7 @@ host:

 		if ($1){

 			$$=(char*)pkg_malloc(strlen($1)+1+strlen($3)+1);

 			if ($$==0) {

-				LM_CRIT("cfg. parser: memory allocation"

-							" failure while parsing host\n");

+				PKG_MEM_CRITICAL;

 			} else {

 				memcpy($$, $1, strlen($1));

 				$$[strlen($1)]='.';

@@ -2287,8 +2286,7 @@ host:

 		if ($1){

 			$$=(char*)pkg_malloc(strlen($1)+1+strlen($3)+1);

 			if ($$==0) {

-				LM_CRIT("cfg. parser: memory allocation"

-							" failure while parsing host\n");

+				PKG_MEM_CRITICAL;

 			} else {

 				memcpy($$, $1, strlen($1));

 				$$[strlen($1)]='-';

@@ -2308,8 +2306,11 @@ host_if_id: ID

 		| NUMBER {

 			/* get string version */

 			$$=pkg_malloc(strlen(yy_number_str)+1);

-			if ($$)

+			if ($$==0) {

+				PKG_MEM_ERROR;

+			} else {

 				strcpy($$, yy_number_str);

+			}

 		}

 		;

@@ -2319,8 +2320,7 @@ host_or_if:

 		if ($1){

 			$$=(char*)pkg_malloc(strlen($1)+1+strlen($3)+1);

 			if ($$==0) {

-				LM_CRIT("cfg. parser: memory allocation"

-							" failure while parsing host/interface name\n");

+				PKG_MEM_CRITICAL;

 			} else {

 				memcpy($$, $1, strlen($1));

 				$$[strlen($1)]='.';

@@ -2335,8 +2335,7 @@ host_or_if:

 		if ($1){

 			$$=(char*)pkg_malloc(strlen($1)+1+strlen($3)+1);

 			if ($$==0) {

-				LM_CRIT("cfg. parser: memory allocation"

-							" failure while parsing host/interface name\n");

+				PKG_MEM_CRITICAL;

 			} else {

 				memcpy($$, $1, strlen($1));

 				$$[strlen($1)]='-';

@@ -3294,7 +3293,7 @@ cmd:

 	| SET_ADV_ADDRESS LPAREN listen_id RPAREN {

 		$$=0;

 		if ((str_tmp=pkg_malloc(sizeof(str)))==0) {

-			LM_CRIT("cfg. parser: out of memory.\n");

+			PKG_MEM_CRITICAL;

 		} else {

 			str_tmp->s=$3;

 			str_tmp->len=$3?strlen($3):0;

@@ -3308,10 +3307,10 @@ cmd:

 		$$=0;

 		tmp=int2str($3, &i_tmp);

 		if ((str_tmp=pkg_malloc(sizeof(str)))==0) {

-			LM_CRIT("cfg. parser: out of memory.\n");

+			PKG_MEM_CRITICAL;

 		} else {

 			if ((str_tmp->s=pkg_malloc(i_tmp))==0) {

-				LM_CRIT("cfg. parser: out of memory.\n");

+				PKG_MEM_CRITICAL;

 			} else {

 				memcpy(str_tmp->s, tmp, i_tmp);

 				str_tmp->len=i_tmp;

@@ -3680,7 +3679,7 @@ static struct name_lst* mk_name_lst(char* host, int flags)

 	if (host==0) return 0;

 	l=pkg_malloc(sizeof(struct name_lst));

 	if (l==0) {

-		LM_CRIT("cfg. parser: out of memory.\n");

+		PKG_MEM_CRITICAL;

 	} else {

 		l->name=host;

 		l->flags=flags;

@@ -3696,7 +3695,7 @@ static struct socket_id* mk_listen_id(char* host, int proto, int port)

 	if (host==0) return 0;

 	l=pkg_malloc(sizeof(struct socket_id));

 	if (l==0) {

-		LM_CRIT("cfg. parser: out of memory.\n");

+		PKG_MEM_CRITICAL;

 	} else {

 		l->addr_lst=mk_name_lst(host, 0);

 		if (l->addr_lst==0){

@@ -3731,7 +3730,7 @@ static struct socket_id* mk_listen_id2(struct name_lst* addr_l, int proto,

 	if (addr_l==0) return 0;

 	l=pkg_malloc(sizeof(struct socket_id));

 	if (l==0) {

-		LM_CRIT("cfg. parser: out of memory.\n");

+		PKG_MEM_CRITICAL;

 	} else {

 		l->flags=addr_l->flags;

 		l->port=port;

@@ -49,7 +49,7 @@ int cfg_declare(char *group_name, cfg_def_t *def, void *values, int def_size,

 	mapping = (cfg_mapping_t *)pkg_malloc(sizeof(cfg_mapping_t)*num);

 	if (!mapping) {

-		LM_ERR("not enough memory\n");

+		PKG_MEM_ERROR;

 		goto error;

 	}

 	memset(mapping, 0, sizeof(cfg_mapping_t)*num);

@@ -212,7 +212,7 @@ int cfg_declare_str(char *group_name, char *var_name, char *val, char *descr)

 		len = strlen(val);

 		var->val.s.s = (char *)pkg_malloc(sizeof(char) * (len + 1));

 		if (!var->val.s.s) {

-			LM_ERR("not enough memory\n");

+			PKG_MEM_ERROR;

 			return -1;

 		}

 		memcpy(var->val.s.s, val, len + 1);

@@ -46,7 +46,7 @@ int cfg_register_ctx(cfg_ctx_t **handle, cfg_on_declare on_declare_cb)

 	 * must be in shm mem anyway */

 	ctx = (cfg_ctx_t *)shm_malloc(sizeof(cfg_ctx_t));

 	if (!ctx) {

-		LM_ERR("not enough shm memory\n");

+		SHM_MEM_ERROR;

 		return -1;

 	}

 	memset(ctx, 0, sizeof(cfg_ctx_t));

@@ -183,7 +183,7 @@ int convert_val(unsigned int val_type, void *val,

 				if (temp_string) pkg_free(temp_string);

 				temp_string = (char *)pkg_malloc(sizeof(char) * (((str *)val)->len + 1));

 				if (!temp_string) {

-					LM_ERR("not enough memory\n");

+					PKG_MEM_ERROR;

 					return -1;

 				}

 				memcpy(temp_string, ((str *)val)->s, ((str *)val)->len);

@@ -427,7 +427,7 @@ int cfg_set_now(cfg_ctx_t *ctx, str *group_name, unsigned int *group_id, str *va

 				var->def->on_set_child_cb,

 				var->def->type);

 		if (!child_cb) {

-			LM_ERR("not enough shm memory\n");

+			SHM_MEM_ERROR;

 			goto error0;

 		}

 	}

@@ -558,7 +558,7 @@ int cfg_set_now(cfg_ctx_t *ctx, str *group_name, unsigned int *group_id, str *va

 			replaced = (void **)shm_malloc(sizeof(void *)

 					* ((old_string?1:0) + (new_array?1:0) + 1));

 			if (!replaced) {

-				LM_ERR("not enough shm memory\n");

+				SHM_MEM_ERROR;

 				goto error;

 			}

 			i = 0;

@@ -782,7 +782,7 @@ int cfg_set_delayed(cfg_ctx_t *ctx, str *group_name, unsigned int *group_id,

 		if (ctx->changed_first) {

 			temp_handle = (unsigned char *)pkg_malloc(group->size);

 			if (!temp_handle) {

-				LM_ERR("not enough memory\n");

+				PKG_MEM_ERROR;

 				goto error;

 			}

 			temp_handle_created = 1;

@@ -831,7 +831,7 @@ int cfg_set_delayed(cfg_ctx_t *ctx, str *group_name, unsigned int *group_id,

 		+ ((val_type != CFG_VAR_UNSET) ? cfg_var_size(var) : 0);

 	changed = (cfg_changed_var_t *)shm_malloc(size);

 	if (!changed) {

-		LM_ERR("not enough shm memory\n");

+		SHM_MEM_ERROR;

 		goto error;

 	}

 	memset(changed, 0, size);

@@ -1063,7 +1063,7 @@ int cfg_commit(cfg_ctx_t *ctx)

 		size = sizeof(void *)*(replaced_num + 1);

 		replaced = (void **)shm_malloc(size);

 		if (!replaced) {

-			LM_ERR("not enough shm memory\n");

+			SHM_MEM_ERROR;

 			goto error0;

 		}

 		memset(replaced, 0 , size);

@@ -1635,7 +1635,7 @@ int cfg_add_group_inst(cfg_ctx_t *ctx, str *group_name, unsigned int group_id)

 		 * they will be freed when the old block is freed */

 		replaced = (void **)shm_malloc(sizeof(void *) * 2);

 		if (!replaced) {

-			LM_ERR("not enough shm memory\n");

+			SHM_MEM_ERROR;

 			goto error;

 		}

 		replaced[0] = CFG_GROUP_META(*cfg_global, group)->array;

@@ -1740,7 +1740,7 @@ int cfg_del_group_inst(cfg_ctx_t *ctx, str *group_name, unsigned int group_id)

 		replaced = (void **)shm_malloc(sizeof(void *) * (num + 2));

 		if (!replaced) {

-			LM_ERR("not enough shm memory\n");

+			SHM_MEM_ERROR;

 			goto error;

 		}

@@ -139,7 +139,7 @@ cfg_script_var_t *new_cfg_script_var(char *gname, char *vname, unsigned int type

 	return var;

 error:

-	LM_ERR("not enough memory\n");

+	PKG_MEM_ERROR;

 	return NULL;

 }

@@ -188,7 +188,7 @@ int cfg_set_script_var(cfg_group_t *group, str *var_name,

 					s.len = ((str *)v)->len;

 					s.s = pkg_malloc(sizeof(char) * (s.len + 1));

 					if (!s.s) {

-						LM_ERR("not enough memory\n");

+						PKG_MEM_ERROR;

 						goto error;

 					}

 					memcpy(s.s, ((str *)v)->s, s.len);

@@ -325,7 +325,7 @@ error:

 	if (def) pkg_free(def);

 	if (handle) pkg_free(handle);

-	LM_ERR("not enough memory\n");

+	PKG_MEM_ERROR;

 	return -1;

 }

@@ -73,7 +73,7 @@ static int cfg_new_select(str *gname, str *vname, void **group_p, void **var_p)

 	return 0;

 error:

-	LM_ERR("not enough memory\n");

+	PKG_MEM_ERROR;

 	if (sel) {

 		if (sel->gname.s) pkg_free(sel->gname.s);

 		if (sel->vname.s) pkg_free(sel->vname.s);

@@ -78,7 +78,7 @@ cfg_group_t *cfg_new_group(char *name, int name_len,

 	group = (cfg_group_t *)pkg_malloc(sizeof(cfg_group_t)+name_len-1);

 	if (!group) {

-		LM_ERR("not enough memory\n");

+		PKG_MEM_ERROR;

 		return NULL;

 	}

 	memset(group, 0, sizeof(cfg_group_t)+name_len-1);

@@ -129,7 +129,7 @@ int cfg_clone_str(str *src, str *dst)

 	c = (char *)shm_malloc(sizeof(char)*(src->len+1));

 	if (!c) {

-		LM_ERR("not enough shm memory\n");

+		SHM_MEM_ERROR;

 		return -1;

 	}

 	memcpy(c, src->s, src->len);

@@ -216,7 +216,7 @@ int cfg_shmize(void)

 	block = (cfg_block_t*)shm_malloc(sizeof(cfg_block_t)+size-1);

 	if (!block) {

-		LM_ERR("not enough shm memory\n");

+		SHM_MEM_ERROR;

 		goto error;

 	}

 	memset(block, 0, sizeof(cfg_block_t)+size-1);

@@ -319,9 +319,10 @@ static void cfg_destory_groups(unsigned char *block)

 /* initiate the cfg framework */

 int sr_cfg_init(void)

 {

+	/* lock_alloc() is a define for shm_malloc */

 	cfg_global_lock = lock_alloc();

 	if (!cfg_global_lock) {

-		LM_ERR("not enough shm memory\n");

+		SHM_MEM_ERROR;

 		goto error;

 	}

 	if (lock_init(cfg_global_lock) == 0) {

@@ -333,7 +334,7 @@ int sr_cfg_init(void)

 	cfg_writer_lock = lock_alloc();

 	if (!cfg_writer_lock) {

-		LM_ERR("not enough shm memory\n");

+		SHM_MEM_ERROR;

 		goto error;

 	}

 	if (lock_init(cfg_writer_lock) == 0) {

@@ -345,21 +346,21 @@ int sr_cfg_init(void)

 	cfg_global = (cfg_block_t **)shm_malloc(sizeof(cfg_block_t *));

 	if (!cfg_global) {

-		LM_ERR("not enough shm memory\n");

+		SHM_MEM_ERROR;

 		goto error;

 	}

 	*cfg_global = NULL;

 	cfg_child_cb_first = (cfg_child_cb_t **)shm_malloc(sizeof(cfg_child_cb_t *));

 	if (!cfg_child_cb_first) {

-		LM_ERR("not enough shm memory\n");

+		SHM_MEM_ERROR;

 		goto error;

 	}

 	*cfg_child_cb_first = NULL;

 	cfg_child_cb_last = (cfg_child_cb_t **)shm_malloc(sizeof(cfg_child_cb_t *));

 	if (!cfg_child_cb_last) {

-		LM_ERR("not enough shm memory\n");

+		SHM_MEM_ERROR;

 		goto error;

 	}

 	*cfg_child_cb_last = NULL;

@@ -624,7 +625,7 @@ cfg_block_t *cfg_clone_global(void)

 	block = (cfg_block_t*)shm_malloc(sizeof(cfg_block_t)+cfg_block_size-1);

 	if (!block) {

-		LM_ERR("not enough shm memory\n");

+		SHM_MEM_ERROR;

 		return NULL;

 	}

 	memcpy(block, *cfg_global, sizeof(cfg_block_t)+cfg_block_size-1);

@@ -647,7 +648,7 @@ cfg_group_inst_t *cfg_clone_array(cfg_group_meta_t *meta, cfg_group_t *group)

 	size = (sizeof(cfg_group_inst_t) + group->size - 1) * meta->num;

 	new_array = (cfg_group_inst_t *)shm_malloc(size);

 	if (!new_array) {

-		LM_ERR("not enough shm memory\n");

+		SHM_MEM_ERROR;

 		return NULL;

 	}

 	memcpy(new_array, meta->array, size);

@@ -668,7 +669,7 @@ cfg_group_inst_t *cfg_extend_array(cfg_group_meta_t *meta, cfg_group_t *group,

 	inst_size = sizeof(cfg_group_inst_t) + group->size - 1;

 	new_array = (cfg_group_inst_t *)shm_malloc(inst_size * (meta->num + 1));

 	if (!new_array) {

-		LM_ERR("not enough shm memory\n");

+		SHM_MEM_ERROR;

 		return NULL;

 	}

 	/* Find the position of the new group in the array. The array is ordered

@@ -717,7 +718,7 @@ int cfg_collapse_array(cfg_group_meta_t *meta, cfg_group_t *group,

 	inst_size = sizeof(cfg_group_inst_t) + group->size - 1;

 	new_array = (cfg_group_inst_t *)shm_malloc(inst_size * (meta->num - 1));

 	if (!new_array) {

-		LM_ERR("not enough shm memory\n");

+		SHM_MEM_ERROR;

 		return -1;

 	}

@@ -796,7 +797,7 @@ void cfg_install_global(cfg_block_t *block, void **replaced,

 				cb_last = cb_first;

 				cb_first->replaced = replaced;

 			} else {

-				LM_ERR("not enough shm memory\n");

+				SHM_MEM_ERROR;

 				/* Nothing more can be done here, the replaced strings are still needed,

 				 * they cannot be freed at this moment.

 				 */

@@ -827,7 +828,7 @@ cfg_child_cb_t *cfg_child_cb_new(str *gname, str *name,

 	cb_struct = (cfg_child_cb_t *)shm_malloc(sizeof(cfg_child_cb_t));

 	if (!cb_struct) {

-		LM_ERR("not enough shm memory\n");

+		SHM_MEM_ERROR;

 		return NULL;

 	}

 	memset(cb_struct, 0, sizeof(cfg_child_cb_t));

@@ -923,7 +924,7 @@ int new_add_var(str *group_name, unsigned int group_id, str *var_name,

 	add_var = (cfg_add_var_t *)pkg_malloc(sizeof(cfg_add_var_t) +

 			(type ? (var_name->len - 1) : 0));

 	if (!add_var) {

-		LM_ERR("Not enough memory\n");

+		PKG_MEM_ERROR;

 		goto error;

 	}

 	memset(add_var, 0, sizeof(cfg_add_var_t) +

@@ -944,7 +945,7 @@ int new_add_var(str *group_name, unsigned int group_id, str *var_name,

 				if (len) {

 					add_var->val.s.s = (char *)pkg_malloc(sizeof(char) * len);

 					if (!add_var->val.s.s) {

-						LM_ERR("Not enough memory\n");

+						PKG_MEM_ERROR;

 						goto error;

 					}

 					memcpy(add_var->val.s.s, ((str *)val)->s, len);

@@ -959,7 +960,7 @@ int new_add_var(str *group_name, unsigned int group_id, str *var_name,

 					len = strlen((char *)val);

 					add_var->val.ch = (char *)pkg_malloc(sizeof(char) * (len + 1));

 					if (!add_var->val.ch) {

-						LM_ERR("Not enough memory\n");

+						PKG_MEM_ERROR;

 						goto error;

 					}

 					memcpy(add_var->val.ch, (char *)val, len);

@@ -1049,7 +1050,7 @@ static int apply_add_var_list(cfg_block_t *block, cfg_group_t *group)

 	size = (sizeof(cfg_group_inst_t) + group->size - 1) * num;

 	new_array = (cfg_group_inst_t *)shm_malloc(size);

 	if (!new_array) {

-		LM_ERR("not enough shm memory\n");

+		SHM_MEM_ERROR;

 		return -1;

 	}

 	memset(new_array, 0, size);

@@ -287,6 +287,7 @@ static void print_token(cfg_token_t* token)

 			token->type, STR_FMT(&token->val),

 			token->start.line, token->start.col, 

 			token->end.line, token->end.col);

+			PKG_MEM_ERROR;

 	} else {

 		for(i = 0, j = 0; i < token->val.len; i++) {

 			switch(token->val.s[i]) {

@@ -599,7 +600,7 @@ static char* get_base_name(str* filename)

 	len = strlen(tmp2);

 	if ((res = pkg_malloc(len + 1)) == NULL) {

-		ERR("cfg_parser: No memory left");

+	        PKG_MEM_ERROR;

 		goto error;

 	}

 	memcpy(res, tmp2, len + 1);

@@ -644,7 +645,7 @@ cfg_parser_t* cfg_parser_init(str* basedir, str* filename)

 	if ((base = get_base_name(filename)) == NULL) goto error;

 	if ((st = (cfg_parser_t*)pkg_malloc(sizeof(*st))) == NULL) {

-		ERR("cfg_parser: No memory left\n");

+	        PKG_MEM_ERROR;

 		goto error;

 	}

 	memset(st, '\0', sizeof(*st));

@@ -904,22 +905,19 @@ int cfg_parse_str(void* param, cfg_parser_t* st, unsigned int flags)

 		buf = val->s;

 	} else if (flags & CFG_STR_SHMMEM) {

 		if ((buf = shm_malloc(t.val.len + 1)) == NULL) {

-			ERR("%s:%d:%d: Out of shared memory\n", st->file,

-				t.start.line, t.start.col);

+		        SHM_MEM_ERROR;

 			return -1;

 		}

 		if (val->s) shm_free(val->s);

 	} else if (flags & CFG_STR_MALLOC) {

 		if ((buf = malloc(t.val.len + 1)) == NULL) {

-			ERR("%s:%d:%d: Out of malloc memory\n", st->file,

-				t.start.line, t.start.col);

+		        SYS_MEM_ERROR;

 			return -1;

 		}

 		if (val->s) free(val->s);

 	} else if (flags & CFG_STR_PKGMEM) {

 		if ((buf = pkg_malloc(t.val.len + 1)) == NULL) {

-			ERR("%s:%d:%d: Out of private memory\n", st->file,

-				t.start.line, t.start.col);

+		        PKG_MEM_ERROR;

 			return -1;

 		}

 		if (val->s) pkg_free(val->s);

@@ -453,7 +453,7 @@ static void core_pwd(rpc_t* rpc, void* c)

 	max_len = pathmax();

 	cwd_buf = pkg_malloc(max_len);

 	if (!cwd_buf) {

-		ERR("core_pwd: No memory left\n");

+		PKG_MEM_ERROR;

 		rpc->fault(c, 500, "Server Ran Out of Memory");

 		return;

 	}

@@ -114,14 +114,18 @@ int init_counters()

 	grp_no = 0;

 	cnt_id2record_size = CNT_ID2RECORD_SIZE;

 	cnt_id2record = pkg_malloc(sizeof(*cnt_id2record) * cnt_id2record_size);

-	if (cnt_id2record == 0)

+	if (cnt_id2record == 0) {

+		PKG_MEM_ERROR;

 		goto error;

+	}

 	memset(cnt_id2record, 0, sizeof(*cnt_id2record) * cnt_id2record_size);

 	grp_sorted_max_size = GRP_SORTED_SIZE;

 	grp_sorted_crt_size = 0;

 	grp_sorted = pkg_malloc(sizeof(*grp_sorted) * grp_sorted_max_size);

-	if (grp_sorted == 0)

+	if (grp_sorted == 0) {

+		PKG_MEM_ERROR;

 		goto error;

+	}

 	memset(grp_sorted, 0, sizeof(*grp_sorted) * grp_sorted_max_size);

 	return 0;

 error:

@@ -205,8 +209,10 @@ int counters_prefork_init(int max_process_no)

 	   the final shm version (with max_process_no rows) */

 	old = _cnts_vals;

 	_cnts_vals = shm_malloc(size);

-	if (_cnts_vals == 0)

+	if (_cnts_vals == 0) {

+		SHM_MEM_ERROR;

 		return -1;

+	}

 	memset(_cnts_vals, 0, size);

 	cnts_max_rows = max_process_no;

 	/* copy prefork values into the newly shm array */

@@ -232,8 +238,10 @@ static struct grp_record* grp_hash_add(str* group)

 	/* grp_rec copied at &g->u.data */

 	g = pkg_malloc(sizeof(struct str_hash_entry) - sizeof(g->u.data) +

 					sizeof(*grp_rec) + group->len + 1);

-	if (g == 0)

+	if (g == 0) {

+		PKG_MEM_ERROR;

 		goto error;

+	}

 	grp_rec = (struct grp_record*)&g->u.data[0];

 	grp_rec->group.s = (char*)(grp_rec + 1);

 	grp_rec->group.len = group->len;

@@ -330,8 +338,10 @@ static struct counter_record* cnt_hash_add(

 	e = pkg_malloc(sizeof(struct str_hash_entry) - sizeof(e->u.data) +

 					sizeof(*cnt_rec) + name->len + 1 + group->len + 1 +

 					doc_len + 1);

-	if (e == 0)

+	if (e == 0) {

+		PKG_MEM_ERROR;

 		goto error;

+	}

 	cnt_rec = (struct counter_record*)&e->u.data[0];

 	cnt_rec->group.s = (char*)(cnt_rec + 1);

 	cnt_rec->group.len = group->len;

@@ -57,7 +57,7 @@ struct lump* append_new_lump(struct lump** list, char* new_hdr,

 	tmp=pkg_malloc(sizeof(struct lump));

 	if (tmp==0){

-		LM_ERR("out of memory\n");

+		PKG_MEM_ERROR;

 		return 0;

 	}

@@ -83,7 +83,7 @@ struct lump* add_new_lump(struct lump** list, char* new_hdr,

 	tmp=pkg_malloc(sizeof(struct lump));

 	if (tmp==0){

-		LM_ERR("out of memory\n");

+		PKG_MEM_ERROR;

 		return 0;

 	}

@@ -108,7 +108,7 @@ struct lump* insert_new_lump(struct lump** list, char* new_hdr,

 	tmp=pkg_malloc(sizeof(struct lump));

 	if (tmp==0){

-		LM_ERR("out of memory\n");

+		PKG_MEM_ERROR;

 		return 0;

 	}

 	memset(tmp,0,sizeof(struct lump));

@@ -133,7 +133,7 @@ struct lump* insert_new_lump_after( struct lump* after, char* new_hdr,

 	tmp=pkg_malloc(sizeof(struct lump));

 	if (tmp==0){

 		ser_error=E_OUT_OF_MEM;

-		LM_ERR("out of memory\n");

+		PKG_MEM_ERROR;

 		return 0;

 	}

 	memset(tmp,0,sizeof(struct lump));

@@ -158,7 +158,7 @@ struct lump* insert_new_lump_before( struct lump* before, char* new_hdr,

 	tmp=pkg_malloc(sizeof(struct lump));

 	if (tmp==0){

 		ser_error=E_OUT_OF_MEM;

-		LM_ERR("out of memory\n");

+		PKG_MEM_ERROR;

 		return 0;

 	}

 	memset(tmp,0,sizeof(struct lump));

@@ -183,7 +183,7 @@ struct lump* insert_subst_lump_after( struct lump* after, enum lump_subst subst,

 	tmp=pkg_malloc(sizeof(struct lump));

 	if (tmp==0){

 		ser_error=E_OUT_OF_MEM;

-		LM_ERR("out of memory\n");

+		PKG_MEM_ERROR;

 		return 0;

 	}

 	memset(tmp,0,sizeof(struct lump));

@@ -209,7 +209,7 @@ struct lump* insert_subst_lump_before(	struct lump* before,

 	tmp=pkg_malloc(sizeof(struct lump));

 	if (tmp==0){

 		ser_error=E_OUT_OF_MEM;

-		LM_ERR("out of memory\n");

+		PKG_MEM_ERROR;

 		return 0;

 	}

 	memset(tmp,0,sizeof(struct lump));

@@ -234,7 +234,7 @@ struct lump* insert_cond_lump_after( struct lump* after, enum lump_conditions c,

 	tmp=pkg_malloc(sizeof(struct lump));

 	if (tmp==0){

 		ser_error=E_OUT_OF_MEM;

-		LM_ERR("out of memory\n");

+		PKG_MEM_ERROR;

 		return 0;

 	}

 	memset(tmp,0,sizeof(struct lump));

@@ -260,7 +260,7 @@ struct lump* insert_cond_lump_before(	struct lump* before,

 	tmp=pkg_malloc(sizeof(struct lump));

 	if (tmp==0){

 		ser_error=E_OUT_OF_MEM;

-		LM_ERR("out of memory\n");

+		PKG_MEM_ERROR;

 		return 0;

 	}

 	memset(tmp,0,sizeof(struct lump));

@@ -303,7 +303,7 @@ struct lump* del_lump(struct sip_msg* msg, int offset, int len, enum _hdr_types_

 	tmp=pkg_malloc(sizeof(struct lump));

 	if (tmp==0){

-		LM_ERR("out of memory\n");

+		PKG_MEM_ERROR;

 		return 0;

 	}

 	memset(tmp,0,sizeof(struct lump));

@@ -358,7 +358,7 @@ struct lump* anchor_lump(struct sip_msg* msg, int offset, int len, enum _hdr_typ

 	tmp=pkg_malloc(sizeof(struct lump));

 	if (tmp==0){

 		ser_error=E_OUT_OF_MEM;

-		LM_ERR("out of memory\n");

+		PKG_MEM_ERROR;

 		return 0;

 	}

 	memset(tmp,0,sizeof(struct lump));

@@ -436,7 +436,7 @@ struct lump* anchor_lump2(struct sip_msg* msg, int offset, int len, enum _hdr_ty

 	tmp=pkg_malloc(sizeof(struct lump));

 	if (tmp==0){

 		ser_error=E_OUT_OF_MEM;

-		LM_ERR("out of memory\n");

+		PKG_MEM_ERROR;

 		return 0;

 	}

 	memset(tmp,0,sizeof(struct lump));

@@ -535,7 +535,11 @@ static struct lump *dup_lump_list_r( struct lump *l,

 	if (!l) { *error=0; return 0; }

 	/* otherwise duplicate current element */

 	new_lump=pkg_malloc(sizeof(struct lump));

-	if (!new_lump) { *error=1; return 0; }

+	if (!new_lump) {

+		PKG_MEM_ERROR;

+		*error=1;

+		return 0;

+	}

 	memcpy(new_lump, l, sizeof(struct lump));

 	new_lump->flags=LUMPFLAG_DUPED;

@@ -750,7 +754,7 @@ int sr_hdr_add(sip_msg_t *msg, str *sname, str *sbody)

 	h.len = sname->len + 2 + sbody->len + CRLF_LEN;

 	h.s = (char*)pkg_malloc(h.len+1);

 	if(h.s == 0) {

-		LM_ERR("no more pkg\n");

+		PKG_MEM_ERROR;

 		return -1;

 	}

 	anchor = anchor_lump(msg, msg->last_header->name.s + msg->last_header->len

@@ -56,7 +56,7 @@ struct lump_rpl** add_lump_rpl2(struct sip_msg *msg, char *s,

 	lump = (struct lump_rpl*) pkg_malloc

 		( sizeof(struct lump_rpl) + ((flags&LUMP_RPL_NODUP)?0:len) );

 	if (!lump) {

-		LM_ERR("no free pkg memory !\n");

+		PKG_MEM_ERROR;

 		goto error;

 	}

@@ -335,6 +335,7 @@ int init_dns_cache()

 	}

 	dns_cache_mem_used=shm_malloc(sizeof(*dns_cache_mem_used));

 	if (dns_cache_mem_used==0){

+		SHM_MEM_ERROR;

 		ret=E_OUT_OF_MEM;

 		goto error;

 	}

@@ -342,6 +343,7 @@ int init_dns_cache()

 	dns_last_used_lst=shm_malloc(sizeof(*dns_last_used_lst));

 	if (dns_last_used_lst==0){

+		SHM_MEM_ERROR;

 		ret=E_OUT_OF_MEM;

 		goto error;

 	}

@@ -349,6 +351,7 @@ int init_dns_cache()

 	dns_hash=shm_malloc(sizeof(struct dns_hash_head)*DNS_HASH_SIZE);

 	if (dns_hash==0){

+		SHM_MEM_ERROR;

 		ret=E_OUT_OF_MEM;

 		goto error;

 	}

@@ -370,6 +373,7 @@ int init_dns_cache()

 #ifdef DNS_WATCHDOG_SUPPORT

 	dns_servers_up=shm_malloc(sizeof(atomic_t));

 	if (dns_servers_up==0){

+		SHM_MEM_ERROR;

 		ret=E_OUT_OF_MEM;

 		goto error;

 	}

@@ -416,6 +420,7 @@ int init_dns_cache_stats(int iproc_num)

 	dns_cache_stats=shm_malloc(sizeof(*dns_cache_stats) * iproc_num);

 	if (dns_cache_stats==0){

+		SHM_MEM_ERROR;

 		return E_OUT_OF_MEM;

 	}

 	memset(dns_cache_stats, 0, sizeof(*dns_cache_stats) * iproc_num);

@@ -757,7 +762,7 @@ inline static struct dns_hash_entry* dns_cache_mk_bad_entry(str* name,

 	size=sizeof(struct dns_hash_entry)+name->len-1+1;

 	e=shm_malloc(size);

 	if (e==0){

-		LM_ERR("out of memory\n");

+		SHM_MEM_ERROR;

 		return 0;

 	}

 	memset(e, 0, size); /* init with 0*/

@@ -798,7 +803,7 @@ inline static struct dns_hash_entry* dns_cache_mk_ip_entry(str* name,

 			sizeof(struct dns_rr)+ ip->len;

 	e=shm_malloc(size);

 	if (e==0){

-		LM_ERR("out of memory\n");

+		SHM_MEM_ERROR;

 		return 0;

 	}

 	memset(e, 0, size); /* init with 0*/

@@ -851,7 +856,7 @@ static struct dns_hash_entry* dns_cache_mk_srv_entry(str* name,

 	e=shm_malloc(size);

 	if (e==0){

-		LM_ERR("out of memory\n");

+		SHM_MEM_ERROR;

 		return 0;

 	}

 	memset(e, 0, size); /* init with 0*/

@@ -1104,7 +1109,7 @@ inline static struct dns_hash_entry* dns_cache_mk_rd_entry(str* name, int type,

 	size+=ROUND_POINTER(sizeof(struct dns_hash_entry)+name->len-1+1);

 	e=shm_malloc(size);

 	if (e==0){

-		LM_ERR("out of memory\n");

+		SHM_MEM_ERROR;

 		return 0;

 	}

 	memset(e, 0, size); /* init with 0 */

@@ -1411,7 +1416,7 @@ found:

 	for (r=0; r<no_records; r++){

 		rec[r].e=shm_malloc(rec[r].size);

 		if (rec[r].e==0){

-			LM_ERR("out of memory\n");

+			SHM_MEM_ERROR;

 			goto error;

 		}

 		memset(rec[r].e, 0, rec[r].size); /* init with 0*/

@@ -3988,7 +3993,7 @@ static struct dns_hash_entry *dns_cache_clone_entry(struct dns_hash_entry *e,