Contributed Logic / file comparison

comparison: opensips/modules/lcr/lcr_mod.c

opensips/modules/lcr/lcr_mod.c

changeset 23
d783b433388d
parent 16
c5c55937e44c
equal deleted inserted replaced
0:e0fa091cdb6d 1:f32acf32c034
112 112
113 #define FROM_URI_COL "from_uri" 113 #define FROM_URI_COL "from_uri"
114 114
115 #define PRIORITY_COL "priority" 115 #define PRIORITY_COL "priority"
116 116
117 #define USER_COL "user"
118
119 #define REALM_COL "realm"
120
121 #define PASSWD_COL "passwd"
122
117 #define MAX_NO_OF_GWS 32 123 #define MAX_NO_OF_GWS 32
118 #define MAX_NO_OF_LCRS 256 124 #define MAX_NO_OF_LCRS 256
119 #define MAX_PREFIX_LEN 256 125 #define MAX_PREFIX_LEN 256
126 #define MAX_USER_LEN 64
127 #define MAX_REALM_LEN 64
128 #define MAX_PASSWD_LEN 64
120 #define MAX_TAG_LEN 16 129 #define MAX_TAG_LEN 16
121 #define MAX_FROM_URI_LEN 256 130 #define MAX_FROM_URI_LEN 256
122 131
123 /* Default module parameter values */ 132 /* Default module parameter values */
124 #define DEF_FR_INV_TIMER 90 133 #define DEF_FR_INV_TIMER 90
139 uri_transport transport; 148 uri_transport transport;
140 unsigned int strip; 149 unsigned int strip;
141 char tag[MAX_TAG_LEN + 1]; 150 char tag[MAX_TAG_LEN + 1];
142 unsigned short tag_len; 151 unsigned short tag_len;
143 unsigned int flags; 152 unsigned int flags;
153 char user[MAX_USER_LEN];
154 unsigned short user_len;
155 char realm[MAX_REALM_LEN];
156 unsigned short realm_len;
157 char passwd[MAX_PASSWD_LEN];
158 unsigned short passwd_len;
144 }; 159 };
145 160
146 struct lcr_info { 161 struct lcr_info {
147 char prefix[MAX_PREFIX_LEN + 1]; 162 char prefix[MAX_PREFIX_LEN + 1];
148 unsigned short prefix_len; 163 unsigned short prefix_len;
194 static str flags_col = str_init(FLAGS_COL); 209 static str flags_col = str_init(FLAGS_COL);
195 static str lcr_table = str_init(LCR_TABLE); 210 static str lcr_table = str_init(LCR_TABLE);
196 static str prefix_col = str_init(PREFIX_COL); 211 static str prefix_col = str_init(PREFIX_COL);
197 static str from_uri_col = str_init(FROM_URI_COL); 212 static str from_uri_col = str_init(FROM_URI_COL);
198 static str priority_col = str_init(PRIORITY_COL); 213 static str priority_col = str_init(PRIORITY_COL);
214 static str user_col = str_init(USER_COL);
215 static str realm_col = str_init(REALM_COL);
216 static str passwd_col = str_init(PASSWD_COL);
199 217
200 /* timer */ 218 /* timer */
201 int fr_inv_timer = DEF_FR_INV_TIMER; 219 int fr_inv_timer = DEF_FR_INV_TIMER;
202 int fr_inv_timer_next = DEF_FR_INV_TIMER_NEXT; 220 int fr_inv_timer_next = DEF_FR_INV_TIMER_NEXT;
203 221
206 static char *gw_uri_avp_param = NULL; 224 static char *gw_uri_avp_param = NULL;
207 static char *ruri_user_avp_param = NULL; 225 static char *ruri_user_avp_param = NULL;
208 static char *contact_avp_param = NULL; 226 static char *contact_avp_param = NULL;
209 static char *rpid_avp_param = NULL; 227 static char *rpid_avp_param = NULL;
210 static char *flags_avp_param = NULL; 228 static char *flags_avp_param = NULL;
229 static char *user_avp_param = NULL;
230 static char *realm_avp_param = NULL;
231 static char *passwd_avp_param = NULL;
211 232
212 /* prefix mode */ 233 /* prefix mode */
213 int prefix_mode_param = DEF_PREFIX_MODE; 234 int prefix_mode_param = DEF_PREFIX_MODE;
214 235
215 /* 236 /*
237 static int_str contact_avp; 258 static int_str contact_avp;
238 static int rpid_avp_type; 259 static int rpid_avp_type;
239 static int_str rpid_avp; 260 static int_str rpid_avp;
240 static int flags_avp_type; 261 static int flags_avp_type;
241 static int_str flags_avp; 262 static int_str flags_avp;
263 static int user_avp_type;
264 static int_str user_avp;
265 static int realm_avp_type;
266 static int_str realm_avp;
267 static int passwd_avp_type;
268 static int_str passwd_avp;
242 269
243 struct gw_info **gws; /* Pointer to current gw table pointer */ 270 struct gw_info **gws; /* Pointer to current gw table pointer */
244 struct gw_info *gws_1; /* Pointer to gw table 1 */ 271 struct gw_info *gws_1; /* Pointer to gw table 1 */
245 struct gw_info *gws_2; /* Pointer to gw table 2 */ 272 struct gw_info *gws_2; /* Pointer to gw table 2 */
246 273
325 {"rpid_avp", STR_PARAM, &rpid_avp_param }, 352 {"rpid_avp", STR_PARAM, &rpid_avp_param },
326 {"flags_avp", STR_PARAM, &flags_avp_param }, 353 {"flags_avp", STR_PARAM, &flags_avp_param },
327 {"fr_inv_timer", INT_PARAM, &fr_inv_timer }, 354 {"fr_inv_timer", INT_PARAM, &fr_inv_timer },
328 {"fr_inv_timer_next", INT_PARAM, &fr_inv_timer_next }, 355 {"fr_inv_timer_next", INT_PARAM, &fr_inv_timer_next },
329 {"prefix_mode", INT_PARAM, &prefix_mode_param }, 356 {"prefix_mode", INT_PARAM, &prefix_mode_param },
357 {"user_column", STR_PARAM, &user_col.s },
358 {"realm_column", STR_PARAM, &realm_col.s },
359 {"passwd_column", STR_PARAM, &passwd_col.s },
360 {"auth_username_avp", STR_PARAM, &user_avp_param },
361 {"auth_realm_avp", STR_PARAM, &realm_avp_param },
362 {"auth_password_avp", STR_PARAM, &passwd_avp_param },
330 {0, 0, 0} 363 {0, 0, 0}
331 }; 364 };
332 365
333 366
334 /* 367 /*
436 flags_col.len = strlen(flags_col.s); 469 flags_col.len = strlen(flags_col.s);
437 lcr_table.len = strlen(lcr_table.s); 470 lcr_table.len = strlen(lcr_table.s);
438 prefix_col.len = strlen(prefix_col.s); 471 prefix_col.len = strlen(prefix_col.s);
439 from_uri_col.len = strlen(from_uri_col.s); 472 from_uri_col.len = strlen(from_uri_col.s);
440 priority_col.len = strlen(priority_col.s); 473 priority_col.len = strlen(priority_col.s);
474 user_col.len = strlen(user_col.s);
475 realm_col.len = strlen(realm_col.s);
476 passwd_col.len = strlen(passwd_col.s);
441 477
442 /* Bind database */ 478 /* Bind database */
443 if (lcr_db_bind(&db_url)) { 479 if (lcr_db_bind(&db_url)) {
444 LM_ERR("No database module found\n"); 480 LM_ERR("No database module found\n");
445 return -1; 481 return -1;
558 return -1; 594 return -1;
559 } 595 }
560 flags_avp_type = avp_flags; 596 flags_avp_type = avp_flags;
561 } else { 597 } else {
562 LM_ERR("AVP flags_avp has not been defined\n"); 598 LM_ERR("AVP flags_avp has not been defined\n");
599 return -1;
600 }
601
602 if (user_avp_param && *user_avp_param) {
603 s.s = user_avp_param; s.len = strlen(s.s);
604 if (pv_parse_spec(&s, &avp_spec)==0
605 || avp_spec.type!=PVT_AVP) {
606 LM_ERR("Malformed or non AVP definition <%s>\n", user_avp_param);
607 return -1;
608 }
609
610 if(pv_get_avp_name(0, &(avp_spec.pvp), &user_avp, &avp_flags)!=0) {
611 LM_ERR("Invalid AVP definition <%s>\n", user_avp_param);
612 return -1;
613 }
614 user_avp_type = avp_flags;
615 } else {
616 LM_ERR("AVP user_avp has not been defined\n");
617 return -1;
618 }
619
620 if (realm_avp_param && *realm_avp_param) {
621 s.s = realm_avp_param; s.len = strlen(s.s);
622 if (pv_parse_spec(&s, &avp_spec)==0
623 || avp_spec.type!=PVT_AVP) {
624 LM_ERR("Malformed or non AVP definition <%s>\n", realm_avp_param);
625 return -1;
626 }
627
628 if(pv_get_avp_name(0, &(avp_spec.pvp), &realm_avp, &avp_flags)!=0) {
629 LM_ERR("Invalid AVP definition <%s>\n", realm_avp_param);
630 return -1;
631 }
632 realm_avp_type = avp_flags;
633 } else {
634 LM_ERR("AVP realm_avp has not been defined\n");
635 return -1;
636 }
637
638 if (passwd_avp_param && *passwd_avp_param) {
639 s.s = passwd_avp_param; s.len = strlen(s.s);
640 if (pv_parse_spec(&s, &avp_spec)==0
641 || avp_spec.type!=PVT_AVP) {
642 LM_ERR("Malformed or non AVP definition <%s>\n", passwd_avp_param);
643 return -1;
644 }
645
646 if(pv_get_avp_name(0, &(avp_spec.pvp), &passwd_avp, &avp_flags)!=0) {
647 LM_ERR("Invalid AVP definition <%s>\n", passwd_avp_param);
648 return -1;
649 }
650 passwd_avp_type = avp_flags;
651 } else {
652 LM_ERR("AVP passwd_avp has not been defined\n");
563 return -1; 653 return -1;
564 } 654 }
565 655
566 /* Check table version */ 656 /* Check table version */
567 db_con_t* dbh; 657 db_con_t* dbh;
799 * make unused gw and lcr table the one in use. 889 * make unused gw and lcr table the one in use.
800 */ 890 */
801 int reload_gws(void) 891 int reload_gws(void)
802 { 892 {
803 unsigned int i, port, strip, tag_len, prefix_len, from_uri_len, 893 unsigned int i, port, strip, tag_len, prefix_len, from_uri_len,
804 grp_id, priority; 894 user_len, realm_len, passwd_len, grp_id, priority;
805 struct in_addr ip_addr; 895 struct in_addr ip_addr;
806 unsigned int flags; 896 unsigned int flags;
807 uri_type scheme; 897 uri_type scheme;
808 uri_transport transport; 898 uri_transport transport;
809 db_con_t* dbh; 899 db_con_t* dbh;
810 char *tag, *prefix, *from_uri; 900 char *tag, *prefix, *from_uri;
901 char *user, *realm, *passwd;
811 db_res_t* res = NULL; 902 db_res_t* res = NULL;
812 db_row_t* row; 903 db_row_t* row;
813 db_key_t gw_cols[8]; 904 db_key_t gw_cols[11];
814 db_key_t lcr_cols[4]; 905 db_key_t lcr_cols[4];
815 906
816 gw_cols[0] = &ip_addr_col; 907 gw_cols[0] = &ip_addr_col;
817 gw_cols[1] = &port_col; 908 gw_cols[1] = &port_col;
818 gw_cols[2] = &uri_scheme_col; 909 gw_cols[2] = &uri_scheme_col;
821 gw_cols[5] = &tag_col; 912 gw_cols[5] = &tag_col;
822 /* FIXME: is this ok if we have different names for grp_id 913 /* FIXME: is this ok if we have different names for grp_id
823 in the two tables? (ge vw lcr) */ 914 in the two tables? (ge vw lcr) */
824 gw_cols[6] = &grp_id_col; 915 gw_cols[6] = &grp_id_col;
825 gw_cols[7] = &flags_col; 916 gw_cols[7] = &flags_col;
917 gw_cols[8] = &user_col;
918 gw_cols[9] = &realm_col;
919 gw_cols[10] = &passwd_col;
826 920
827 lcr_cols[0] = &prefix_col; 921 lcr_cols[0] = &prefix_col;
828 lcr_cols[1] = &from_uri_col; 922 lcr_cols[1] = &from_uri_col;
829 /* FIXME: is this ok if we have different names for grp_id 923 /* FIXME: is this ok if we have different names for grp_id
830 in the two tables? (ge vw lcr) */ 924 in the two tables? (ge vw lcr) */
844 if (lcr_dbf.use_table(dbh, &gw_table) < 0) { 938 if (lcr_dbf.use_table(dbh, &gw_table) < 0) {
845 LM_ERR("Error while trying to use gw table\n"); 939 LM_ERR("Error while trying to use gw table\n");
846 return -1; 940 return -1;
847 } 941 }
848 942
849 if (lcr_dbf.query(dbh, NULL, 0, NULL, gw_cols, 0, 8, 0, &res) < 0) { 943 if (lcr_dbf.query(dbh, NULL, 0, NULL, gw_cols, 0, 11, 0, &res) < 0) {
850 LM_ERR("Failed to query gw data\n"); 944 LM_ERR("Failed to query gw data\n");
851 lcr_dbf.close(dbh); 945 lcr_dbf.close(dbh);
852 return -1; 946 return -1;
853 } 947 }
854 948
936 LM_ERR("Attribute flags is NULL or non-int\n"); 1030 LM_ERR("Attribute flags is NULL or non-int\n");
937 lcr_dbf.free_result(dbh, res); 1031 lcr_dbf.free_result(dbh, res);
938 lcr_dbf.close(dbh); 1032 lcr_dbf.close(dbh);
939 return -1; 1033 return -1;
940 } 1034 }
1035 if (VAL_NULL(ROW_VALUES(row) + 8) == 1) {
1036 user_len = 0;
1037 user = (char *)0;
1038 } else {
1039 user = (char *)VAL_STRING(ROW_VALUES(row) + 8);
1040 user_len = strlen(user);
1041 if (user_len > MAX_USER_LEN) {
1042 LM_ERR("Too long gw user <%u>\n", user_len);
1043 lcr_dbf.free_result(dbh, res);
1044 lcr_dbf.close(dbh);
1045 return -1;
1046 }
1047 }
1048 if (VAL_NULL(ROW_VALUES(row) + 9) == 1) {
1049 realm_len = 0;
1050 realm = (char *)0;
1051 } else {
1052 realm = (char *)VAL_STRING(ROW_VALUES(row) + 9);
1053 realm_len = strlen(realm);
1054 if (realm_len > MAX_REALM_LEN) {
1055 LM_ERR("Too long gw realm <%u>\n", realm_len);
1056 lcr_dbf.free_result(dbh, res);
1057 lcr_dbf.close(dbh);
1058 return -1;
1059 }
1060 }
1061 if (VAL_NULL(ROW_VALUES(row) + 10) == 1) {
1062 passwd_len = 0;
1063 passwd = (char *)0;
1064 } else {
1065 passwd = (char *)VAL_STRING(ROW_VALUES(row) + 10);
1066 passwd_len = strlen(passwd);
1067 if (passwd_len > MAX_PASSWD_LEN) {
1068 LM_ERR("Too long gw passwd <%u>\n", passwd_len);
1069 lcr_dbf.free_result(dbh, res);
1070 lcr_dbf.close(dbh);
1071 return -1;
1072 }
1073 }
941 if (*gws == gws_1) { 1074 if (*gws == gws_1) {
942 gws_2[i].ip_addr = (unsigned int)ip_addr.s_addr; 1075 gws_2[i].ip_addr = (unsigned int)ip_addr.s_addr;
943 gws_2[i].port = port; 1076 gws_2[i].port = port;
944 gws_2[i].grp_id = grp_id; 1077 gws_2[i].grp_id = grp_id;
945 gws_2[i].scheme = scheme; 1078 gws_2[i].scheme = scheme;
947 gws_2[i].flags = flags; 1080 gws_2[i].flags = flags;
948 gws_2[i].strip = strip; 1081 gws_2[i].strip = strip;
949 gws_2[i].tag_len = tag_len; 1082 gws_2[i].tag_len = tag_len;
950 if (tag_len) 1083 if (tag_len)
951 memcpy(&(gws_2[i].tag[0]), tag, tag_len); 1084 memcpy(&(gws_2[i].tag[0]), tag, tag_len);
1085 gws_2[i].user_len = user_len;
1086 if (user_len)
1087 memcpy(&(gws_2[i].user[0]), user, user_len);
1088 gws_2[i].realm_len = realm_len;
1089 if (realm_len)
1090 memcpy(&(gws_2[i].realm[0]), realm, realm_len);
1091 gws_2[i].passwd_len = passwd_len;
1092 if (passwd_len)
1093 memcpy(&(gws_2[i].passwd[0]), passwd, passwd_len);
952 } else { 1094 } else {
953 gws_1[i].ip_addr = (unsigned int)ip_addr.s_addr; 1095 gws_1[i].ip_addr = (unsigned int)ip_addr.s_addr;
954 gws_1[i].port = port; 1096 gws_1[i].port = port;
955 gws_1[i].grp_id = grp_id; 1097 gws_1[i].grp_id = grp_id;
956 gws_1[i].scheme = scheme; 1098 gws_1[i].scheme = scheme;
958 gws_1[i].flags = flags; 1100 gws_1[i].flags = flags;
959 gws_1[i].strip = strip; 1101 gws_1[i].strip = strip;
960 gws_1[i].tag_len = tag_len; 1102 gws_1[i].tag_len = tag_len;
961 if (tag_len) 1103 if (tag_len)
962 memcpy(&(gws_1[i].tag[0]), tag, tag_len); 1104 memcpy(&(gws_1[i].tag[0]), tag, tag_len);
1105 gws_1[i].user_len = user_len;
1106 if (user_len)
1107 memcpy(&(gws_1[i].user[0]), user, user_len);
1108 gws_1[i].realm_len = realm_len;
1109 if (realm_len)
1110 memcpy(&(gws_1[i].realm[0]), realm, realm_len);
1111 gws_1[i].passwd_len = passwd_len;
1112 if (passwd_len)
1113 memcpy(&(gws_1[i].passwd[0]), passwd, passwd_len);
963 } 1114 }
964 } 1115 }
965 1116
966 lcr_dbf.free_result(dbh, res); 1117 lcr_dbf.free_result(dbh, res);
967 1118
1139 1290
1140 p = int2str((unsigned long)(*gws)[i].flags, &len ); 1291 p = int2str((unsigned long)(*gws)[i].flags, &len );
1141 attr = add_mi_attr(node, MI_DUP_VALUE, "FLAGS", 5, p, len); 1292 attr = add_mi_attr(node, MI_DUP_VALUE, "FLAGS", 5, p, len);
1142 if(attr == NULL) 1293 if(attr == NULL)
1143 return -1; 1294 return -1;
1295
1296 attr = add_mi_attr(node, MI_DUP_VALUE, "USER", 6,
1297 (*gws)[i].user, (*gws)[i].user_len );
1298 if(attr == NULL)
1299 return -1;
1300
1301 attr = add_mi_attr(node, MI_DUP_VALUE, "REALM", 6,
1302 (*gws)[i].realm, (*gws)[i].realm_len );
1303 if(attr == NULL)
1304 return -1;
1305
1306 attr = add_mi_attr(node, MI_DUP_VALUE, "PASSWD", 6,
1307 (*gws)[i].passwd, (*gws)[i].passwd_len );
1308 if(attr == NULL)
1309 return -1;
1144 } 1310 }
1145 1311
1146 for (i = 0; i < MAX_NO_OF_LCRS; i++) { 1312 for (i = 0; i < MAX_NO_OF_LCRS; i++) {
1147 if ((*lcrs)[i].end_record != 0) 1313 if ((*lcrs)[i].end_record != 0)
1148 break; 1314 break;
1182 str ruri_user, from_uri, value; 1348 str ruri_user, from_uri, value;
1183 char from_uri_str[MAX_FROM_URI_LEN + 1]; 1349 char from_uri_str[MAX_FROM_URI_LEN + 1];
1184 char ruri[MAX_URI_SIZE]; 1350 char ruri[MAX_URI_SIZE];
1185 unsigned int i, j, k, index, addr, port, strip, gw_index, 1351 unsigned int i, j, k, index, addr, port, strip, gw_index,
1186 duplicated_gw, flags, have_rpid_avp; 1352 duplicated_gw, flags, have_rpid_avp;
1353 char *user;
1354 char *realm;
1355 char *passwd;
1187 uri_type scheme; 1356 uri_type scheme;
1188 uri_transport transport; 1357 uri_transport transport;
1189 struct ip_addr address; 1358 struct ip_addr address;
1190 str addr_str, port_str; 1359 str addr_str, port_str;
1191 char *at, *tag, *strip_string, *flags_string; 1360 char *at, *tag, *strip_string, *flags_string;
1405 port = (*gws)[index].port; 1574 port = (*gws)[index].port;
1406 scheme = (*gws)[index].scheme; 1575 scheme = (*gws)[index].scheme;
1407 transport = (*gws)[index].transport; 1576 transport = (*gws)[index].transport;
1408 flags = (*gws)[index].flags; 1577 flags = (*gws)[index].flags;
1409 strip = (*gws)[index].strip; 1578 strip = (*gws)[index].strip;
1579 user = (*gws)[index].user;
1580 realm = (*gws)[index].realm;
1581 passwd = (*gws)[index].passwd;
1410 if (strip > ruri_user.len) { 1582 if (strip > ruri_user.len) {
1411 LM_ERR("Strip count of gw is too large <%u>\n", strip); 1583 LM_ERR("Strip count of gw is too large <%u>\n", strip);
1412 goto skip; 1584 goto skip;
1413 } 1585 }
1414 tag_len = (*gws)[index].tag_len; 1586 tag_len = (*gws)[index].tag_len;
1474 value.s = (char *)&(ruri[0]); 1646 value.s = (char *)&(ruri[0]);
1475 value.len = at - value.s; 1647 value.len = at - value.s;
1476 val.s = value; 1648 val.s = value;
1477 add_avp(gw_uri_avp_type|AVP_VAL_STR, gw_uri_avp, val); 1649 add_avp(gw_uri_avp_type|AVP_VAL_STR, gw_uri_avp, val);
1478 LM_DBG("Added gw_uri_avp <%.*s>\n", value.len, value.s); 1650 LM_DBG("Added gw_uri_avp <%.*s>\n", value.len, value.s);
1651
1652 value.s = user;
1653 value.len = strlen(value.s);
1654 val.s = value;
1655 add_avp(user_avp_type|AVP_VAL_STR, user_avp, val);
1656 LM_DBG("Added user_avp <%.*s>\n", value.len, value.s);
1657
1658 value.s = realm;
1659 value.len = strlen(value.s);
1660 val.s = value;
1661 add_avp(realm_avp_type|AVP_VAL_STR, realm_avp, val);
1662 LM_DBG("Added realm_avp <%.*s>\n", value.len, value.s);
1663
1664 value.s = passwd;
1665 value.len = strlen(value.s);
1666 val.s = value;
1667 add_avp(passwd_avp_type|AVP_VAL_STR, passwd_avp, val);
1668 LM_DBG("Added passwd_avp <%.*s>\n", value.len, value.s);
1669
1479 skip: 1670 skip:
1480 continue; 1671 continue;
1481 } 1672 }
1482 1673
1483 return 1; 1674 return 1;
1556 * Returns 1 upon success and -1 upon failure. 1747 * Returns 1 upon success and -1 upon failure.
1557 */ 1748 */
1558 static int next_gw(struct sip_msg* _m, char* _s1, char* _s2) 1749 static int next_gw(struct sip_msg* _m, char* _s1, char* _s2)
1559 { 1750 {
1560 int_str gw_uri_val, ruri_user_val, val; 1751 int_str gw_uri_val, ruri_user_val, val;
1561 struct usr_avp *gu_avp, *ru_avp; 1752 int_str user_val, realm_val, passwd_val;
1753 struct usr_avp *gu_avp, *ru_avp, *usr_avp, *rlm_avp, *pwd_avp;
1562 int rval; 1754 int rval;
1563 str new_ruri; 1755 str new_ruri;
1564 char *at, *at_char, *strip_char, *endptr; 1756 char *at, *at_char, *strip_char, *endptr;
1565 unsigned int strip; 1757 unsigned int strip;
1566 1758
1572 add_avp(flags_avp_type, flags_avp, val); 1764 add_avp(flags_avp_type, flags_avp, val);
1573 LM_DBG("Added flags_avp <%u>\n", (unsigned int)val.n); 1765 LM_DBG("Added flags_avp <%u>\n", (unsigned int)val.n);
1574 1766
1575 gw_uri_val.s.len = gw_uri_val.s.len - (at - gw_uri_val.s.s); 1767 gw_uri_val.s.len = gw_uri_val.s.len - (at - gw_uri_val.s.s);
1576 gw_uri_val.s.s = at; 1768 gw_uri_val.s.s = at;
1769
1770 /* Save gateway AVPs for use in script */
1771 usr_avp = search_first_avp(user_avp_type, user_avp, &user_val, 0);
1772 rlm_avp = search_first_avp(realm_avp_type, realm_avp, &realm_val, 0);
1773 pwd_avp = search_first_avp(passwd_avp_type, passwd_avp, &passwd_val, 0);
1774 if (!usr_avp) {
1775 LM_DBG("User AVP no set\n");
1776 return -1;
1777 }
1778 else {
1779 add_avp(user_avp_type|AVP_VAL_STR, user_avp, user_val);
1780 LM_DBG("Added user_avp <%.*s>\n", user_val.s.len, user_val.s.s);
1781 }
1782 if (!rlm_avp) {
1783 LM_DBG("Realm AVP no set\n");
1784 return -1;
1785 }
1786 else {
1787 add_avp(realm_avp_type|AVP_VAL_STR, realm_avp, realm_val);
1788 LM_DBG("Added realm_avp <%.*s>\n", realm_val.s.len, realm_val.s.s);
1789 }
1790 if (!pwd_avp) {
1791 LM_DBG("Passwd AVP no set\n");
1792 return -1;
1793 }
1794 else {
1795 add_avp(passwd_avp_type|AVP_VAL_STR, passwd_avp, passwd_val);
1796 LM_DBG("Added passwd_avp <%.*s>\n", passwd_val.s.len, passwd_val.s.s);
1797 }
1577 1798
1578 /* Create new Request-URI taking URI user from ruri_user AVP 1799 /* Create new Request-URI taking URI user from ruri_user AVP
1579 and other parts of from gateway URI AVP. */ 1800 and other parts of from gateway URI AVP. */
1580 ru_avp = search_first_avp(ruri_user_avp_type, ruri_user_avp, 1801 ru_avp = search_first_avp(ruri_user_avp_type, ruri_user_avp,
1581 &ruri_user_val, 0); 1802 &ruri_user_val, 0);

Mercurial Repository: Contributed Logic

Europalab SCM Repository Server

mercurial