Contributed Logic: opensips/modules/lcr/lcr_mod.c@8ec65b8f6e2c (annotated)

opensips/modules/lcr/lcr_mod.c@8ec65b8f6e2c (annotated)

opensips/modules/lcr/lcr_mod.c

Wed, 10 Feb 2010 21:25:01 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 10 Feb 2010 21:25:01 +0100
changeset 18: 8ec65b8f6e2c
parent 16: c5c55937e44c
permissions: -rw-r--r--

Extend uac_auth() of the UAC module to workaround CSEQ problems.
This logic is meant to complement that of changeset 17, which
added rich authentication credentials to the gw table and its
associated logic in the LCR module.

 /*
  * $Id: lcr_mod.c 6015 2009-08-22 21:45:06Z bogdan_iancu $
  *
  * Least Cost Routing module (also implements sequential forking)
  *
  * Copyright (C) 2005 Juha Heinanen
  * Copyright (C) 2006 Voice Sistem SRL
  *
  * This file is part of opensips, a free SIP server.
  *
  * opensips is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version
  *
  * opensips is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
  * History:
  * -------
  *  2005-02-14: Introduced lcr module (jh)
  *  2005-02-20: Added sequential forking functions (jh)
  *  2005-02-25: Added support for int AVP names, combined addr and port
  *              AVPs (jh)
  *  2005-07-28: Added support for gw URI scheme and transport,
  *              backport from ser (kd)
  *  2005-08-20: Added support for gw prefixes (jh)
  *  2005-09-03: Request-URI user part can be modified between load_gws()
  *              and first next_gw() calls.
  */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <regex.h>
 #include "../../sr_module.h"
 #include "../../dprint.h"
 #include "../../ut.h"
 #include "../../error.h"
 #include "../../mem/mem.h"
 #include "../../mem/shm_mem.h"
 #include "../../db/db.h"
 #include "../../usr_avp.h"
 #include "../../parser/parse_uri.h"
 #include "../../parser/parse_from.h"
 #include "../../parser/msg_parser.h"
 #include "../../action.h"
 #include "../../qvalue.h"
 #include "../../dset.h"
 #include "../../ip_addr.h"
 #include "../../resolve.h"
 #include "../../mi/mi.h"
 #include "../../mod_fix.h"
 #include "../../socket_info.h"
 #include "../../pvar.h"
 #include "../../mod_fix.h"
 #include "mi.h"
 /*
  * Version of gw and lcr tables required by the module,
  * increment this value if you change the table in
  * an backwards incompatible way
  */
 #define GW_TABLE_VERSION 8
 #define LCR_TABLE_VERSION 3
 /* usr_avp flag for sequential forking */
 #define Q_FLAG      (1<<2)
 static void destroy(void);       /* Module destroy function */
 static int mi_child_init(void);
 static int mod_init(void);       /* Module initialization function */
 static int fixstringloadgws(void **param, int param_count);
 int reload_gws ( void );
 #define GW_TABLE "gw"
 #define GW_NAME_COL "gw_name"
 #define GRP_ID_COL "grp_id"
 #define IP_ADDR_COL "ip_addr"
 #define PORT_COL "port"
 #define URI_SCHEME_COL "uri_scheme"
 #define TRANSPORT_COL "transport"
 #define STRIP_COL "strip"
 #define TAG_COL "tag"
 #define FLAGS_COL "flags"
 #define LCR_TABLE "lcr"
 #define PREFIX_COL "prefix"
 #define FROM_URI_COL "from_uri"
 #define PRIORITY_COL "priority"
 #define USER_COL "user"
 #define REALM_COL "realm"
 #define PASSWD_COL "passwd"
 #define MAX_NO_OF_GWS 32
 #define MAX_NO_OF_LCRS 256
 #define MAX_PREFIX_LEN 256
 #define MAX_USER_LEN 64
 #define MAX_REALM_LEN 64
 #define MAX_PASSWD_LEN 64
 #define MAX_TAG_LEN 16
 #define MAX_FROM_URI_LEN 256
 /* Default module parameter values */
 #define DEF_FR_INV_TIMER 90
 #define DEF_FR_INV_TIMER_NEXT 30
 #define DEF_PREFIX_MODE 0
 /*
  * Type definitions
  */
 typedef enum sip_protos uri_transport;
 struct gw_info {
     unsigned int ip_addr;
     unsigned int port;
     unsigned int grp_id;
     uri_type scheme;
     uri_transport transport;
     unsigned int strip;
     char tag[MAX_TAG_LEN + 1];
     unsigned short tag_len;
     unsigned int flags;
     char user[MAX_USER_LEN];
     unsigned short user_len;
     char realm[MAX_REALM_LEN];
     unsigned short realm_len;
     char passwd[MAX_PASSWD_LEN];
     unsigned short passwd_len;
 };
 struct lcr_info {
     char prefix[MAX_PREFIX_LEN + 1];
     unsigned short prefix_len;
     char from_uri[MAX_FROM_URI_LEN + 1];
     unsigned short from_uri_len;
     unsigned int grp_id;
     unsigned short priority;
     unsigned short end_record;
 };
 struct prefix_regex {
 	regex_t re;
 	short int valid;
 };
 struct from_uri_regex {
     regex_t re;
     short int valid;
 };
 struct mi {
     int gw_index;
     int route_index;
     int randomizer;
 };
 /*
  * Database variables
  */
 static db_con_t* db_handle = 0;   /* Database connection handle */
 static db_func_t lcr_dbf;
 /*
  * Module parameter variables
  */
 /* database */
 static str db_url           = str_init(DEFAULT_RODB_URL);
 static str gw_table         = str_init(GW_TABLE);
 static str gw_name_col      = str_init(GW_NAME_COL);
 static str grp_id_col       = str_init(GRP_ID_COL);
 static str ip_addr_col      = str_init(IP_ADDR_COL);
 static str port_col         = str_init(PORT_COL);
 static str uri_scheme_col   = str_init(URI_SCHEME_COL);
 static str transport_col    = str_init(TRANSPORT_COL);
 static str strip_col        = str_init(STRIP_COL);
 static str tag_col          = str_init(TAG_COL);
 static str flags_col        = str_init(FLAGS_COL);
 static str lcr_table        = str_init(LCR_TABLE);
 static str prefix_col       = str_init(PREFIX_COL);
 static str from_uri_col     = str_init(FROM_URI_COL);
 static str priority_col     = str_init(PRIORITY_COL);
 static str user_col         = str_init(USER_COL);
 static str realm_col        = str_init(REALM_COL);
 static str passwd_col       = str_init(PASSWD_COL);
 /* timer */
 int fr_inv_timer      = DEF_FR_INV_TIMER;
 int fr_inv_timer_next = DEF_FR_INV_TIMER_NEXT;
 /* avps */
 static char *fr_inv_timer_avp_param = NULL;
 static char *gw_uri_avp_param = NULL;
 static char *ruri_user_avp_param = NULL;
 static char *contact_avp_param = NULL;
 static char *rpid_avp_param = NULL;
 static char *flags_avp_param = NULL;
 static char *user_avp_param = NULL;
 static char *realm_avp_param = NULL;
 static char *passwd_avp_param = NULL;
 /* prefix mode */
 int prefix_mode_param = DEF_PREFIX_MODE;
 /*
  * Other module types and variables
  */
 struct contact {
     str uri;
     qvalue_t q;
     str dst_uri;
     str path;
     unsigned int flags;
     struct socket_info* sock;
     unsigned short q_flag;
     struct contact *next;
 };
 static int     fr_inv_timer_avp_type;
 static int_str fr_inv_timer_avp;
 static int     gw_uri_avp_type;
 static int_str gw_uri_avp;
 static int     ruri_user_avp_type;
 static int_str ruri_user_avp;
 static int     contact_avp_type;
 static int_str contact_avp;
 static int     rpid_avp_type;
 static int_str rpid_avp;
 static int     flags_avp_type;
 static int_str flags_avp;
 static int     user_avp_type;
 static int_str user_avp;
 static int     realm_avp_type;
 static int_str realm_avp;
 static int     passwd_avp_type;
 static int_str passwd_avp;
 struct gw_info **gws;	/* Pointer to current gw table pointer */
 struct gw_info *gws_1;	/* Pointer to gw table 1 */
 struct gw_info *gws_2;	/* Pointer to gw table 2 */
 struct lcr_info **lcrs;  /* Pointer to current lcr table pointer */
 struct lcr_info *lcrs_1; /* Pointer to lcr table 1 */
 struct lcr_info *lcrs_2; /* Pointer to lcr table 2 */
 unsigned int *lcrs_ws_reload_counter;
 unsigned int reload_counter;
 struct prefix_regex prefix_reg[MAX_NO_OF_LCRS];
 struct from_uri_regex from_uri_reg[MAX_NO_OF_LCRS];
 /*
  * Module functions that are defined later
  */
 static int load_gws_0(struct sip_msg* _m, char* _s1, char* _s2);
 static int load_gws_1(struct sip_msg* _m, char* _s1, char* _s2);
 static int load_gws_from_grp(struct sip_msg* _m, char* _s1, char* _s2);
 static int next_gw(struct sip_msg* _m, char* _s1, char* _s2);
 static int from_gw_0(struct sip_msg* _m, char* _s1, char* _s2);
 static int from_gw_1(struct sip_msg* _m, char* _s1, char* _s2);
 static int from_gw_grp(struct sip_msg* _m, char* _s1, char* _s2);
 static int to_gw(struct sip_msg* _m, char* _s1, char* _s2);
 static int to_gw_grp(struct sip_msg* _m, char* _s1, char* _s2);
 static int load_contacts (struct sip_msg*, char*, char*);
 static int next_contacts (struct sip_msg*, char*, char*);
 /*
  * Exported functions
  */
 static cmd_export_t cmds[] = {
 	{"load_gws", (cmd_function)load_gws_0, 0, 0, 0, REQUEST_ROUTE},
 	{"load_gws", (cmd_function)load_gws_1, 1, fixup_pvar_null,
 		fixup_free_pvar_null, REQUEST_ROUTE},
 	{"load_gws_from_grp", (cmd_function)load_gws_from_grp, 1,
 	 fixstringloadgws, 0, REQUEST_ROUTE},
 	{"next_gw", (cmd_function)next_gw, 0, 0, 0,
 	 REQUEST_ROUTE | FAILURE_ROUTE},
 	{"from_gw", (cmd_function)from_gw_0, 0, 0, 0,
 	 REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE},
 	{"from_gw", (cmd_function)from_gw_1, 1, fixup_pvar_null,
 	 fixup_free_pvar_null, REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE},
 	{"from_gw_grp", (cmd_function)from_gw_grp, 1, fixup_uint_null, 0,
 	 REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE},
 	{"to_gw", (cmd_function)to_gw, 0, 0, 0,
 	 REQUEST_ROUTE | FAILURE_ROUTE},
 	{"to_gw", (cmd_function)to_gw_grp, 1, fixup_uint_null, 0,
 	 REQUEST_ROUTE | FAILURE_ROUTE},
 	{"load_contacts", (cmd_function)load_contacts, 0, 0, 0,
 	 REQUEST_ROUTE},
 	{"next_contacts", (cmd_function)next_contacts, 0, 0, 0,
 	 REQUEST_ROUTE | FAILURE_ROUTE},
 	{0, 0, 0, 0, 0, 0}
 };
 /*
  * Exported parameters
  */
 static param_export_t params[] = {
 	{"db_url",                   STR_PARAM, &db_url.s       },
 	{"gw_table",                 STR_PARAM, &gw_table.s     },
 	{"gw_name_column",           STR_PARAM, &gw_name_col.s  },
 	{"grp_id_column",            STR_PARAM, &grp_id_col.s   },
 	{"ip_addr_column",           STR_PARAM, &ip_addr_col.s  },
 	{"port_column",              STR_PARAM, &port_col.s     },
 	{"uri_scheme_column",        STR_PARAM, &uri_scheme_col.s },
 	{"transport_column",         STR_PARAM, &transport_col.s },
 	{"strip_column",             STR_PARAM, &strip_col.s    },
 	{"tag_column",               STR_PARAM, &tag_col.s      },
 	{"flags_column",             STR_PARAM, &flags_col.s    },
 	{"lcr_table",                STR_PARAM, &lcr_table.s    },
 	{"prefix_column",            STR_PARAM, &prefix_col.s   },
 	{"from_uri_column",          STR_PARAM, &from_uri_col.s },
 	{"priority_column",          STR_PARAM, &priority_col.s },
 	{"fr_inv_timer_avp",         STR_PARAM,	&fr_inv_timer_avp_param },
 	{"gw_uri_avp",               STR_PARAM, &gw_uri_avp_param },
 	{"ruri_user_avp",            STR_PARAM, &ruri_user_avp_param },
 	{"contact_avp",              STR_PARAM, &contact_avp_param },
 	{"rpid_avp",                 STR_PARAM, &rpid_avp_param },
 	{"flags_avp",                STR_PARAM, &flags_avp_param },
 	{"fr_inv_timer",             INT_PARAM, &fr_inv_timer },
 	{"fr_inv_timer_next",        INT_PARAM,	&fr_inv_timer_next },
 	{"prefix_mode",              INT_PARAM, &prefix_mode_param },
 	{"user_column",              STR_PARAM, &user_col.s },
 	{"realm_column",             STR_PARAM, &realm_col.s },
 	{"passwd_column",            STR_PARAM, &passwd_col.s },
 	{"auth_username_avp",        STR_PARAM, &user_avp_param },
 	{"auth_realm_avp",           STR_PARAM, &realm_avp_param },
 	{"auth_password_avp",        STR_PARAM, &passwd_avp_param },
 	{0, 0, 0}
 };
 /*
  * Exported MI functions
  */
 static mi_export_t mi_cmds[] = {
 	{ MI_LCR_RELOAD,  mi_lcr_reload,   MI_NO_INPUT_FLAG,  0,  mi_child_init },
 	{ MI_LCR_DUMP,    mi_lcr_dump,     MI_NO_INPUT_FLAG,  0,  0 },
 	{ 0, 0, 0, 0 ,0}
 };
 /*
  * Module interface
  */
 struct module_exports exports = {
 	"lcr",
 	MODULE_VERSION,
 	DEFAULT_DLFLAGS, /* dlopen flags */
 	cmds,      /* Exported functions */
 	params,    /* Exported parameters */
 ,         /* exported statistics */
 	mi_cmds,   /* exported MI functions */
 ,         /* exported pseudo-variables */
 ,         /* extra processes */
 	mod_init,  /* module initialization function */
 ,         /* response function */
 	destroy,   /* destroy function */
 /* child initialization function */
 };
 static int lcr_db_init(const str* db_url)
 {
 	if (lcr_dbf.init==0){
 		LM_CRIT("Null lcr_dbf\n");
 		goto error;
 	}
 	db_handle=lcr_dbf.init(db_url);
 	if (db_handle==0){
 		LM_ERR("Unable to connect to the database\n");
 		goto error;
 	}
 	return 0;
 error:
 	return -1;
 }
 static int lcr_db_bind(const str* db_url)
 {
     if (db_bind_mod(db_url, &lcr_dbf)<0){
 	LM_ERR("Unable to bind to the database module\n");
 	return -1;
     }
     if (!DB_CAPABILITY(lcr_dbf, DB_CAP_QUERY)) {
 	LM_ERR("Database module does not implement 'query' function\n");
 	return -1;
     }
     return 0;
 }
 static void lcr_db_close(void)
 {
 	if (db_handle && lcr_dbf.close){
 		lcr_dbf.close(db_handle);
 		db_handle=0;
 	}
 }
 static int mi_child_init(void)
 {
 	return lcr_db_init(&db_url);
 }
 /*
  * Module initialization function that is called before the main process forks
  */
 static int mod_init(void)
 {
 	int i;
     pv_spec_t avp_spec;
     str s;
     unsigned short avp_flags;
     LM_DBG("Initializing\n");
     /* Update length of module variables */
     db_url.len = strlen(db_url.s);
     gw_table.len = strlen(gw_table.s);
     gw_name_col.len = strlen(gw_name_col.s);
     grp_id_col.len = strlen(grp_id_col.s);
     ip_addr_col.len = strlen(ip_addr_col.s);
     port_col.len = strlen(port_col.s);
     uri_scheme_col.len = strlen(uri_scheme_col.s);
     transport_col.len = strlen(transport_col.s);
     strip_col.len = strlen(strip_col.s);
     tag_col.len = strlen(tag_col.s);
     flags_col.len = strlen(flags_col.s);
     lcr_table.len = strlen(lcr_table.s);
     prefix_col.len = strlen(prefix_col.s);
     from_uri_col.len = strlen(from_uri_col.s);
     priority_col.len = strlen(priority_col.s);
     user_col.len = strlen(user_col.s);
     realm_col.len = strlen(realm_col.s);
     passwd_col.len = strlen(passwd_col.s);
     /* Bind database */
     if (lcr_db_bind(&db_url)) {
 	LM_ERR("No database module found\n");
 	return -1;
     }
     /* Check value of prefix_mode */
     if ((prefix_mode_param != 0) && (prefix_mode_param != 1)) {
 	LM_ERR("Invalid prefix_mode value <%d>\n", prefix_mode_param);
 	return -1;
     }
     /* Process AVP params */
     if (fr_inv_timer_avp_param && *fr_inv_timer_avp_param) {
 	s.s = fr_inv_timer_avp_param; s.len = strlen(s.s);
 	if (pv_parse_spec(&s, &avp_spec)==0
 	    || avp_spec.type!=PVT_AVP) {
 	    LM_ERR("Malformed or non AVP definition <%s>\n",
 		   fr_inv_timer_avp_param);
 	    return -1;
 	}
 	if(pv_get_avp_name(0, &(avp_spec.pvp), &fr_inv_timer_avp, &avp_flags)!=0) {
 	    LM_ERR("Invalid AVP definition <%s>\n", fr_inv_timer_avp_param);
 	    return -1;
 	}
 	fr_inv_timer_avp_type = avp_flags;
     } else {
 	LM_ERR("AVP fr_inv_timer_avp has not been defined\n");
 	return -1;
     }
     if (gw_uri_avp_param && *gw_uri_avp_param) {
 	s.s = gw_uri_avp_param; s.len = strlen(s.s);
 	if (pv_parse_spec(&s, &avp_spec)==0
 	    || avp_spec.type!=PVT_AVP) {
 	    LM_ERR("Malformed or non AVP definition <%s>\n", gw_uri_avp_param);
 	    return -1;
 	}
 	if(pv_get_avp_name(0, &(avp_spec.pvp), &gw_uri_avp, &avp_flags)!=0) {
 	    LM_ERR("Invalid AVP definition <%s>\n", gw_uri_avp_param);
 	    return -1;
 	}
 	gw_uri_avp_type = avp_flags;
     } else {
 	LM_ERR("AVP gw_uri_avp has not been defined\n");
 	return -1;
     }
     if (ruri_user_avp_param && *ruri_user_avp_param) {
 	s.s = ruri_user_avp_param; s.len = strlen(s.s);
 	if (pv_parse_spec(&s, &avp_spec)==0
 	    || avp_spec.type!=PVT_AVP) {
 	    LM_ERR("Malformed or non AVP definition <%s>\n",
 		   ruri_user_avp_param);
 	    return -1;
 	}
 	if(pv_get_avp_name(0, &(avp_spec.pvp), &ruri_user_avp, &avp_flags)!=0) {
 	    LM_ERR("Invalid AVP definition <%s>\n", ruri_user_avp_param);
 	    return -1;
 	}
 	ruri_user_avp_type = avp_flags;
     } else {
 	LM_ERR("AVP ruri_user_avp has not been defined\n");
 	return -1;
     }
     if (contact_avp_param && *contact_avp_param) {
 	s.s = contact_avp_param; s.len = strlen(s.s);
 	if (pv_parse_spec(&s, &avp_spec)==0
 	    || avp_spec.type!=PVT_AVP) {
 	    LM_ERR("Malformed or non AVP definition <%s>\n",
 		   contact_avp_param);
 	    return -1;
 	}
 	if(pv_get_avp_name(0, &(avp_spec.pvp), &contact_avp, &avp_flags)!=0) {
 	    LM_ERR("Invalid AVP definition <%s>\n", contact_avp_param);
 	    return -1;
 	}
 	contact_avp_type = avp_flags;
     } else {
 	LM_ERR("AVP contact_avp has not been defined\n");
 	return -1;
     }
     if (rpid_avp_param && *rpid_avp_param) {
 	s.s = rpid_avp_param; s.len = strlen(s.s);
 	if (pv_parse_spec(&s, &avp_spec)==0
 	    || avp_spec.type!=PVT_AVP) {
 	    LM_ERR("Malformed or non AVP definition <%s>\n", rpid_avp_param);
 	    return -1;
 	}
 	if(pv_get_avp_name(0, &(avp_spec.pvp), &rpid_avp, &avp_flags)!=0) {
 	    LM_ERR("Invalid AVP definition <%s>\n", rpid_avp_param);
 	    return -1;
 	}
 	rpid_avp_type = avp_flags;
     } else {
 	LM_ERR("AVP rpid_avp has not been defined\n");
 	return -1;
     }
     if (flags_avp_param && *flags_avp_param) {
 	s.s = flags_avp_param; s.len = strlen(s.s);
 	if (pv_parse_spec(&s, &avp_spec)==0
 	    || avp_spec.type!=PVT_AVP) {
 	    LM_ERR("Malformed or non AVP definition <%s>\n", flags_avp_param);
 	    return -1;
 	}
 	if(pv_get_avp_name(0, &(avp_spec.pvp), &flags_avp, &avp_flags)!=0) {
 	    LM_ERR("Invalid AVP definition <%s>\n", flags_avp_param);
 	    return -1;
 	}
 	flags_avp_type = avp_flags;
     } else {
 	LM_ERR("AVP flags_avp has not been defined\n");
 	return -1;
     }
 	if (user_avp_param && *user_avp_param) {
 	s.s = user_avp_param; s.len = strlen(s.s);
 	if (pv_parse_spec(&s, &avp_spec)==0
 	    || avp_spec.type!=PVT_AVP) {
 	    LM_ERR("Malformed or non AVP definition <%s>\n", user_avp_param);
 	    return -1;
 	}
 	if(pv_get_avp_name(0, &(avp_spec.pvp), &user_avp, &avp_flags)!=0) {
 	    LM_ERR("Invalid AVP definition <%s>\n", user_avp_param);
 	    return -1;
 	}
 	user_avp_type = avp_flags;
     } else {
 	LM_ERR("AVP user_avp has not been defined\n");
 	return -1;
     }
 	if (realm_avp_param && *realm_avp_param) {
 	s.s = realm_avp_param; s.len = strlen(s.s);
 	if (pv_parse_spec(&s, &avp_spec)==0
 	    || avp_spec.type!=PVT_AVP) {
 	    LM_ERR("Malformed or non AVP definition <%s>\n", realm_avp_param);
 	    return -1;
 	}
 	if(pv_get_avp_name(0, &(avp_spec.pvp), &realm_avp, &avp_flags)!=0) {
 	    LM_ERR("Invalid AVP definition <%s>\n", realm_avp_param);
 	    return -1;
 	}
 	realm_avp_type = avp_flags;
     } else {
 	LM_ERR("AVP realm_avp has not been defined\n");
 	return -1;
     }
 	if (passwd_avp_param && *passwd_avp_param) {
 	s.s = passwd_avp_param; s.len = strlen(s.s);
 	if (pv_parse_spec(&s, &avp_spec)==0
 	    || avp_spec.type!=PVT_AVP) {
 	    LM_ERR("Malformed or non AVP definition <%s>\n", passwd_avp_param);
 	    return -1;
 	}
 	if(pv_get_avp_name(0, &(avp_spec.pvp), &passwd_avp, &avp_flags)!=0) {
 	    LM_ERR("Invalid AVP definition <%s>\n", passwd_avp_param);
 	    return -1;
 	}
 	passwd_avp_type = avp_flags;
     } else {
 	LM_ERR("AVP passwd_avp has not been defined\n");
 	return -1;
     }
     /* Check table version */
 	db_con_t* dbh;
 	if (lcr_dbf.init==0){
 		LM_CRIT("Unbound database\n");
 		return -1;
 	}
 	dbh=lcr_dbf.init(&db_url);
 	if (dbh==0){
 		LM_ERR("Unable to open database connection\n");
 		return -1;
 	}
 	if((db_check_table_version(&lcr_dbf, dbh, &gw_table, GW_TABLE_VERSION) < 0) ||
 		(db_check_table_version(&lcr_dbf, dbh, &lcr_table, LCR_TABLE_VERSION) < 0)) {
 			LM_ERR("error during table version check.\n");
 			lcr_dbf.close(dbh);
 			goto err;
     }
 	lcr_dbf.close(dbh);
     /* Initializing gw tables and gw table pointer variable */
     gws_1 = (struct gw_info *)shm_malloc(sizeof(struct gw_info) *
 					 (MAX_NO_OF_GWS + 1));
     if (gws_1 == 0) {
 	LM_ERR("No memory for gw table\n");
 	goto err;
     }
     gws_2 = (struct gw_info *)shm_malloc(sizeof(struct gw_info) *
 					 (MAX_NO_OF_GWS + 1));
     if (gws_2 == 0) {
 	LM_ERR("No memory for gw table\n");
 	goto err;
     }
     for (i = 0; i < MAX_NO_OF_GWS + 1; i++) {
 	gws_1[i].ip_addr = gws_2[i].ip_addr = 0;
     }
     gws = (struct gw_info **)shm_malloc(sizeof(struct gw_info *));
     if (gws == 0) {
 	LM_ERR("No memory for gw table pointer\n");
     }
     *gws = gws_1;
     /* Initializing lcr tables and lcr table pointer variable */
     lcrs_1 = (struct lcr_info *)shm_malloc(sizeof(struct lcr_info) *
 					   (MAX_NO_OF_LCRS + 1));
     if (lcrs_1 == 0) {
 	LM_ERR("No memory for lcr table\n");
 	goto err;
     }
     lcrs_2 = (struct lcr_info *)shm_malloc(sizeof(struct lcr_info) *
 					   (MAX_NO_OF_LCRS + 1));
     if (lcrs_2 == 0) {
 	LM_ERR("No memory for lcr table\n");
 	goto err;
     }
     for (i = 0; i < MAX_NO_OF_LCRS + 1; i++) {
 	lcrs_1[i].end_record = lcrs_2[i].end_record = 0;
     }
     lcrs = (struct lcr_info **)shm_malloc(sizeof(struct lcr_info *));
     if (lcrs == 0) {
 	LM_ERR("No memory for lcr table pointer\n");
 	goto err;
     }
     *lcrs = lcrs_1;
     lcrs_ws_reload_counter = (unsigned int *)shm_malloc(sizeof(unsigned int));
     if (lcrs_ws_reload_counter == 0) {
 	LM_ERR("No memory for reload counter\n");
 	goto err;
     }
     *lcrs_ws_reload_counter = reload_counter = 0;
     memset(prefix_reg, 0, sizeof(struct prefix_regex) * MAX_NO_OF_LCRS);
     memset(from_uri_reg, 0, sizeof(struct from_uri_regex) * MAX_NO_OF_LCRS);
     /* First reload */
     if (reload_gws() == -1) {
 	LM_CRIT("Failed to reload gateways and routes\n");
 	goto err;
     }
     return 0;
 err:
     return -1;
 }
 static void destroy(void)
 {
 	lcr_db_close();
 }
 /*
  * Sort lcr records by prefix_len and priority.
  */
 static int comp_lcrs(const void *m1, const void *m2)
 {
     int result = -1;
     struct mi *mi1 = (struct mi *) m1;
     struct mi *mi2 = (struct mi *) m2;
     struct lcr_info lcr_record1 = (*lcrs)[mi1->route_index];
     struct lcr_info lcr_record2 = (*lcrs)[mi2->route_index];
     if (prefix_mode_param == 0) {
         /* Sort by prefix. */
         if (lcr_record1.prefix_len > lcr_record2.prefix_len) {
 	    result = 1;
         } else if (lcr_record1.prefix_len == lcr_record2.prefix_len) {
 	    /* Sort by priority. */
 	    if (lcr_record1.priority < lcr_record2.priority) {
 	        result = 1;
 	    } else if (lcr_record1.priority == lcr_record2.priority) {
 	        /* Nothing to do. */
 	        result = 0;
 	    }
         }
     } else {
         if (lcr_record1.priority < lcr_record2.priority) {
 	    result = 1;
 	} else if (lcr_record1.priority == lcr_record2.priority) {
 	    /* Nothing to do. */
 	    result = 0;
 	}
     }
     return result;
 }
 /*
  * Sort lcr records by rand table.
  */
 static int rand_lcrs(const void *m1, const void *m2)
 {
     int result = -1;
     struct mi mi1 = *((struct mi *) m1);
     struct mi mi2 = *((struct mi *) m2);
     if (mi1.randomizer > mi2.randomizer) {
 	result = 1;
     } else if (mi1.randomizer == mi2.randomizer) {
 	result = 0;
     }
     return result;
 }
 /*
  * regcomp each prefix.
  */
 static int load_prefix_regex(void)
 {
     int i, status, result = 0;
     for (i = 0; i < MAX_NO_OF_LCRS; i++) {
 	if ((*lcrs)[i].end_record != 0) {
 	    break;
 	}
 	if (prefix_reg[i].valid) {
 	    regfree(&(prefix_reg[i].re));
 	    prefix_reg[i].valid = 0;
 	}
 	memset(&(prefix_reg[i].re), 0, sizeof(regex_t));
 	if ((status=regcomp(&(prefix_reg[i].re),(*lcrs)[i].prefix,0))!=0){
 	    LM_ERR("bad prefix re <%s>, regcomp returned %d (check regex.h)\n",
 		(*lcrs)[i].prefix, status);
 	    result = -1;
 	    break;
 	}
 	prefix_reg[i].valid = 1;
     }
     return result;
 }
 /*
  * regcomp each from_uri.
  */
 static int load_from_uri_regex(void)
 {
     int i, status, result = 0;
     for (i = 0; i < MAX_NO_OF_LCRS; i++) {
 	if ((*lcrs)[i].end_record != 0) {
 	    break;
 	}
 	if (from_uri_reg[i].valid) {
 	    regfree(&(from_uri_reg[i].re));
 	    from_uri_reg[i].valid = 0;
 	}
 	memset(&(from_uri_reg[i].re), 0, sizeof(regex_t));
 	if ((status=regcomp(&(from_uri_reg[i].re),(*lcrs)[i].from_uri,0))!=0){
 	    LM_ERR("Bad from_uri re <%s>, regcomp returned %d (check regex.h)\n",
 	    	(*lcrs)[i].from_uri, status);
 	    result = -1;
 	    break;
 	}
 	from_uri_reg[i].valid = 1;
     }
     if (result != -1) {
 	reload_counter = *lcrs_ws_reload_counter;
     }
     return result;
 }
 static int load_all_regex(void)
 {
 	int result =0;
 	if (prefix_mode_param != 0) {
 		result = load_prefix_regex();
 	}
 	if (result == 0) {
 		result = load_from_uri_regex();
 	} else {
 		LM_ERR("Unable to load prefix regex\n");
 	}
 	if (result == 0) {
 		reload_counter = *lcrs_ws_reload_counter;
 	} else {
 		LM_ERR("Unable to load from_uri regex\n");
 	}
 	return result;
 }
 /*
  * Reload gws to unused gw table and lcrs to unused lcr table, and, when done
  * make unused gw and lcr table the one in use.
  */
 int reload_gws(void)
 {
     unsigned int i, port, strip, tag_len, prefix_len, from_uri_len,
     user_len, realm_len, passwd_len, grp_id, priority;
     struct in_addr ip_addr;
     unsigned int flags;
     uri_type scheme;
     uri_transport transport;
     db_con_t* dbh;
     char *tag, *prefix, *from_uri;
     char *user, *realm, *passwd;
     db_res_t* res = NULL;
     db_row_t* row;
     db_key_t gw_cols[11];
     db_key_t lcr_cols[4];
     gw_cols[0] = &ip_addr_col;
     gw_cols[1] = &port_col;
     gw_cols[2] = &uri_scheme_col;
     gw_cols[3] = &transport_col;
     gw_cols[4] = &strip_col;
     gw_cols[5] = &tag_col;
     /* FIXME: is this ok if we have different names for grp_id
        in the two tables? (ge vw lcr) */
     gw_cols[6] = &grp_id_col;
     gw_cols[7] = &flags_col;
     gw_cols[8] = &user_col;
     gw_cols[9] = &realm_col;
     gw_cols[10] = &passwd_col;
     lcr_cols[0] = &prefix_col;
     lcr_cols[1] = &from_uri_col;
     /* FIXME: is this ok if we have different names for grp_id
        in the two tables? (ge vw lcr) */
     lcr_cols[2] = &grp_id_col;
     lcr_cols[3] = &priority_col;
     if (lcr_dbf.init==0){
 	LM_CRIT("Unbound database\n");
 	return -1;
     }
     dbh=lcr_dbf.init(&db_url);
     if (dbh==0){
 	LM_ERR("Unable to open database connection\n");
 	return -1;
     }
     if (lcr_dbf.use_table(dbh, &gw_table) < 0) {
 	LM_ERR("Error while trying to use gw table\n");
 	return -1;
     }
     if (lcr_dbf.query(dbh, NULL, 0, NULL, gw_cols, 0, 11, 0, &res) < 0) {
 	    LM_ERR("Failed to query gw data\n");
 	    lcr_dbf.close(dbh);
 	    return -1;
     }
     if (RES_ROW_N(res) + 1 > MAX_NO_OF_GWS) {
 	    LM_ERR("Too many gateways\n");
 	    lcr_dbf.free_result(dbh, res);
 	    lcr_dbf.close(dbh);
 	    return -1;
     }
     for (i = 0; i < RES_ROW_N(res); i++) {
 	row = RES_ROWS(res) + i;
 	if (!((VAL_TYPE(ROW_VALUES(row)) == DB_STRING) &&
 	      !VAL_NULL(ROW_VALUES(row)) &&
 	      inet_aton((char *)VAL_STRING(ROW_VALUES(row)), &ip_addr) != 0)) {
 	    LM_ERR("Invalid IP address of gw <%s>\n",
 		   (char *)VAL_STRING(ROW_VALUES(row)));
 	    lcr_dbf.free_result(dbh, res);
 	    lcr_dbf.close(dbh);
 	    return -1;
 	}
 	if (VAL_NULL(ROW_VALUES(row) + 1) == 1) {
 	    port = 0;
 	} else {
 	    port = (unsigned int)VAL_INT(ROW_VALUES(row) + 1);
 	}
 	if (port > 65536) {
 	    LM_ERR("Port of gw is too large <%u>\n", port);
 	    lcr_dbf.free_result(dbh, res);
 	    lcr_dbf.close(dbh);
 	    return -1;
 	}
 	if (VAL_NULL(ROW_VALUES(row) + 2) == 1) {
 	    scheme = SIP_URI_T;
 	} else {
 	    scheme = (uri_type)VAL_INT(ROW_VALUES(row) + 2);
 	    if ((scheme != SIP_URI_T) && (scheme != SIPS_URI_T)) {
 		LM_ERR("Unknown or unsupported URI scheme <%u>\n",
 		       (unsigned int)scheme);
 		lcr_dbf.free_result(dbh, res);
 		lcr_dbf.close(dbh);
 		return -1;
 	    }
 	}
 	if (VAL_NULL(ROW_VALUES(row) + 3) == 1) {
 	    transport = PROTO_NONE;
 	} else {
 	    transport = (uri_transport)VAL_INT(ROW_VALUES(row) + 3);
 	    if ((transport != PROTO_UDP) && (transport != PROTO_TCP) &&
 		(transport != PROTO_TLS)) {
 		LM_ERR("Unknown or unsupported transport <%u>\n",
 		       (unsigned int)transport);
 		lcr_dbf.free_result(dbh, res);
 		lcr_dbf.close(dbh);
 		return -1;
 	    }
 	}
 	if (VAL_NULL(ROW_VALUES(row) + 4) == 1) {
 	    strip = 0;
 	} else {
 	    strip = (unsigned int)VAL_INT(ROW_VALUES(row) + 4);
 	}
 	if (VAL_NULL(ROW_VALUES(row) + 5) == 1) {
 	    tag_len = 0;
 	    tag = (char *)0;
 	} else {
 	    tag = (char *)VAL_STRING(ROW_VALUES(row) + 5);
 	    tag_len = strlen(tag);
 	    if (tag_len > MAX_TAG_LEN) {
 		LM_ERR("Too long gw tag <%u>\n", tag_len);
 		lcr_dbf.free_result(dbh, res);
 		lcr_dbf.close(dbh);
 		return -1;
 	    }
 	}
 	if (VAL_NULL(ROW_VALUES(row) + 6) == 1) {
 	    grp_id = 0;
 	} else {
 	    grp_id = VAL_INT(ROW_VALUES(row) + 6);
 	}
 	if (!VAL_NULL(ROW_VALUES(row) + 7) &&
 	    (VAL_TYPE(ROW_VALUES(row) + 7) == DB_INT)) {
 	    flags = (unsigned int)VAL_INT(ROW_VALUES(row) + 7);
 	} else {
 	    LM_ERR("Attribute flags is NULL or non-int\n");
 	    lcr_dbf.free_result(dbh, res);
 	    lcr_dbf.close(dbh);
 	    return -1;
 	}
 	if (VAL_NULL(ROW_VALUES(row) + 8) == 1) {
 	    user_len = 0;
 	    user = (char *)0;
 	} else {
 	    user = (char *)VAL_STRING(ROW_VALUES(row) + 8);
 	    user_len = strlen(user);
 	    if (user_len > MAX_USER_LEN) {
 		LM_ERR("Too long gw user <%u>\n", user_len);
 		lcr_dbf.free_result(dbh, res);
 		lcr_dbf.close(dbh);
 		return -1;
 	    }
 	}
 	if (VAL_NULL(ROW_VALUES(row) + 9) == 1) {
 	    realm_len = 0;
 	    realm = (char *)0;
 	} else {
 	    realm = (char *)VAL_STRING(ROW_VALUES(row) + 9);
 	    realm_len = strlen(realm);
 	    if (realm_len > MAX_REALM_LEN) {
 		LM_ERR("Too long gw realm <%u>\n", realm_len);
 		lcr_dbf.free_result(dbh, res);
 		lcr_dbf.close(dbh);
 		return -1;
 	    }
 	}
 	if (VAL_NULL(ROW_VALUES(row) + 10) == 1) {
 	    passwd_len = 0;
 	    passwd = (char *)0;
 	} else {
 	    passwd = (char *)VAL_STRING(ROW_VALUES(row) + 10);
 	    passwd_len = strlen(passwd);
 	    if (passwd_len > MAX_PASSWD_LEN) {
 		LM_ERR("Too long gw passwd <%u>\n", passwd_len);
 		lcr_dbf.free_result(dbh, res);
 		lcr_dbf.close(dbh);
 		return -1;
 	    }
 	}
 	if (*gws == gws_1) {
 	    gws_2[i].ip_addr = (unsigned int)ip_addr.s_addr;
 	    gws_2[i].port = port;
 	    gws_2[i].grp_id = grp_id;
 	    gws_2[i].scheme = scheme;
 	    gws_2[i].transport = transport;
 	    gws_2[i].flags = flags;
 	    gws_2[i].strip = strip;
 	    gws_2[i].tag_len = tag_len;
 	    if (tag_len)
 		memcpy(&(gws_2[i].tag[0]), tag, tag_len);
 	    gws_2[i].user_len = user_len;
 	    if (user_len)
 	    memcpy(&(gws_2[i].user[0]), user, user_len);
 	    gws_2[i].realm_len = realm_len;
 	    if (realm_len)
 	    memcpy(&(gws_2[i].realm[0]), realm, realm_len);
 	    gws_2[i].passwd_len = passwd_len;
 	    if (passwd_len)
 	    memcpy(&(gws_2[i].passwd[0]), passwd, passwd_len);
 	} else {
 	    gws_1[i].ip_addr = (unsigned int)ip_addr.s_addr;
 	    gws_1[i].port = port;
 	    gws_1[i].grp_id = grp_id;
 	    gws_1[i].scheme = scheme;
 	    gws_1[i].transport = transport;
 	    gws_1[i].flags = flags;
 	    gws_1[i].strip = strip;
 	    gws_1[i].tag_len = tag_len;
 	    if (tag_len)
 		memcpy(&(gws_1[i].tag[0]), tag, tag_len);
 	    gws_1[i].user_len = user_len;
 	    if (user_len)
 	    memcpy(&(gws_1[i].user[0]), user, user_len);
 	    gws_1[i].realm_len = realm_len;
 	    if (realm_len)
 	    memcpy(&(gws_1[i].realm[0]), realm, realm_len);
 	    gws_1[i].passwd_len = passwd_len;
 	    if (passwd_len)
 	    memcpy(&(gws_1[i].passwd[0]), passwd, passwd_len);
 	}
     }
     lcr_dbf.free_result(dbh, res);
     if (*gws == gws_1) {
 	gws_2[i].ip_addr = 0;
 	*gws = gws_2;
     } else {
 	gws_1[i].ip_addr = 0;
 	*gws = gws_1;
     }
     if (lcr_dbf.use_table(dbh, &lcr_table) < 0) {
 	LM_ERR("Error while trying to use lcr table\n");
 	return -1;
     }
     if (lcr_dbf.query(dbh, NULL, 0, NULL, lcr_cols, 0, 4, 0, &res) < 0) {
 	LM_ERR("Failed to query lcr data\n");
 	lcr_dbf.close(dbh);
 	return -1;
     }
     if (RES_ROW_N(res) + 1 > MAX_NO_OF_LCRS) {
 	LM_ERR("Too many lcr entries <%d>\n", RES_ROW_N(res));
 	lcr_dbf.free_result(dbh, res);
 	lcr_dbf.close(dbh);
 	return -1;
     }
     for (i = 0; i < RES_ROW_N(res); i++) {
 	row = RES_ROWS(res) + i;
 	if (VAL_NULL(ROW_VALUES(row)) == 1) {
 	    prefix_len = 0;
 	    prefix = 0;
 	} else {
 	    prefix = (char *)VAL_STRING(ROW_VALUES(row));
 	    prefix_len = strlen(prefix);
 	    if (prefix_len > MAX_PREFIX_LEN) {
 		LM_ERR("Too long lcr prefix <%u>\n", prefix_len);
 		lcr_dbf.free_result(dbh, res);
 		lcr_dbf.close(dbh);
 		return -1;
 	    }
 	}
 	if (VAL_NULL(ROW_VALUES(row) + 1) == 1) {
 	    from_uri_len = 0;
 	    from_uri = 0;
 	} else {
 	    from_uri = (char *)VAL_STRING(ROW_VALUES(row) + 1);
 	    from_uri_len = strlen(from_uri);
 	    if (from_uri_len > MAX_FROM_URI_LEN) {
 		LM_ERR("Too long from_uri <%u>\n", from_uri_len);
 		lcr_dbf.free_result(dbh, res);
 		lcr_dbf.close(dbh);
 		return -1;
 	    }
 	}
 	if (VAL_NULL(ROW_VALUES(row) + 2) == 1) {
 	    LM_ERR("Route grp_id is NULL\n");
 	    lcr_dbf.free_result(dbh, res);
 	    lcr_dbf.close(dbh);
 	    return -1;
 	}
 	grp_id = (unsigned int)VAL_INT(ROW_VALUES(row) + 2);
 	if (VAL_NULL(ROW_VALUES(row) + 3) == 1) {
 	    LM_ERR("Route priority is NULL\n");
 	    lcr_dbf.free_result(dbh, res);
 	    lcr_dbf.close(dbh);
 	    return -1;
 	}
 	priority = (unsigned int)VAL_INT(ROW_VALUES(row) + 3);
 	if (*lcrs == lcrs_1) {
 	    lcrs_2[i].prefix_len = prefix_len;
 	    if (prefix_len)
 		memcpy(&(lcrs_2[i].prefix[0]), prefix, prefix_len);
 	    lcrs_2[i].from_uri_len = from_uri_len;
 	    if (from_uri_len) {
 		memcpy(&(lcrs_2[i].from_uri[0]), from_uri, from_uri_len);
 		lcrs_2[i].from_uri[from_uri_len] = '\0';
 	    }
 	    lcrs_2[i].grp_id = grp_id;
 	    lcrs_2[i].priority = priority;
 	    lcrs_2[i].end_record = 0;
 	} else {
 	    lcrs_1[i].prefix_len = prefix_len;
 	    if (prefix_len)
 		memcpy(&(lcrs_1[i].prefix[0]), prefix, prefix_len);
 	    lcrs_1[i].from_uri_len = from_uri_len;
 	    if (from_uri_len) {
 		memcpy(&(lcrs_1[i].from_uri[0]), from_uri, from_uri_len);
 		lcrs_1[i].from_uri[from_uri_len] = '\0';
 	    }
 	    lcrs_1[i].grp_id = grp_id;
 	    lcrs_1[i].priority = priority;
 	    lcrs_1[i].end_record = 0;
 	}
     }
     lcr_dbf.free_result(dbh, res);
     lcr_dbf.close(dbh);
     if (*lcrs == lcrs_1) {
 	lcrs_2[i].end_record = 1;
 	*lcrs = lcrs_2;
     } else {
 	lcrs_1[i].end_record = 1;
 	*lcrs = lcrs_1;
     }
     (*lcrs_ws_reload_counter)++;
     if (0 != load_all_regex()) {
 	return -1;
     }
     return 1;
 }
 int mi_print_gws(struct mi_node* rpl)
 {
     unsigned int i;
     struct mi_attr* attr;
     uri_transport transport;
     char *transp;
     struct mi_node* node;
     struct ip_addr address;
     char* p;
     int len;
     for (i = 0; i < MAX_NO_OF_GWS; i++) {
 	if ((*gws)[i].ip_addr == 0)
 	    break;
 	node= add_mi_node_child(rpl,0 ,"GW", 2, 0, 0);
 	if(node == NULL)
 	    return -1;
 	p = int2str((unsigned long)(*gws)[i].grp_id, &len );
 	attr = add_mi_attr(node, MI_DUP_VALUE, "GRP_ID", 6, p, len );
 	if(attr == NULL)
 	    return -1;
 	transport = (*gws)[i].transport;
 	if (transport == PROTO_UDP)
 	    transp= ";transport=udp";
 	else  if (transport == PROTO_TCP)
 	    transp= ";transport=tcp";
 	else  if (transport == PROTO_TLS)
 	    transp= ";transport=tls";
 	else
 	    transp= "";
 	address.af = AF_INET;
 	address.len = 4;
 	address.u.addr32[0] = (*gws)[i].ip_addr;
 	attr= addf_mi_attr(node,0 ,"URI", 3,"%s:%s:%d%s",
 			   ((*gws)[i].scheme == SIP_URI_T)?"sip":"sips",
 			   ip_addr2a(&address),
 			   ((*gws)[i].port == 0)?5060:(*gws)[i].port,transp);
 	if(attr == NULL)
 	    return -1;
 	p = int2str((unsigned long)(*gws)[i].strip, &len );
 	attr = add_mi_attr(node, MI_DUP_VALUE, "STRIP", 5, p, len);
 	if(attr == NULL)
 	    return -1;
 	attr = add_mi_attr(node, MI_DUP_VALUE, "TAG", 3,
 			   (*gws)[i].tag, (*gws)[i].tag_len );
 	if(attr == NULL)
 	    return -1;
 	p = int2str((unsigned long)(*gws)[i].flags, &len );
 	attr = add_mi_attr(node, MI_DUP_VALUE, "FLAGS", 5, p, len);
 	if(attr == NULL)
 	    return -1;
 	attr = add_mi_attr(node, MI_DUP_VALUE, "USER", 6,
 			   (*gws)[i].user, (*gws)[i].user_len );
 	if(attr == NULL)
 	    return -1;
 	attr = add_mi_attr(node, MI_DUP_VALUE, "REALM", 6,
 			   (*gws)[i].realm, (*gws)[i].realm_len );
 	if(attr == NULL)
 	    return -1;
 	attr = add_mi_attr(node, MI_DUP_VALUE, "PASSWD", 6,
 			   (*gws)[i].passwd, (*gws)[i].passwd_len );
 	if(attr == NULL)
 	    return -1;
     }
     for (i = 0; i < MAX_NO_OF_LCRS; i++) {
 	if ((*lcrs)[i].end_record != 0)
 	    break;
 	node= add_mi_node_child(rpl, 0, "RULE", 4, 0, 0);
 	attr = add_mi_attr(node, 0, "PREFIX", 6, (*lcrs)[i].prefix,
 			   (*lcrs)[i].prefix_len );
 	if(attr== 0)
 	    return -1;
 	attr = add_mi_attr(node, 0, "FROM_URI", 8, (*lcrs)[i].from_uri,
 			   (*lcrs)[i].from_uri_len );
 	if(attr== 0)
 	    return -1;
 	p = int2str((unsigned long)(*lcrs)[i].grp_id, &len );
 	attr = add_mi_attr(node, MI_DUP_VALUE, "GRP_ID", 6, p, len );
 	if(attr == NULL)
 	    return -1;
 	p = int2str((unsigned long)(*lcrs)[i].priority, &len );
 	attr = add_mi_attr(node, MI_DUP_VALUE, "PRIORITY", 8, p, len );
 	if(attr == NULL)
 	    return -1;
     }
     return 0;
 }
 /*
  * Load info of matching GWs from database to gw_uri AVPs
  */
 static int do_load_gws(struct sip_msg* _m, str *_from_uri, int _grp_id)
 {
     str ruri_user, from_uri, value;
     char from_uri_str[MAX_FROM_URI_LEN + 1];
     char ruri[MAX_URI_SIZE];
     unsigned int i, j, k, index, addr, port, strip, gw_index,
 	duplicated_gw, flags, have_rpid_avp;
     char *user;
     char *realm;
     char *passwd;
     uri_type scheme;
     uri_transport transport;
     struct ip_addr address;
     str addr_str, port_str;
     char *at, *tag, *strip_string, *flags_string;
     struct usr_avp *avp;
     int_str val;
     struct mi matched_gws[MAX_NO_OF_GWS + 1];
     unsigned short tag_len, prefix_len, priority;
     int randomizer_start, randomizer_end, randomizer_flag,
 	strip_len, flags_len;
     struct lcr_info lcr_rec;
 	/* Find Request-URI user */
 	if ((parse_sip_msg_uri(_m) < 0) || (!_m->parsed_uri.user.s)) {
 		LM_ERR("Error while parsing R-URI\n");
 		return -1;
 	}
 	ruri_user = _m->parsed_uri.user;
     if (_from_uri) {
 	/* take caller uri from _from_uri argument */
 	from_uri = *_from_uri;
     } else {
 	/* take caller uri from RPID or From URI */
 	have_rpid_avp = 0;
 	avp = search_first_avp(rpid_avp_type, rpid_avp, &val, 0);
 	if (avp != NULL) {
 	    /* Get URI user from RPID if not empty */
 	    if (avp->flags & AVP_VAL_STR) {
 		if (val.s.s && val.s.len) {
 		    from_uri = val.s;
 		    have_rpid_avp = 1;
 		}
 	    } else {
 		from_uri.s = int2str(val.n, &from_uri.len);
 		have_rpid_avp = 1;
 	    }
 	}
 	if (!have_rpid_avp) {
 	    /* Get URI from From URI */
 	    if ((!_m->from) && (parse_headers(_m, HDR_FROM_F, 0) == -1)) {
 		LM_ERR("Error while parsing headers\n");
 		return -1;
 	    }
 	    if (!_m->from) {
 		LM_ERR("From header field not found\n");
 		return -1;
 	    }
 	    if ((!(_m->from)->parsed) && (parse_from_header(_m) < 0)) {
 		LM_ERR("Error while parsing From header\n");
 		return -1;
 	    }
 	    from_uri = get_from(_m)->uri;
 	}
     }
     if (from_uri.len <= MAX_FROM_URI_LEN) {
 	strncpy(from_uri_str, from_uri.s, from_uri.len);
 	from_uri_str[from_uri.len] = '\0';
     } else {
 	LM_ERR("From URI is too long <%u>\n", from_uri.len);
 	return -1;
     }
     /*
      * Check if the gws and lcrs were reloaded
      */
 	if (reload_counter != *lcrs_ws_reload_counter) {
 		if (load_all_regex() != 0) {
 		    return -1;
 		}
 	}
     /*
      * Let's match the gws:
      *  1. prefix matching
      *  2. from_uri matching
      *  3. _grp_id matching
      *
      * Note: A gateway must be in the list _only_ once.
      */
     gw_index = 0;
     duplicated_gw = 0;
     for (i = 0; i < MAX_NO_OF_LCRS; i++) {
 	lcr_rec = (*lcrs)[i];
 	if (lcr_rec.end_record != 0) {
 	    break;
 	}
 	if ( ((prefix_mode_param == 0) && (lcr_rec.prefix_len <= ruri_user.len) &&
 	      (strncmp(lcr_rec.prefix, ruri_user.s, lcr_rec.prefix_len)==0)) ||
 	     ( (prefix_mode_param != 0) && ( (lcr_rec.prefix_len == 0) ||
 					(prefix_reg[i].valid &&
 					 (regexec(&(prefix_reg[i].re), ruri_user.s, 0,
 						  (regmatch_t *)NULL, 0) == 0)) ) ) ) {
 	    /* 1. Prefix matching is done */
 	    if ((lcr_rec.from_uri_len == 0) ||
 		(from_uri_reg[i].valid &&
 		 (regexec(&(from_uri_reg[i].re), from_uri_str, 0,
 			  (regmatch_t *)NULL, 0) == 0))) {
 		/* 2. from_uri matching is done */
 		for (j = 0; j < MAX_NO_OF_GWS; j++) {
 		    if ((*gws)[j].ip_addr == 0) {
 			break;
 		    }
 		    if (lcr_rec.grp_id == (*gws)[j].grp_id &&
 			(_grp_id < 0 || (*gws)[j].grp_id == _grp_id)) {
 			/* 3. _grp_id matching is done */
 			for (k = 0; k < gw_index; k++) {
 			    if ((*gws)[j].ip_addr ==
 				(*gws)[matched_gws[k].gw_index].ip_addr) {
 				/* Found the same gw in the list  */
 				/* Let's keep the one with higher */
 				/* match on prefix len            */
 				LM_DBG("Duplicate gw for index"
 				       " %d [%d,%d] and current [%d,%d] \n",
 				       k, matched_gws[k].route_index,
 				       matched_gws[k].route_index, i, j);
 				duplicated_gw = 1;
 				if (lcr_rec.prefix_len >
 				    (*lcrs)[matched_gws[k].route_index].prefix_len) {
 				    /* Replace the old entry with the new one */
 				    LM_DBG("Replace [%d,%d]"
 					   " with [%d,%d] on index %d:"
 					   " prefix reason %d>%d\n",
 					   matched_gws[k].route_index,
 					   matched_gws[k].gw_index, i, j, k,
 					   lcr_rec.prefix_len,
 					   (*lcrs)[matched_gws[k].route_index].prefix_len);
 				    matched_gws[k].route_index = i;
 				    matched_gws[k].gw_index = j;
 				    /* Stop searching in the matched_gws list */
 				    break;
 				} else if (lcr_rec.prefix_len ==
 					   (*lcrs)[matched_gws[k].route_index].prefix_len) {
 				    if (lcr_rec.priority >
 					(*lcrs)[matched_gws[k].route_index].priority) {
 					/* Replace the old entry with the new one */
 					LM_DBG("Replace [%d,%d] with"
 					       " [%d,%d] on index %d:"
 					       " priority reason %d>%d\n",
 					       matched_gws[k].route_index,
 					       matched_gws[k].gw_index,
 					       i, j, k, lcr_rec.priority,
 					       (*lcrs)[matched_gws[k].route_index].priority);
 					matched_gws[k].route_index = i;
 					matched_gws[k].gw_index = j;
 					/* Stop searching in the matched_gws list */
 					break;
 				    }
 				}
 			    }
 			}
 			if (duplicated_gw == 0) {
 			    /* This is a new gw */
 			    matched_gws[gw_index].route_index = i;
 			    matched_gws[gw_index].gw_index = j;
 			    LM_DBG("Added matched_gws[%d]=[%d,%d]\n",
 				   gw_index, i, j);
 			    gw_index++;
 			} else {
 			    duplicated_gw = 0;
 			}
 		    }
 		}
 	    }
 	}
     }
     matched_gws[gw_index].route_index = -1;
     matched_gws[gw_index].gw_index = -1;
     /*
      * Sort the gateways based on:
      *  1. prefix len
      *  2. priority
      */
     qsort(matched_gws, gw_index, sizeof(struct mi), comp_lcrs);
 	randomizer_start = 0;
     /* Randomizing the gateways with same prefix_len and same priority */
     randomizer_flag = 0;
     prefix_len = (*lcrs)[matched_gws[0].route_index].prefix_len;
     priority = (*lcrs)[matched_gws[0].route_index].priority;
     for (i = 1; i < gw_index; i++) {
  	if ( prefix_len == (*lcrs)[matched_gws[i].route_index].prefix_len &&
  	     priority == (*lcrs)[matched_gws[i].route_index].priority) {
 	    /* we have a match */
 	    if (randomizer_flag == 0) {
 		randomizer_flag = 1;
 		randomizer_start = i - 1;
 	    }
 	    matched_gws[i - 1].randomizer = rand();
  	}
 	else {
 	    if (randomizer_flag == 1) {
 		randomizer_end = i - 1;
 		randomizer_flag = 0;
 		qsort(&matched_gws[randomizer_start],
 		      randomizer_end - randomizer_start + 1,
 		      sizeof(struct mi), rand_lcrs);
 	    }
 	    prefix_len = (*lcrs)[matched_gws[i].route_index].prefix_len;
 	    priority = (*lcrs)[matched_gws[i].route_index].priority;
 	}
     }
     if (randomizer_flag == 1) {
 	randomizer_end = gw_index - 1;
 	matched_gws[i - 1].randomizer = rand();
 	qsort(&matched_gws[randomizer_start],
 	      randomizer_end - randomizer_start + 1,
 	      sizeof(struct mi), rand_lcrs);
     }
     for (i = 0; i < MAX_NO_OF_GWS; i++) {
 	index = matched_gws[i].gw_index;
 	if (index == -1) {
 	    break;
 	}
       	addr = (*gws)[index].ip_addr;
 	port = (*gws)[index].port;
 	scheme = (*gws)[index].scheme;
 	transport = (*gws)[index].transport;
 	flags = (*gws)[index].flags;
 	strip = (*gws)[index].strip;
 	user = (*gws)[index].user;
 	realm = (*gws)[index].realm;
 	passwd = (*gws)[index].passwd;
 	if (strip > ruri_user.len) {
 	    LM_ERR("Strip count of gw is too large <%u>\n", strip);
 	    goto skip;
 	}
 	tag_len = (*gws)[index].tag_len;
 	tag = (*gws)[index].tag;
 	if (6 + tag_len + 40 /* flags + strip */ + 1 + 15 + 1 + 5 + 1 + 14 >
 	    MAX_URI_SIZE) {
 	    LM_ERR("Request URI would be too long\n");
 	    goto skip;
 	}
 	at = (char *)&(ruri[0]);
 	flags_string = int2str(flags, &flags_len);
 	memcpy(at, flags_string, flags_len);
 	at = at + flags_len;
 	if (scheme == SIP_URI_T) {
 	    memcpy(at, "sip:", 4); at = at + 4;
 	} else if (scheme == SIPS_URI_T) {
 	    memcpy(at, "sips:", 5); at = at + 5;
 	} else {
 	    LM_ERR("Unknown or unsupported URI scheme <%u>\n",
 		   (unsigned int)scheme);
 	    goto skip;
 	}
 	if (tag_len) {
 	    memcpy(at, tag, tag_len); at = at + tag_len;
 	}
 	/* Add strip in this form |number.
 	 * For example: |3 means strip first 3 characters.
          */
 	*at = '|'; at = at + 1;
 	strip_string = int2str(strip, &strip_len);
 	memcpy(at, strip_string, strip_len);
 	at = at + strip_len;
 	*at = '@'; at = at + 1;
 	address.af = AF_INET;
 	address.len = 4;
 	address.u.addr32[0] = addr;
 	addr_str.s = ip_addr2a(&address);
 	addr_str.len = strlen(addr_str.s);
 	memcpy(at, addr_str.s, addr_str.len); at = at + addr_str.len;
 	if (port != 0) {
 	    if (port > 65536) {
 		LM_ERR("Port of GW is too large <%u>\n", port);
 		goto skip;
 	    }
 	    *at = ':'; at = at + 1;
 	    port_str.s = int2str(port, &port_str.len);
 	    memcpy(at, port_str.s, port_str.len); at = at + port_str.len;
 	}
 	if (transport != PROTO_NONE) {
 	    memcpy(at, ";transport=", 11); at = at + 11;
 	    if (transport == PROTO_UDP) {
 		memcpy(at, "udp", 3); at = at + 3;
 	    } else if (transport == PROTO_TCP) {
 		memcpy(at, "tcp", 3); at = at + 3;
 	    } else if (transport == PROTO_TLS) {
 		memcpy(at, "tls", 3); at = at + 3;
 	    } else {
 		LM_ERR("Unknown or unsupported transport <%u>\n",
 		       (unsigned int)transport);
 		goto skip;
 	    }
 	}
 	value.s = (char *)&(ruri[0]);
 	value.len = at - value.s;
 	val.s = value;
 	add_avp(gw_uri_avp_type|AVP_VAL_STR, gw_uri_avp, val);
 	LM_DBG("Added gw_uri_avp <%.*s>\n", value.len, value.s);
 	value.s = user;
 	value.len = strlen(value.s);
 	val.s = value;
 	add_avp(user_avp_type|AVP_VAL_STR, user_avp, val);
 	LM_DBG("Added user_avp <%.*s>\n", value.len, value.s);
 	value.s = realm;
 	value.len = strlen(value.s);
 	val.s = value;
 	add_avp(realm_avp_type|AVP_VAL_STR, realm_avp, val);
 	LM_DBG("Added realm_avp <%.*s>\n", value.len, value.s);
 	value.s = passwd;
 	value.len = strlen(value.s);
 	val.s = value;
 	add_avp(passwd_avp_type|AVP_VAL_STR, passwd_avp, val);
 	LM_DBG("Added passwd_avp <%.*s>\n", value.len, value.s);
     skip:
 	continue;
     }
     return 1;
 }
 /*
  * Load info of matching GWs from database to gw_uri AVPs
  * taking into account the given group id.  Caller URI is taken
  * from request.
  */
 static int load_gws_from_grp(struct sip_msg* _m, char* _s1, char* _s2)
 {
 	str grp_s;
 	unsigned int grp_id;
 	if(((pv_elem_p)_s1)->spec.getf!=NULL)
 	{
 		if(pv_printf_s(_m, (pv_elem_p)_s1, &grp_s)!=0)
 			return -1;
 		if(str2int(&grp_s, &grp_id)!=0)
 			return -1;
 	} else {
 		grp_id = ((pv_elem_p)_s1)->spec.pvp.pvn.u.isname.name.n;
 	}
 	if (grp_id > 0) return do_load_gws(_m, (str *)0, (int)grp_id);
 	else return -1;
 }
 /*
  * Load info of matching GWs from database to gw_uri AVPs.
  * Caller URI is taken from request.
  */
 static int load_gws_0(struct sip_msg* _m, char* _s1, char* _s2)
 {
     return do_load_gws(_m, (str *)0, -1);
 }
 /*
  * Load info of matching GWs from database to gw_uri AVPs.
  * Caller URI is taken from pseudo variable argument.
  */
 static int load_gws_1(struct sip_msg* _m, char* _sp, char* _s2)
 {
     pv_spec_t *sp;
     pv_value_t pv_val;
     sp = (pv_spec_t *)_sp;
     if (sp && (pv_get_spec_value(_m, sp, &pv_val) == 0)) {
 	if (pv_val.flags & PV_VAL_STR) {
 	    if (pv_val.rs.len == 0 || pv_val.rs.s == NULL) {
 		LM_DBG("missing from uri\n");
 		return -1;
 	    }
  	    return do_load_gws(_m, &(pv_val.rs), -1);
 	} else {
 	   LM_DBG("pseudo variable value is not string\n");
 	   return -1;
 	}
     } else {
 	LM_DBG("cannot get pseudo variable value\n");
 	return -1;
     }
 }
 /*
  * Rewrites scheme, host, port, and transport parts of R-URI based on first
  * gw_uri AVP value, which is then destroyed.  Also saves R-URI user to
  * ruri_user AVP for later use in failure route block.
  * If called from failure route block, appends a new branch to request
  * where scheme, host, port, and transport of URI are taken from the first
  * gw_uri AVP value, which is then destroyed.  URI user is taken from
  * ruri_user AVP value saved earlier.
  * Returns 1 upon success and -1 upon failure.
  */
 static int next_gw(struct sip_msg* _m, char* _s1, char* _s2)
 {
     int_str gw_uri_val, ruri_user_val, val;
     int_str user_val, realm_val, passwd_val;
     struct usr_avp *gu_avp, *ru_avp, *usr_avp, *rlm_avp, *pwd_avp;
     int rval;
     str new_ruri;
     char *at, *at_char, *strip_char, *endptr;
     unsigned int strip;
     gu_avp = search_first_avp(gw_uri_avp_type, gw_uri_avp, &gw_uri_val, 0);
     if (!gu_avp) return -1;
     /* Set flags_avp from integer at the beginning of of gw_uri */
     val.n = (int)strtoul(gw_uri_val.s.s, &at, 0);
     add_avp(flags_avp_type, flags_avp, val);
     LM_DBG("Added flags_avp <%u>\n", (unsigned int)val.n);
     gw_uri_val.s.len = gw_uri_val.s.len - (at - gw_uri_val.s.s);
     gw_uri_val.s.s = at;
 	/* Save gateway AVPs for use in script */
 	usr_avp = search_first_avp(user_avp_type, user_avp, &user_val, 0);
 	rlm_avp = search_first_avp(realm_avp_type, realm_avp, &realm_val, 0);
 	pwd_avp = search_first_avp(passwd_avp_type, passwd_avp, &passwd_val, 0);
 	if (!usr_avp) {
 		LM_DBG("User AVP no set\n");
 		return -1;
 	}
 	else {
 		add_avp(user_avp_type|AVP_VAL_STR, user_avp, user_val);
 		LM_DBG("Added user_avp <%.*s>\n", user_val.s.len, user_val.s.s);
 	}
 	if (!rlm_avp) {
 		LM_DBG("Realm AVP no set\n");
 		return -1;
 	}
 	else {
 		add_avp(realm_avp_type|AVP_VAL_STR, realm_avp, realm_val);
 		LM_DBG("Added realm_avp <%.*s>\n", realm_val.s.len, realm_val.s.s);
 	}
 	if (!pwd_avp) {
 		LM_DBG("Passwd AVP no set\n");
 		return -1;
 	}
 	else {
 		add_avp(passwd_avp_type|AVP_VAL_STR, passwd_avp, passwd_val);
 		LM_DBG("Added passwd_avp <%.*s>\n", passwd_val.s.len, passwd_val.s.s);
 	}
 	/* Create new Request-URI taking URI user from ruri_user AVP
 	   and other parts of from gateway URI AVP. */
 	ru_avp = search_first_avp(ruri_user_avp_type, ruri_user_avp,
 		&ruri_user_val, 0);
 	if (!ru_avp) {
 		LM_DBG("ruri_user AVP no yet set -> use RURI\n");
 		/* parse RURI and ger username */
 		if (parse_sip_msg_uri(_m) < 0) {
 			LM_ERR("Parsing of R-URI failed\n");
 			return -1;
 		}
 		ruri_user_val.s = _m->parsed_uri.user;
 		/* Save Request-URI user for use in FAILURE_ROUTE */
 		val.s = _m->parsed_uri.user;
 		add_avp(ruri_user_avp_type|AVP_VAL_STR, ruri_user_avp, val);
 		LM_DBG("Added ruri_user_avp <%.*s>\n", val.s.len, val.s.s);
 	}
 	new_ruri.s = pkg_malloc(gw_uri_val.s.len + ruri_user_val.s.len);
 	if (!new_ruri.s) {
 	    LM_ERR("No memory for new R-URI.\n");
 	    return -1;
 	}
 	at_char = memchr(gw_uri_val.s.s, '@', gw_uri_val.s.len);
 	if (!at_char) {
 	    pkg_free(new_ruri.s);
 	    LM_ERR("No @ in gateway URI <%.*s>\n",
 		   gw_uri_val.s.len, gw_uri_val.s.s);
 	    return -1;
 	}
 	strip_char = memchr(gw_uri_val.s.s, '|', gw_uri_val.s.len);
 	if (!strip_char || strip_char + 1 >= at_char) {
 	    pkg_free(new_ruri.s);
 	    LM_ERR("No strip char | and at least one "
 		   "char before @ in gateway URI <%.*s>\n",
 		   gw_uri_val.s.len, gw_uri_val.s.s);
 	    return -1;
 	}
 	at = new_ruri.s;
 	memcpy(at, gw_uri_val.s.s, strip_char - gw_uri_val.s.s);
 	at = at + (strip_char - gw_uri_val.s.s);
 	strip = strtol(strip_char + 1, &endptr, 10);
 	if (endptr != at_char) {
 	    pkg_free(new_ruri.s);
 	    LM_ERR("Non-digit char between | and @ chars in gw URI <%.*s>\n",
 		   gw_uri_val.s.len, gw_uri_val.s.s);
 	    return -1;
 	}
 	if (ruri_user_val.s.len - strip > 0) {
 	    memcpy(at, ruri_user_val.s.s + strip,
 		   ruri_user_val.s.len - strip);
 	    at = at + ruri_user_val.s.len - strip;
 	}
 	if (*(at - 1) != ':') {
 	    memcpy(at, at_char, gw_uri_val.s.len - (at_char - gw_uri_val.s.s));
 	    at = at + gw_uri_val.s.len - (at_char - gw_uri_val.s.s);
 	} else {
 	    memcpy(at, at_char + 1, gw_uri_val.s.len -
 		   (at_char + 1 - gw_uri_val.s.s));
 	    at = at + gw_uri_val.s.len - (at_char + 1 - gw_uri_val.s.s);
 	}
 	new_ruri.len = at - new_ruri.s;
 	/* set new RURI */
 	rval = set_ruri( _m, &new_ruri);
 	pkg_free(new_ruri.s);
 	destroy_avp(gu_avp);
 	if (rval!=0) {
 		LM_ERR("failed to set new RURI\n");
 		return -1;
 	}
 	return 1;
 }
 /*
  * Checks if request comes from a gateway
  */
 static int do_from_gw(struct sip_msg* _m, pv_spec_t *addr_sp, int grp_id)
 {
     int i;
     unsigned int src_addr;
     pv_value_t pv_val;
     struct ip_addr *ip;
     int_str val;
 	if (addr_sp && (pv_get_spec_value(_m, addr_sp, &pv_val) == 0)) {
 		if (pv_val.flags & PV_VAL_INT) {
 			src_addr = pv_val.ri;
 		} else if (pv_val.flags & PV_VAL_STR) {
 			if ( (ip=str2ip( &pv_val.rs)) == NULL) {
 				LM_ERR("failed to convert IP address string to in_addr\n");
 				return -1;
 			} else {
 				src_addr = ip->u.addr32[0];
 			}
 		} else {
 			LM_ERR("IP address PV empty value\n");
 			return -1;
 		}
 	} else {
 		src_addr = _m->rcv.src_ip.u.addr32[0];
 	}
     for (i = 0; i < MAX_NO_OF_GWS; i++) {
 	if ((*gws)[i].ip_addr == 0) {
 	    return -1;
 	}
 	if ((*gws)[i].ip_addr == src_addr &&
 	    (grp_id < 0 || (*gws)[i].grp_id == grp_id)) {
 	    LM_DBG("Request came from gw\n");
 	    val.n = (int)(*gws)[i].flags;
 	    add_avp(flags_avp_type, flags_avp, val);
 	    LM_DBG("Added flags_avp <%u>\n", (unsigned int)val.n);
 	    return 1;
 	}
     }
     LM_DBG("Request did not come from gw\n");
     return -1;
 }
 /*
  * Checks if request comes from a gateway, taking source address from request
  * and taking into account the group id.
  */
 static int from_gw_grp(struct sip_msg* _m, char* _grp_id, char* _s2)
 {
     return do_from_gw(_m, (pv_spec_t *)0, (int)(long)_grp_id);
 }
 /*
  * Checks if request comes from a gateway, taking src_address from request
  * and ignoring group id.
  */
 static int from_gw_0(struct sip_msg* _m, char* _s1, char* _s2)
 {
     return do_from_gw(_m, (pv_spec_t *)0, -1);
 }
 /*
  * Checks if request comes from a gateway, taking source address from pw
  * and ignoring group id.
  */
 static int from_gw_1(struct sip_msg* _m, char* _addr_sp, char* _s2)
 {
     return do_from_gw(_m, (pv_spec_t *)_addr_sp, -1);
 }
 /*
  * Checks if in-dialog request goes to gateway
  */
 static int do_to_gw(struct sip_msg* _m, int grp_id)
 {
     char host[16];
     struct in_addr addr;
     unsigned int i;
     if((_m->parsed_uri_ok == 0) && (parse_sip_msg_uri(_m) < 0)) {
 	LM_ERR("Error while parsing the R-URI\n");
 	return -1;
     }
     if (_m->parsed_uri.host.len > 15) {
 	return -1;
     }
     memcpy(host, _m->parsed_uri.host.s, _m->parsed_uri.host.len);
     host[_m->parsed_uri.host.len] = 0;
     if (!inet_aton(host, &addr)) {
 	return -1;
     }
     for (i = 0; i < MAX_NO_OF_GWS; i++) {
 	if ((*gws)[i].ip_addr == 0) {
 	    return -1;
 	}
 	if ((*gws)[i].ip_addr == addr.s_addr &&
 		(grp_id < 0 || (*gws)[i].grp_id == grp_id)) {
 	    return 1;
 	}
     }
     return -1;
 }
 /*
  * Checks if in-dialog request goes to gateway, taking
  * into account the group id.
  */
 static int to_gw_grp(struct sip_msg* _m, char* _s1, char* _s2)
 {
     int grp_id;
     grp_id = (int)(long)_s1;
     return do_to_gw(_m, grp_id);
 }
 /*
  * Checks if in-dialog request goes to gateway, ignoring
  * the group id.
  */
 static int to_gw(struct sip_msg* _m, char* _s1, char* _s2)
 {
     return do_to_gw(_m, -1);
 }
 /*
  * Frees contact list used by load_contacts function
  */
 static inline void free_contact_list(struct contact *curr) {
     struct contact *prev;
     while (curr) {
 	prev = curr;
 	curr = curr->next;
 	pkg_free(prev);
     }
 }
 /* Encode branch info from contact struct to str */
 static inline int encode_branch_info(str *info, struct contact *con)
 {
     char *at, *s;
     int len;
     info->len = con->uri.len + con->dst_uri.len +
 	con->path.len + MAX_SOCKET_STR + INT2STR_MAX_LEN + 5;
     info->s = pkg_malloc(info->len);
     if (!info->s) {
 	LM_ERR("No memory left for branch info\n");
 	return 0;
     }
     at = info->s;
     memcpy(at, con->uri.s, con->uri.len);
     at = at + con->uri.len;
     *at = '\n';
     at++;
     memcpy(at, con->dst_uri.s, con->dst_uri.len);
     at = at + con->dst_uri.len;
     *at = '\n';
     at++;
     memcpy(at, con->path.s, con->path.len);
     at = at + con->path.len;
     *at = '\n';
     at++;
     if (con->sock) {
 	len = MAX_SOCKET_STR;
 	if (!socket2str(con->sock, at, &len, 1)) {
 	    LM_ERR("Failed to convert socket to str\n");
 	    return 0;
 	}
     } else {
 	len = 0;
     }
     at = at + len;
     *at = '\n';
     at++;
     s = int2str(con->flags, &len);
     memcpy(at, s, len);
     at = at + len;
     *at = '\n';
     info->len = at - info->s + 1;
     return 1;
 }
 /* Encode branch info from str */
 static inline int decode_branch_info(char *info, str *uri, str *dst, str *path,
 			      struct socket_info **sock, unsigned int *flags)
 {
     str s, host;
     int port, proto;
     char *pos, *at;
     pos = strchr(info, '\n');
     uri->len = pos - info;
     if (uri->len) {
 	uri->s = info;
     } else {
 	uri->s = 0;
     }
     at = pos + 1;
     pos = strchr(at, '\n');
     dst->len = pos - at;
     if (dst->len) {
 	dst->s = at;
     } else {
 	dst->s = 0;
     }
     at = pos + 1;
     pos = strchr(at, '\n');
     path->len = pos - at;
     if (path->len) {
 	path->s = at;
     } else {
 	path->s = 0;
     }
     at = pos + 1;
     pos = strchr(at, '\n');
     s.len = pos - at;
     if (s.len) {
 	s.s = at;
 	if (parse_phostport(s.s, s.len, &host.s, &host.len,
 			    &port, &proto) != 0) {
 	    LM_ERR("Parsing of socket info <%.*s> failed\n",  s.len, s.s);
 	    return 0;
 	}
 	*sock = grep_sock_info(&host, (unsigned short)port,
 			       (unsigned short)proto);
 	if (*sock == 0) {
 	    LM_ERR("Invalid socket <%.*s>\n", s.len, s.s);
 	    return 0;
 	}
     } else {
 	*sock = 0;
     }
     at = pos + 1;
     pos = strchr(at, '\n');
     s.len = pos - at;
     if (s.len) {
 	s.s = at;
 	if (str2int(&s, flags) != 0) {
 	    LM_ERR("Failed to decode flags <%.*s>\n", s.len, s.s);
 	    return 0;
 	}
     } else {
 	*flags = 0;
     }
     return 1;
 }
 /*
  * Loads contacts in destination set into "lcr_contact" AVP in reverse
  * priority order and associated each contact with Q_FLAG telling if
  * contact is the last one in its priority class.  Finally, removes
  * all branches from destination set.
  */
 static int load_contacts(struct sip_msg* msg, char* key, char* value)
 {
     str uri, dst_uri, path, branch_info, *ruri;
     qvalue_t q, ruri_q;
     struct contact *contacts, *next, *prev, *curr;
     int_str val;
     int idx;
     struct socket_info* sock;
     unsigned int flags;
     /* Check if anything needs to be done */
     if (nr_branches == 0) {
 	LM_DBG("Nothing to do - no branches!\n");
 	return 1;
     }
     ruri = GET_RURI(msg);
     if (!ruri) {
 	LM_ERR("No Request-URI found\n");
 	return -1;
     }
     ruri_q = get_ruri_q();
     for(idx = 0; (uri.s = get_branch(idx, &uri.len, &q, 0, 0, 0, 0)) != 0;
 	idx++) {
 	if (q != ruri_q) {
 	    goto rest;
 	}
     }
     LM_DBG("Nothing to do - all contacts have same q!\n");
     return 1;
 rest:
     /* Insert Request-URI branch to contact list */
     contacts = (struct contact *)pkg_malloc(sizeof(struct contact));
     if (!contacts) {
 	LM_ERR("No memory for contact info\n");
 	return -1;
     }
     contacts->uri.s = ruri->s;
     contacts->uri.len = ruri->len;
     contacts->q = ruri_q;
     contacts->dst_uri = msg->dst_uri;
     contacts->sock = msg->force_send_socket;
     contacts->flags = getb0flags();
     contacts->path = msg->path_vec;
     contacts->next = (struct contact *)0;
     /* Insert branches to contact list in increasing q order */
     for(idx = 0;
 	(uri.s = get_branch(idx,&uri.len,&q,&dst_uri,&path,&flags,&sock))
 	    != 0;
 	idx++ ) {
 	next = (struct contact *)pkg_malloc(sizeof(struct contact));
 	if (!next) {
 	    LM_ERR("No memory for contact info\n");
 	    free_contact_list(contacts);
 	    return -1;
 	}
 	next->uri = uri;
 	next->q = q;
 	next->dst_uri = dst_uri;
 	next->path = path;
 	next->flags = flags;
 	next->sock = sock;
 	next->next = (struct contact *)0;
 	prev = (struct contact *)0;
 	curr = contacts;
 	while (curr && (curr->q < q)) {
 	    prev = curr;
 	    curr = curr->next;
 	}
 	if (!curr) {
 	    next->next = (struct contact *)0;
 	    prev->next = next;
 	} else {
 	    next->next = curr;
 	    if (prev) {
 		prev->next = next;
 	    } else {
 		contacts = next;
 	    }
 	}
     }
     /* Assign values for q_flags */
     curr = contacts;
     curr->q_flag = 0;
     while (curr->next) {
 	if (curr->q < curr->next->q) {
 	    curr->next->q_flag = Q_FLAG;
 	} else {
 	    curr->next->q_flag = 0;
 	}
 	curr = curr->next;
     }
     /* Add contacts to "contacts" AVP */
     curr = contacts;
     while (curr) {
 	if (encode_branch_info(&branch_info, curr) == 0) {
 	    LM_ERR("Encoding of branch info failed\n");
 	    free_contact_list(contacts);
 	    if (branch_info.s) pkg_free(branch_info.s);
 	    return -1;
 	}
 	val.s = branch_info;
 	add_avp(contact_avp_type|AVP_VAL_STR|(curr->q_flag),
 		contact_avp, val);
 	pkg_free(branch_info.s);
 	LM_DBG("Loaded contact <%.*s> with q_flag <%d>\n",
 	       val.s.len, val.s.s, curr->q_flag);
 	curr = curr->next;
     }
     /* Clear all branches */
     clear_branches();
     /* Free contact list */
     free_contact_list(contacts);
     return 1;
 }
 /*
  * Adds to request a destination set that includes all highest priority
  * class contacts in "lcr_contact" AVP.   If called from a route block,
  * rewrites the request uri with first contact and adds the remaining
  * contacts as branches.  If called from failure route block, adds all
  * contacts as branches.  Removes added contacts from "lcr_contact" AVP.
  */
 static int next_contacts(struct sip_msg* msg, char* key, char* value)
 {
     struct usr_avp *avp, *prev;
     int_str val;
     str uri, dst, path;
     struct socket_info *sock;
     unsigned int flags;
 	/* Find first lcr_contact_avp value */
 	avp = search_first_avp(contact_avp_type, contact_avp, &val, 0);
 	if (!avp) {
 	    LM_DBG("No AVPs -- we are done!\n");
 	    return -1;
 	}
 	LM_DBG("Next contact is <%s>\n", val.s.s);
 	if (decode_branch_info(val.s.s, &uri, &dst, &path, &sock, &flags)== 0) {
 	    LM_ERR("Decoding of branch info <%.*s> failed\n",
 		   val.s.len, val.s.s);
 	    destroy_avp(avp);
 	    return -1;
 	}
 	set_ruri(msg, &uri);
 	set_dst_uri(msg, &dst);
 	set_path_vector(msg, &path);
 	msg->force_send_socket = sock;
 	setb0flags(flags);
 	if (avp->flags & Q_FLAG) {
 		destroy_avp(avp);
 		if (route_type == REQUEST_ROUTE) {
 			/* Set fr_inv_timer */
 			val.n = fr_inv_timer_next;
 			if (add_avp(fr_inv_timer_avp_type, fr_inv_timer_avp, val) != 0) {
 				LM_ERR("Setting of fr_inv_timer_avp failed\n");
 				return -1;
 			}
 		}
 		return 1;
 	}
 	/* Append branches until out of branches or Q_FLAG is set */
 	prev = avp;
 	while ((avp = search_next_avp(avp, &val))) {
 		destroy_avp(prev);
 		LM_DBG("Next contact is <%s>\n", val.s.s);
 		if (decode_branch_info(val.s.s, &uri, &dst, &path, &sock, &flags)== 0){
 			LM_ERR("Decoding of branch info <%.*s> failed\n",
 				val.s.len, val.s.s);
 			destroy_avp(avp);
 			return -1;
 		}
 		if (append_branch(msg, &uri, &dst, &path, 0, flags, sock) != 1) {
 			LM_ERR("Appending branch failed\n");
 			destroy_avp(avp);
 			return -1;
 		}
 		if (avp->flags & Q_FLAG) {
 			destroy_avp(avp);
 			if (route_type == REQUEST_ROUTE) {
 				val.n = fr_inv_timer_next;
 				if (add_avp(fr_inv_timer_avp_type, fr_inv_timer_avp, val)!= 0){
 					LM_ERR("Setting of fr_inv_timer_avp failed\n");
 					return -1;
 				}
 			}
 			return 1;
 		}
 		prev = avp;
 	}
 	/* Restore fr_inv_timer */
 	val.n = fr_inv_timer;
 	if (add_avp(fr_inv_timer_avp_type, fr_inv_timer_avp, val) != 0) {
 		LM_ERR("Setting of fr_inv_timer_avp failed\n");
 		return -1;
 	}
 	return 1;
 }
 /*
  * Convert string parameter to integer for functions that expect an integer.
  * Taken from sl module.
  */
 static int fixstringloadgws(void **param, int param_count)
 {
     pv_elem_t *model=NULL;
     str s;
     /* convert to str */
     s.s = (char*)*param;
     s.len = strlen(s.s);
     model=NULL;
     if (param_count==1) {
 	if(s.len==0) {
 	    LM_ERR("No param <%d>!\n", param_count);
 	    return -1;
 	}
 	if(pv_parse_format(&s,&model)<0 || model==NULL) {
 	    LM_ERR("Wrong format <%s> for param <%d>!\n", s.s, param_count);
 	    return -1;
 	}
 	if(model->spec.getf==NULL) {
 	    if(param_count==1) {
 		if(str2int(&s, (unsigned int*)&model->spec.pvp.pvn.u.isname.name.n)!=0) {
 		    LM_ERR("Wrong value <%s> for param <%d>!\n",
 			   s.s, param_count);
 		    return -1;
 		}
 	    }
 	}
 	*param = (void*)model;
     }
     return 0;
 }

Contributed Logic / annotate

opensips/modules/lcr/lcr_mod.c@8ec65b8f6e2c (annotated)

opensips/modules/lcr/lcr_mod.c