a5b93bbc230c9b3e5d6ffde8c3b3b6fb5f98fdbf
[sip-router] / src / modules / lrkproxy / lrkproxy.c
1 /*
2  * Copyright (C) 2003-2008 Sippy Software, Inc., http://www.sippysoft.com
3  * Copyright (C) 2020 Mojtaba Esfandiari.S, Nasim-Telecom
4  *
5  * This file is part of Kamailio, a free SIP server.
6  *
7  * Kamailio is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version
11  *
12  * Kamailio is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
20  *
21  */
22
23 #include <sys/types.h>
24 #include <sys/socket.h>
25 #include <sys/time.h>
26 #include <netinet/in.h>
27 #include <netinet/in_systm.h>
28 #ifndef __USE_BSD
29 #define  __USE_BSD
30 #endif
31 #include <netinet/ip.h>
32 #ifndef __FAVOR_BSD
33 #define __FAVOR_BSD
34 #endif
35 #include <netinet/udp.h>
36 #include <arpa/inet.h>
37 #include <sys/uio.h>
38 #include <sys/un.h>
39 #include <ctype.h>
40 #include <errno.h>
41 #include <netdb.h>
42 #include <poll.h>
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <string.h>
46 #include <unistd.h>
47
48 #include "../../core/flags.h"
49 #include "../../core/sr_module.h"
50 #include "../../core/dprint.h"
51 #include "../../core/data_lump.h"
52 #include "../../core/data_lump_rpl.h"
53 #include "../../core/error.h"
54 #include "../../core/forward.h"
55 #include "../../core/mem/mem.h"
56 #include "../../core/parser/parse_from.h"
57 #include "../../core/parser/parse_to.h"
58 #include "../../core/parser/parse_uri.h"
59 #include "../../core/parser/parser_f.h"
60 #include "../../core/parser/sdp/sdp.h"
61 #include "../../core/resolve.h"
62 #include "../../core/timer.h"
63 #include "../../core/trim.h"
64 #include "../../core/ut.h"
65 #include "../../core/pt.h"
66 #include "../../core/timer_proc.h"
67 #include "../../core/rpc.h"
68 #include "../../core/rpc_lookup.h"
69 #include "../../core/pvar.h"
70 #include "../../core/lvalue.h"
71 #include "../../core/msg_translator.h"
72 #include "../../core/usr_avp.h"
73 #include "../../core/socket_info.h"
74 #include "../../core/mod_fix.h"
75 #include "../../core/dset.h"
76 #include "../../core/route.h"
77 #include "../../core/kemi.h"
78 #include "../../modules/tm/tm_load.h"
79 #include "lrkproxy.h"
80 #include "lrkproxy_hash.h"
81 #include "lrkproxy_funcs.h"
82
83 MODULE_VERSION
84
85
86 #if !defined(AF_LOCAL)
87 #define AF_LOCAL AF_UNIX
88 #endif
89 #if !defined(PF_LOCAL)
90 #define PF_LOCAL PF_UNIX
91 #endif
92
93 ///* NAT UAC test constants */
94 //#define       NAT_UAC_TEST_C_1918     0x01
95 //#define       NAT_UAC_TEST_RCVD       0x02
96 //#define       NAT_UAC_TEST_V_1918     0x04
97 //#define       NAT_UAC_TEST_S_1918     0x08
98 //#define       NAT_UAC_TEST_RPORT      0x10
99
100 #define DEFAULT_LRKP_SET_ID             0
101 static str DEFAULT_LRKP_SET_ID_STR = str_init("0");
102
103 //#define RPC_DEFAULT_NATPING_STATE     1
104
105 #define RPC_MIN_RECHECK_TICKS           0
106 #define RPC_MAX_RECHECK_TICKS           (unsigned int)-1
107
108
109 /* Supported version of the LRK proxy command protocol */
110 #define SUP_CPROTOVER   "20190708"
111 /* Required additional version of the LRK proxy command protocol */
112 #define REQ_CPROTOVER   "20190709"
113 /* Additional version necessary for re-packetization support */
114 #define REP_CPROTOVER   "20190708"
115 #define PTL_CPROTOVER   "20190708"
116
117 #define CPORT           "22333"
118 #define HASH_SIZE   128
119
120 static char *gencookie();
121 static int lrkp_test(struct lrkp_node*);
122 static int lrkp_get_config(struct lrkp_node *node);
123 static int lrkp_set_conntrack_rule(struct lrkproxy_hash_entry *e);
124
125
126 static int lrkproxy_force(struct sip_msg *msg, const char *flags, enum lrk_operation op, int more);
127 static int lrkproxy_unforce(struct sip_msg *msg, const char *flags, enum lrk_operation op, int more);
128
129 static int lrkproxy_manage0(struct sip_msg *msg, char *flags, char *ip);
130 static int lrkproxy_manage1(struct sip_msg *msg, char *flags, char *ip);
131 static int lrkproxy_manage2(struct sip_msg *msg, char *flags, char *ip);
132
133 static int change_media_sdp(sip_msg_t *msg, struct lrkproxy_hash_entry *e, const char *flags, enum lrk_operation op);
134
135 static int add_lrkproxy_socks(struct lrkp_set * lrkp_list, char * lrkproxy);
136 static int fixup_set_id(void ** param, int param_no);
137 static int set_lrkproxy_set_f(struct sip_msg * msg, char * str1, char * str2);
138
139 static struct lrkp_set * select_lrkp_set(int id_set);
140
141 static int lrkproxy_set_store(modparam_t type, void * val);
142 static int lrkproxy_add_lrkproxy_set( char * lrk_proxies);
143
144 static int mod_init(void);
145 static int child_init(int);
146 static void mod_destroy(void);
147
148 /* Pseudo-Variables */
149 //static int pv_get_lrkstat_f(struct sip_msg *, pv_param_t *, pv_value_t *);
150
151 static int lrkproxy_disable_tout = 60;
152 static int lrkproxy_retr = 5;
153 static int lrkproxy_tout = 1;
154 static pid_t mypid;
155 static unsigned int myseqn = 0;
156 //static str nolrkproxy_str = str_init("a=nolrkproxy:yes");
157 //static str extra_id_pv_param = {NULL, 0};
158
159 static char ** lrkp_strings=0;
160 static int lrkp_sets=0; /*used in lrkproxy_set_store()*/
161 static int lrkp_set_count = 0;
162 static unsigned int current_msg_id = (unsigned int)-1;
163 /* LRK proxy balancing list */
164 struct lrkp_set_head * lrkp_set_list =0;
165 struct lrkp_set * selected_lrkp_set =0;
166 struct lrkp_set * default_lrkp_set=0;
167 struct lrkp_node *selected_lrkp_node = 0;
168 int lrkp_algorithm = LRK_LINER;
169 static int hash_table_size = 0;
170 static int hash_table_tout = 3600;
171
172
173
174 //static char *ice_candidate_priority_avp_param = NULL;
175 //static int ice_candidate_priority_avp_type;
176 //static int_str ice_candidate_priority_avp;
177 //static str lrk_inst_pv_param = {NULL, 0};
178 //static pv_spec_t *lrk_inst_pvar = NULL;
179
180 /* array with the sockets used by lrkproxy (per process)*/
181 static unsigned int lrkp_no = 0;
182 static int *lrkp_socks = 0;
183
184
185 typedef struct lrkp_set_link {
186         struct lrkp_set *rset;
187         pv_spec_t *rpv;
188 } lrkp_set_link_t;
189
190 /* tm */
191 static struct tm_binds tmb;
192
193 /*0-> disabled, 1 ->enabled*/
194 //unsigned int *natping_state=0;
195
196 static cmd_export_t cmds[] = {
197
198         {"set_lrkproxy_set",  (cmd_function)set_lrkproxy_set_f,    1,
199                 fixup_set_id, 0,
200                 ANY_ROUTE},
201         {"lrkproxy_manage",     (cmd_function)lrkproxy_manage0,     0,
202                                                        0, 0,
203                    ANY_ROUTE},
204         {"lrkproxy_manage",     (cmd_function)lrkproxy_manage1,     1,
205                                                        fixup_spve_null, fixup_free_spve_null,
206                    ANY_ROUTE},
207         {"lrkproxy_manage",     (cmd_function)lrkproxy_manage2,     2,
208                                                        fixup_spve_spve, fixup_free_spve_spve,
209                    ANY_ROUTE},
210
211         {0, 0, 0, 0, 0, 0}
212 };
213
214 static param_export_t params[] = {
215         {"lrkproxy_sock",         PARAM_STRING|USE_FUNC_PARAM,
216                 (void*)lrkproxy_set_store          },
217         {"lrkproxy_disable_tout", INT_PARAM, &lrkproxy_disable_tout },
218         {"lrkproxy_retr",         INT_PARAM, &lrkproxy_retr         },
219         {"lrkproxy_tout",         INT_PARAM, &lrkproxy_tout         },
220         {"lrkp_alg",         INT_PARAM, &lrkp_algorithm         },
221         {"hash_table_tout",       INT_PARAM, &hash_table_tout        },
222         {"hash_table_size",       INT_PARAM, &hash_table_size        },
223
224         {0, 0, 0}
225 };
226
227 /** module exports */
228 struct module_exports exports= {
229         "lrkproxy",        /* module name */
230         DEFAULT_DLFLAGS, /* dlopen flags */
231         cmds,            /* cmd exports */
232         params,          /* param exports */
233         0,               /* RPC method exports */
234         0,         /* exported pseudo-variables */
235         0,               /* response handling function */
236         mod_init,        /* module initialization function */
237         child_init,               /* per-child init function */
238         mod_destroy                /* module destroy function */
239 };
240
241
242 static int lrkproxy_set_store(modparam_t type, void * val){
243
244     char * p;
245     int len;
246
247     p = (char* )val;
248
249     if(p==0 || *p=='\0'){
250         return 0;
251     }
252
253     if(lrkp_sets==0){
254         lrkp_strings = (char**)pkg_malloc(sizeof(char*));
255         if(!lrkp_strings){
256                     LM_ERR("no pkg memory left\n");
257             return -1;
258         }
259     } else {/*realloc to make room for the current set*/
260         lrkp_strings = (char**)pkg_reallocxf(lrkp_strings,
261                                              (lrkp_sets+1)* sizeof(char*));
262         if(!lrkp_strings){
263                     LM_ERR("no pkg memory left\n");
264             return -1;
265         }
266     }
267
268     /*allocate for the current set of urls*/
269     len = strlen(p);
270     lrkp_strings[lrkp_sets] = (char*)pkg_malloc((len+1)*sizeof(char));
271
272     if(!lrkp_strings[lrkp_sets]){
273                 LM_ERR("no pkg memory left\n");
274         return -1;
275     }
276
277     memcpy(lrkp_strings[lrkp_sets], p, len);
278     lrkp_strings[lrkp_sets][len] = '\0';
279     lrkp_sets++;
280
281     return 0;
282 }
283
284 struct lrkp_set *get_lrkp_set(str *const set_name)
285 {
286     unsigned int this_set_id;
287     struct lrkp_set *lrkp_list;
288     if (lrkp_set_list == NULL)
289     {
290                 LM_ERR("lrkp set list not configured\n");
291         return NULL;
292     }
293     /* Only integer set_names are valid at the moment */
294     if ((set_name->s == NULL) || (set_name->len == 0))
295     {
296                 LM_ERR("Invalid set name '%.*s'\n", set_name->len, set_name->s);
297         return NULL;
298     }
299     if (str2int(set_name, &this_set_id) < 0)
300     {
301                 LM_ERR("Invalid set name '%.*s' - must be integer\n", set_name->len, set_name->s);
302         return NULL;
303     }
304
305     lrkp_list = select_lrkp_set(this_set_id);
306
307     if(lrkp_list==NULL){        /*if a new id_set : add a new set of lrkp*/
308         lrkp_list = shm_malloc(sizeof(struct lrkp_set));
309         if(!lrkp_list){
310                     LM_ERR("no shm memory left\n");
311             return NULL;
312         }
313         memset(lrkp_list, 0, sizeof(struct lrkp_set));
314         lrkp_list->id_set = this_set_id;
315         if (lrkp_set_list->lset_first == NULL)
316         {
317             lrkp_set_list->lset_first = lrkp_list;
318         } else {
319             lrkp_set_list->lset_last->lset_next = lrkp_list;
320         }
321         lrkp_set_list->lset_last = lrkp_list;
322         lrkp_set_count++;
323
324         if (this_set_id == DEFAULT_LRKP_SET_ID)
325         {
326             default_lrkp_set = lrkp_list;
327         }
328     }
329     return lrkp_list;
330 }
331
332 int insert_lrkp_node(struct lrkp_set *const lrkp_list, const str *const url, const int weight, const int enable)
333 {
334     struct lrkp_node *pnode;
335
336     if ((pnode = shm_malloc(sizeof(struct lrkp_node) + url->len + 1)) == NULL)
337     {
338                 LM_ERR("out of shm memory\n");
339         return -1;
340     }
341
342     memset(pnode, 0, sizeof(struct lrkp_node) + url->len + 1);
343
344
345     struct lrkp_node_conf *node_conf;
346     node_conf = shm_malloc(sizeof(struct lrkp_node_conf));
347     if (!node_conf)
348     {
349                 LM_ERR("out of shm memory\n");
350         return -1;
351     }
352
353     memset(node_conf, 0, sizeof(struct lrkp_node_conf));
354     pnode->lrkp_n_c = node_conf;
355
356     pnode->idx = lrkp_no++;
357     pnode->ln_weight = weight;
358     pnode->ln_umode = 0;
359     pnode->ln_enable = enable;
360     /* Permanently disable if marked as disabled */
361 //    pnode->ln_recheck_ticks = disabled ? RPC_MAX_RECHECK_TICKS : 0;
362     pnode->ln_url.s = (char*)(pnode + 1);
363     memcpy(pnode->ln_url.s, url->s, url->len);
364     pnode->ln_url.len = url->len;
365
366             LM_DBG("url is '%.*s'\n", pnode->ln_url.len, pnode->ln_url.s);
367
368     /* Find protocol and store address */
369     pnode->ln_address = pnode->ln_url.s;
370     if (strncasecmp(pnode->ln_address, "udp:", 4) == 0) {
371         pnode->ln_umode = 1;
372         pnode->ln_address += 4;
373     } else if (strncasecmp(pnode->ln_address, "udp6:", 5) == 0) {
374         pnode->ln_umode = 6;
375         pnode->ln_address += 5;
376     } else if (strncasecmp(pnode->ln_address, "unix:", 5) == 0) {
377         pnode->ln_umode = 0;
378         pnode->ln_address += 5;
379     }
380
381     if (lrkp_list->ln_first == NULL)
382     {
383         lrkp_list->ln_first = pnode;
384     } else {
385         lrkp_list->ln_last->ln_next = pnode;
386     }
387     lrkp_list->ln_last = pnode;
388     lrkp_list->lrkp_node_count++;
389
390     return 0;
391 }
392
393 static int add_lrkproxy_socks(struct lrkp_set * lrkp_list,
394                               char * lrkproxy){
395     /* Make lrk proxies list. */
396     char *p, *p1, *p2, *plim;
397     int weight;
398     str url;
399
400     p = lrkproxy;
401     plim = p + strlen(p);
402
403     for(;;) {
404         weight = 1;
405         while (*p && isspace((int)*p))
406             ++p;
407         if (p >= plim)
408             break;
409         p1 = p;
410         while (*p && !isspace((int)*p))
411             ++p;
412         if (p <= p1)
413             break; /* may happen??? */
414         /* Have weight specified? If yes, scan it */
415         p2 = memchr(p1, '=', p - p1);
416         if (p2 != NULL) {
417             weight = strtoul(p2 + 1, NULL, 10);
418         } else {
419             p2 = p;
420         }
421
422         url.s = p1;
423         url.len = (p2-p1);
424         insert_lrkp_node(lrkp_list, &url, weight, 0);
425     }
426     return 0;
427 }
428
429 /*      0-succes
430  *  -1 - erorr
431  * */
432 static int lrkproxy_add_lrkproxy_set( char * lrk_proxies)
433 {
434     char *p,*p2;
435     struct lrkp_set * lrkp_list;
436     str id_set;
437
438     /* empty definition? */
439     p= lrk_proxies;
440     if(!p || *p=='\0'){
441         return 0;
442     }
443
444     for(;*p && isspace(*p);p++);
445     if(*p=='\0'){
446         return 0;
447     }
448
449     lrk_proxies = strstr(p, "==");
450     if(lrk_proxies){
451         if(*(lrk_proxies +2)=='\0'){
452                     LM_ERR("script error -invalid lrk proxy list!\n");
453             return -1;
454         }
455
456         *lrk_proxies = '\0';
457         p2 = lrk_proxies-1;
458         for(;isspace(*p2); *p2 = '\0',p2--);
459         id_set.s = p;   id_set.len = p2 - p+1;
460
461         if(id_set.len <= 0){
462                     LM_ERR("script error -invalid set_id value!\n");
463             return -1;
464         }
465
466         lrk_proxies+=2;
467     }else{
468         lrk_proxies = p;
469         id_set = DEFAULT_LRKP_SET_ID_STR;
470     }
471
472     for(;*lrk_proxies && isspace(*lrk_proxies);lrk_proxies++);
473
474     if(!(*lrk_proxies)){
475                 LM_ERR("script error -empty lrkproxy list\n");
476         return -1;;
477     }
478
479     lrkp_list = get_lrkp_set(&id_set);
480     if (lrkp_list == NULL)
481     {
482                 LM_ERR("Failed to get or create lrkp_list for '%.*s'\n", id_set.len, id_set.s);
483         return -1;
484     }
485
486     if(add_lrkproxy_socks(lrkp_list, lrk_proxies)!= 0){
487         return -1;
488     }
489
490     return 0;
491 }
492
493
494 static int fixup_set_id(void ** param, int param_no)
495 {
496         int int_val, err;
497         struct lrkp_set* lrkp_list;
498         lrkp_set_link_t *lrkl = NULL;
499         str s;
500
501         lrkl = (lrkp_set_link_t*)pkg_malloc(sizeof(lrkp_set_link_t));
502         if(lrkl==NULL) {
503                 LM_ERR("no more pkg memory\n");
504                 return -1;
505         }
506         memset(lrkl, 0, sizeof(lrkp_set_link_t));
507         s.s = (char*)*param;
508         s.len = strlen(s.s);
509
510         if(s.s[0] == PV_MARKER) {
511                 int_val = pv_locate_name(&s);
512                 if(int_val<0 || int_val!=s.len) {
513                         LM_ERR("invalid parameter %s\n", s.s);
514                         pkg_free(lrkl);
515                         return -1;
516                 }
517                 lrkl->rpv = pv_cache_get(&s);
518                 if(lrkl->rpv == NULL) {
519                         LM_ERR("invalid pv parameter %s\n", s.s);
520                         pkg_free(lrkl);
521                         return -1;
522                 }
523         } else {
524                 int_val = str2s(*param, strlen(*param), &err);
525                 if (err == 0) {
526                         pkg_free(*param);
527                         if((lrkp_list = select_lrkp_set(int_val)) ==0){
528                                 LM_ERR("lrkp_proxy set %i not configured\n", int_val);
529                                 pkg_free(lrkl);
530                                 return E_CFG;
531                         }
532                         lrkl->rset = lrkp_list;
533                 } else {
534                         LM_ERR("bad number <%s>\n",     (char *)(*param));
535                         pkg_free(lrkl);
536                         return E_CFG;
537                 }
538         }
539         *param = (void*)lrkl;
540         return 0;
541 }
542
543
544 static int
545 mod_init(void)
546 {
547     int i;
548 //      pv_spec_t avp_spec;
549 //      str s;
550 //      unsigned short avp_flags;
551
552 //      if(lrkproxy_rpc_init()<0)
553 //      {
554 //              LM_ERR("failed to register RPC commands\n");
555 //              return -1;
556 //      }
557
558     /* Configure the head of the lrkp_set_list */
559     lrkp_set_list = shm_malloc(sizeof(struct lrkp_set_head));
560     if (lrkp_set_list == NULL)
561     {
562                 LM_ERR("no shm memory for lrkp_set_list\n");
563         return -1;
564     }
565     memset(lrkp_set_list, 0, sizeof(struct lrkp_set_head));
566
567
568     /* storing the list of lrk proxy sets in shared memory*/
569     for(i=0;i<lrkp_sets;i++){
570                 LM_DBG("Adding LRK-Proxy set %d/%d: %s\n", i, lrkp_sets, lrkp_strings[i]);
571 //        if ((lrkp_db_url.s == NULL) &&
572         if (lrkproxy_add_lrkproxy_set(lrkp_strings[i]) != 0) {
573             for(;i<lrkp_sets;i++)
574                 if(lrkp_strings[i])
575                     pkg_free(lrkp_strings[i]);
576             pkg_free(lrkp_strings);
577                     LM_ERR("Failed to add LRK-Proxy from Config!\n");
578             return -1;
579         }
580         if(lrkp_strings[i])
581             pkg_free(lrkp_strings[i]);
582     }
583
584
585     if (lrkp_strings)
586         pkg_free(lrkp_strings);
587
588
589     /* init the hastable which keeps the all media address for both party and also the elected_node <--> callid& via-branch relation */
590     if (hash_table_size < 1){
591         hash_table_size = HASH_SIZE;    //the default size 128 entry.
592     }
593
594     if (!lrkproxy_hash_table_init(hash_table_size)) {
595                 LM_ERR("lrkproxy_hash_table_init(%d) failed!\n", hash_table_size);
596         return -1;
597     } else {
598 //                LM_DBG("lrkproxy_hash_table_init(%d) success!\n", hash_table_size);
599                 LM_INFO(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>lrkproxy_hash_table_init(%d) success!\n", hash_table_size);
600     }
601
602
603
604     /* load tm module*/
605     if (load_tm_api( &tmb ) < 0)
606     {
607                 LM_DBG("could not load the TM-functions - answer-offer model"
608                                " auto-detection is disabled\n");
609         memset(&tmb, 0, sizeof(struct tm_binds));
610     }
611
612     return 0;
613 }
614
615
616 static int
617 child_init(int rank)
618 {
619     int n;
620     char *cp;
621     struct addrinfo hints, *res;
622     struct lrkp_set  *lrkp_list;
623     struct lrkp_node *pnode;
624
625     if(lrkp_set_list==NULL )
626         return 0;
627
628     /* do not init sockets for PROC_INIT and main process when fork=yes */
629     if(rank==PROC_INIT || (rank==PROC_MAIN && dont_fork==0)) {
630         return 0;
631     }
632
633     /* Iterate known LRK proxies - create sockets */
634     mypid = getpid();
635
636     lrkp_socks = (int*)pkg_malloc( sizeof(int)*lrkp_no );
637     if (lrkp_socks==NULL) {
638                 LM_ERR("no more pkg memory\n");
639         return -1;
640     }
641     memset(lrkp_socks, -1, sizeof(int)*lrkp_no);
642
643     for(lrkp_list = lrkp_set_list->lset_first; lrkp_list != 0;
644         lrkp_list = lrkp_list->lset_next){
645
646         for (pnode=lrkp_list->ln_first; pnode!=0; pnode = pnode->ln_next){
647             char *hostname;
648
649             if (pnode->ln_umode == 0) {
650                 lrkp_socks[pnode->idx] = -1;
651                 goto rptest;
652             }
653
654             /*
655              * This is UDP or UDP6. Detect host and port; lookup host;
656              * do connect() in order to specify peer address
657              */
658             hostname = (char*)pkg_malloc(sizeof(char) * (strlen(pnode->ln_address) + 1));
659             if (hostname==NULL) {
660                         LM_ERR("no more pkg memory\n");
661                 return -1;
662             }
663             strcpy(hostname, pnode->ln_address);
664
665             cp = strrchr(hostname, ':');
666             if (cp != NULL) {
667                 *cp = '\0';
668                 cp++;
669             }
670             if (cp == NULL || *cp == '\0')
671                 cp = CPORT;
672
673             memset(&hints, 0, sizeof(hints));
674             hints.ai_flags = 0;
675             hints.ai_family = (pnode->ln_umode == 6) ? AF_INET6 : AF_INET;
676             hints.ai_socktype = SOCK_DGRAM;
677             if ((n = getaddrinfo(hostname, cp, &hints, &res)) != 0) {
678                         LM_ERR("%s\n", gai_strerror(n));
679                 pkg_free(hostname);
680                 return -1;
681             }
682             pkg_free(hostname);
683
684             lrkp_socks[pnode->idx] = socket((pnode->ln_umode == 6)
685                                             ? AF_INET6 : AF_INET, SOCK_DGRAM, 0);
686             if ( lrkp_socks[pnode->idx] == -1) {
687                         LM_ERR("can't create socket\n");
688                 freeaddrinfo(res);
689                 return -1;
690             }
691
692             if (connect( lrkp_socks[pnode->idx], res->ai_addr, res->ai_addrlen) == -1) {
693                         LM_ERR("can't connect to a LRK proxy\n");
694                 close( lrkp_socks[pnode->idx] );
695                 lrkp_socks[pnode->idx] = -1;
696                 freeaddrinfo(res);
697                 return -1;
698             }
699             freeaddrinfo(res);
700 rptest:
701             pnode->ln_enable = lrkp_test(pnode);
702             if (pnode->ln_enable) {       //get lrk proxy config if it is enable.
703 //                LM_INFO("lrkp_test test is calling here\n"); //enable next line.
704                 lrkp_get_config(pnode);
705             }
706         }
707     }
708
709     return 0;
710 }
711
712
713 static void mod_destroy(void)
714 {
715     struct lrkp_set * crt_list, * last_list;
716     struct lrkp_node * crt_lrkp, *last_lrkp;
717
718     /*free the shared memory*/
719 //      if (natping_state)
720 //              shm_free(natping_state);
721
722     if(lrkp_set_list == NULL)
723         return;
724
725     for(crt_list = lrkp_set_list->lset_first; crt_list != NULL; ){
726
727         for(crt_lrkp = crt_list->ln_first; crt_lrkp != NULL;  ){
728
729             last_lrkp = crt_lrkp;
730             crt_lrkp = last_lrkp->ln_next;
731             shm_free(last_lrkp);
732         }
733
734         last_list = crt_list;
735         crt_list = last_list->lset_next;
736         shm_free(last_list);
737     }
738
739     shm_free(lrkp_set_list);
740
741     /* destroy the hash table */
742     if (!lrkproxy_hash_table_destroy()) {
743                 LM_ERR("lrkproxy_hash_table_destroy() failed!\n");
744     } else {
745                 LM_DBG("lrkproxy_hash_table_destroy() success!\n");
746     }
747
748 }
749
750
751 static char * gencookie(void)
752 {
753     static char cook[34];
754
755     sprintf(cook, "%d_%u ", (int)mypid, myseqn);
756     myseqn++;
757     return cook;
758 }
759
760 static int lrkp_test(struct lrkp_node *node)
761 {
762     int buflen = 256;
763     char buf[buflen];
764     struct iovec v[2] = {{NULL, 0}, {"P", 1}};
765
766     memset(buf, 0, buflen);
767     memcpy(buf, send_lrkp_command(node, v, 2, 0), buflen);
768
769 //    if (buf == NULL) {
770     if (!buf[0]) {
771         LM_ERR("can't ping the lrk proxy %s, Disable it right now.\n", node->ln_url.s);
772         return 0;
773     }
774
775     char *resp = buf + v[0].iov_len + v[1].iov_len + 1;
776     if (memcmp(resp, "PONG", 4) == 0)
777 //                LM_DBG("Recieve PONG response from lrk proxy server %s, Enable it right now.\n", node->ln_url.s);
778             LM_INFO("Recieve PONG response from lrk proxy server %s, Enable it right now.\n", node->ln_url.s);
779
780     return 1;
781
782 }
783
784 static int lrkp_get_config(struct lrkp_node *node){
785
786     int buflen = 256;
787     char buf[buflen];
788     struct iovec v[2] = {{NULL, 0}, {"G", 1}};
789     struct lrkp_node_conf *lnconf = NULL;
790
791     memset(buf, 0, buflen);
792     memcpy(buf, send_lrkp_command(node, v, 2, 0), buflen);
793
794 //    if (buf == NULL) {
795     if (!buf[0]) {
796         LM_ERR("can't get config of the lrk proxy %s, Disable it right now.\n", node->ln_url.s);
797         return 0;
798     }
799
800     lnconf = (struct lrkp_node_conf *)(buf + v[0].iov_len + v[1].iov_len + 1);
801
802     if (lnconf == NULL){
803         LM_ERR("can't get config of the lrk proxy %s, Disable it right now.\n", node->ln_url.s);
804         return 0;
805     }
806
807
808     memcpy(node->lrkp_n_c, lnconf, sizeof(struct lrkp_node_conf));
809
810 //    node->lrkp_n_c = lnconf;
811     LM_INFO("the lrk proxy %s is configured successfully right now.\n", node->ln_url.s);
812     LM_INFO("buffer internal:%s\n", node->lrkp_n_c->internal_ip);
813     LM_INFO("buffer external:%s\n", node->lrkp_n_c->external_ip);
814     LM_INFO("buffer start_port:%d\n", node->lrkp_n_c->start_port);
815     LM_INFO("buffer end_port:%d\n", node->lrkp_n_c->end_port);
816     LM_INFO("buffer current_port:%d\n", node->lrkp_n_c->current_port);
817
818     return 1;
819
820
821 }
822
823 static int lrkp_set_conntrack_rule(struct lrkproxy_hash_entry *e) {
824     int buflen = 254;
825     char buf[buflen];
826     int v_len = 0;
827
828     char src_ipv4[20];
829     char src_port[20];
830     char dst_ipv4[20];
831     char dst_port[20];
832     char snat_ipv4[20];
833     char snat_port[20];
834     char dnat_ipv4[20];
835     char dnat_port[20];
836     char timeout[20];
837     char callid[50];
838
839     struct iovec v[] = {
840             {NULL, 0},  /* reserved (cookie) */
841             {"S",  1},   /* command & common options */
842             {NULL, 0},  /* src_ipv4 */
843             {NULL, 0},  /* dst_ipnv4 */
844             {NULL, 0},  /* snat_ipv4 */
845             {NULL, 0},  /* dnat_ipv4 */
846             {NULL, 0},  /* src_port */
847             {NULL, 0},  /* dst_port*/
848             {NULL, 0},  /* snat_port */
849             {NULL, 0},  /* dnat_port*/
850             {NULL, 0},  /* timeout to clear conntrack entry*/
851             {NULL, 0},  /* callid of session */
852     };
853
854     v_len += v[1].iov_len;
855
856     //set src_ipv4 to buffer.
857     sprintf(src_ipv4, " %.*s ", e->src_ipv4.len, e->src_ipv4.s);
858     v[2].iov_base = src_ipv4;
859     v[2].iov_len = strlen(v[2].iov_base);
860     v_len += v[2].iov_len;
861
862     //set dst_ipv4 to buffer.
863     sprintf(dst_ipv4, "%.*s ", e->dst_ipv4.len, e->dst_ipv4.s);
864     v[3].iov_base = dst_ipv4;
865     v[3].iov_len = strlen(v[3].iov_base);
866     v_len += v[3].iov_len;
867
868     //set snat_ipv4 to buffer.
869     sprintf(snat_ipv4, "%.*s ", e->snat_ipv4.len, e->snat_ipv4.s);
870     v[4].iov_base = snat_ipv4;
871     v[4].iov_len = strlen(v[4].iov_base);
872     v_len += v[4].iov_len;
873
874     //set dnat_ipv4 to buffer.
875     sprintf(dnat_ipv4, "%.*s ", e->dnat_ipv4.len, e->dnat_ipv4.s);
876     v[5].iov_base = dnat_ipv4;
877     v[5].iov_len = strlen(v[5].iov_base);
878     v_len += v[5].iov_len;
879
880     //set src_port to buffer.
881     sprintf(src_port, "%.*s ", e->src_port.len, e->src_port.s);
882     v[6].iov_base = src_port;
883     v[6].iov_len = strlen(v[6].iov_base);
884     v_len += v[6].iov_len;
885
886     //set dst_port to buffer.
887     sprintf(dst_port, "%.*s ", e->dst_port.len, e->dst_port.s);
888     v[7].iov_base = dst_port;
889     v[7].iov_len = strlen(v[7].iov_base);
890     v_len += v[7].iov_len;
891
892     //set snat_port to buffer.
893     sprintf(snat_port, "%.*s ", e->snat_port.len, e->snat_port.s);
894     v[8].iov_base = snat_port;
895     v[8].iov_len = strlen(v[8].iov_base);
896     v_len += v[8].iov_len;
897
898     //set dnat_port to buffer.
899     sprintf(dnat_port, "%.*s ", e->dnat_port.len, e->dnat_port.s);
900     v[9].iov_base = dnat_port;
901     v[9].iov_len = strlen(v[9].iov_base);
902     v_len += v[9].iov_len;
903
904     //set timeout to buffer. Set to 60 sec for default.
905     sprintf(timeout, "%d ", 60);
906     v[10].iov_base = timeout;
907     v[10].iov_len = strlen(v[10].iov_base);
908     v_len += v[10].iov_len;
909
910     //set callid to buffer.
911     sprintf(callid, "%.*s ", e->callid.len, e->callid.s);
912     v[11].iov_base = callid;
913     v[11].iov_len = strlen(v[11].iov_base);
914     v_len += v[11].iov_len;
915 //    LM_ERR("e->callid.len is:%d right now.\n\n", e->callid.len);
916
917     memset(buf, 0, buflen);
918     memcpy(buf, send_lrkp_command(e->node, v, 12, v_len), buflen);
919 //
920
921 //    if (buf == NULL) {
922     if (!buf[0]) {
923                 LM_ERR("can't ping the lrk proxy %s, Disable it right now.\n", e->node->ln_url.s);
924         return 0;
925     }
926
927     v_len += v[0].iov_len;
928
929
930 //    char *resp = buf + v[0].iov_len + v[1].iov_len + v[2].iov_len;
931     char *resp = buf + v_len;
932     if (memcmp(resp, "OK", 2) == 0) {
933                 LM_INFO("Recieve OK response from lrk proxy server %s, Rule set successfully.\n", e->node->ln_url.s);
934                 LM_DBG("Recieve OK response from lrk proxy server %s, Rule set successfully.\n", e->node->ln_url.s);
935     }
936     return 1;
937
938 }
939
940
941 char *send_lrkp_command(struct lrkp_node *node, struct iovec *v, int vcnt, int more)
942 {
943     struct sockaddr_un addr;
944     int fd, len, i;
945     int ret;
946 //    char *cp;
947     static char buf[256];
948     struct pollfd fds[1];
949
950     memset(buf, 0, 256);
951     len = 0;
952 //    cp = buf;
953     if (node->ln_umode == 0) {
954         memset(&addr, 0, sizeof(addr));
955         addr.sun_family = AF_LOCAL;
956         strncpy(addr.sun_path, node->ln_address,
957                 sizeof(addr.sun_path) - 1);
958 #ifdef HAVE_SOCKADDR_SA_LEN
959         addr.sun_len = strlen(addr.sun_path);
960 #endif
961
962         fd = socket(AF_LOCAL, SOCK_STREAM, 0);
963         if (fd < 0) {
964                     LM_ERR("can't create socket\n");
965             goto badproxy;
966         }
967         if (connect(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
968             close(fd);
969                     LM_ERR("can't connect to lrk proxy\n");
970             goto badproxy;
971         }
972
973         do {
974             len = writev(fd, v + 1, vcnt - 1);
975         } while (len == -1 && errno == EINTR);
976         if (len <= 0) {
977             close(fd);
978                     LM_ERR("can't send command to a lrk proxy %s\n", node->ln_url.s);
979             goto badproxy;
980         }
981         do {
982             len = read(fd, buf, sizeof(buf) - 1);
983         } while (len == -1 && errno == EINTR);
984         close(fd);
985         if (len <= 0) {
986                     LM_ERR("can't read reply from a lrk proxy %s\n", node->ln_url.s);
987             goto badproxy;
988         }
989     } else {
990         fds[0].fd = lrkp_socks[node->idx];
991         fds[0].events = POLLIN;
992         fds[0].revents = 0;
993         /* Drain input buffer */
994         ret = -1;
995         while ((poll(fds, 1, 0) == 1) &&
996                ((fds[0].revents & POLLIN) != 0) && ret != 0) {
997             ret = recv(lrkp_socks[node->idx], buf, sizeof(buf) - 1, 0);
998             fds[0].revents = 0;
999         }
1000         v[0].iov_base = gencookie();
1001         v[0].iov_len = strlen(v[0].iov_base);
1002         for (i = 0; i < lrkproxy_retr; i++) {
1003             do {
1004                 len = writev(lrkp_socks[node->idx], v, vcnt);
1005             } while (len == -1 && (errno == EINTR || errno == ENOBUFS));
1006             if (len <= 0) {
1007                         LM_ERR("can't send command to a lrk proxy %s\n", node->ln_url.s);
1008                 goto badproxy;
1009             }
1010             while ((poll(fds, 1, lrkproxy_tout * 1000) == 1) &&
1011                    (fds[0].revents & POLLIN) != 0) {
1012                 do {
1013                     len = recv(lrkp_socks[node->idx], buf, sizeof(buf) - 1, 0);
1014                 } while (len == -1 && errno == EINTR);
1015                 if (len <= 0) {
1016                             LM_ERR("can't read reply from a lrk proxy %s\n", node->ln_url.s);
1017                     goto badproxy;
1018                 }
1019                 if (len >= (v[0].iov_len - 1) &&
1020                     memcmp(buf, v[0].iov_base, (v[0].iov_len - 1)) == 0) {      //check coocke validation.
1021                     char *command = buf + v[0].iov_len;
1022                     switch (*command) {
1023                         case 'P':
1024                             if (len == v[0].iov_len + v[1].iov_len + 4 + 1)
1025                                 goto out;
1026 //                            break;
1027                         case 'G':
1028                             if (len == v[0].iov_len + v[1].iov_len + sizeof(struct lrkp_node_conf) + 1)
1029                                 goto out;
1030 //                            break;
1031                         case 'S':
1032                             if (len == more + v[0].iov_len + 2)
1033                                 goto out;
1034 //                            break;
1035                     }
1036
1037                 }
1038                 fds[0].revents = 0;
1039             }
1040         }
1041         if (i == lrkproxy_tout) {
1042                     LM_ERR("timeout waiting reply from a lrk proxy server %s\n", node->ln_url.s);
1043             goto badproxy;
1044
1045         }
1046     }
1047     out:
1048     return buf;
1049     badproxy:
1050             LM_ERR("lrk proxy <%s> does not respond, disable it\n", node->ln_url.s);
1051     node->ln_enable = 0;
1052 //    node->ln_recheck_ticks = get_ticks() + lrkproxy_disable_tout;
1053     return buf;
1054 }
1055
1056 /*
1057  * select the set with the id_set id
1058  */
1059 static struct lrkp_set * select_lrkp_set(int id_set ){
1060
1061     struct lrkp_set * lrkp_list;
1062     /*is it a valid set_id?*/
1063
1064     if(!lrkp_set_list)
1065     {
1066                 LM_ERR("lrkproxy set list not initialised\n");
1067         return NULL;
1068     }
1069
1070     for(lrkp_list=lrkp_set_list->lset_first; lrkp_list!=NULL &&
1071                                              lrkp_list->id_set!=id_set; lrkp_list=lrkp_list->lset_next);
1072
1073     return lrkp_list;
1074 }
1075
1076
1077 struct lrkp_node *select_lrkp_node(int do_test)
1078 {
1079     struct lrkp_node* node;
1080     int was_forced;
1081     int was_forced2;
1082
1083     if(!selected_lrkp_set){
1084         LM_ERR("script error -no valid set selected\n");
1085         return NULL;
1086     }
1087     /* Most popular case: 1 proxy, nothing to calculate */
1088     if (selected_lrkp_set->lrkp_node_count == 1) {
1089         node = selected_lrkp_set->ln_first;
1090 //        if (node->rn_disabled && node->rn_recheck_ticks <= get_ticks())
1091         if (!node->ln_enable) {
1092             node->ln_enable = lrkp_test(node);
1093             if (node->ln_enable) {       //get lrk proxy config if it is enable.
1094                 lrkp_get_config(node);
1095                 return node;
1096             }
1097         }
1098         return node->ln_enable ? node : NULL;
1099 //        return NULL;
1100     }
1101
1102
1103     /* Check node is enable and test it again*/
1104 retry:
1105     for (node=selected_lrkp_set->ln_first; node!=NULL; node=node->ln_next) {
1106
1107         if (!node->ln_enable) {
1108             /* Try to enable if it's time to try. */
1109             node->ln_enable = lrkp_test(node);
1110             if (node->ln_enable)       //get lrk proxy config if it is enable.
1111                 lrkp_get_config(node);
1112         }
1113     }
1114
1115     if (lrkp_algorithm == LRK_LINER) {
1116         was_forced = 0;
1117         retry2:
1118         for (node = selected_lrkp_set->ln_first; node != NULL; node = node->ln_next)
1119             if (node->ln_enable)
1120                 goto found;
1121         if (was_forced)
1122             return NULL;
1123
1124         was_forced = 1;
1125         //trying to enable all lrkproxy and check again.
1126         for (node = selected_lrkp_set->ln_first; node != NULL; node = node->ln_next) {
1127             /* Try to enable if it's time to try. */
1128             node->ln_enable = lrkp_test(node);
1129             if (node->ln_enable)       //get lrk proxy config if it is enable.
1130                 lrkp_get_config(node);
1131         }
1132
1133
1134         goto retry2;
1135     }
1136     else if(lrkp_algorithm == LRK_RR) {
1137         was_forced2 = 0;
1138 retry3:
1139         if (!selected_lrkp_node) {
1140             selected_lrkp_node = selected_lrkp_set->ln_first;
1141             node = selected_lrkp_set->ln_first;
1142             if(node->ln_enable)
1143                     goto found;
1144 //            was_forced2 = 1;
1145         }
1146         for (node = selected_lrkp_node->ln_next; node != NULL; node = node->ln_next)
1147 //        for (node = selected_lrkp_node; node != NULL; node = node->ln_next) {
1148             if (node->ln_enable) {
1149                 selected_lrkp_node = node;
1150                 goto found;
1151             }
1152 //            selected_lrkp_node = node->ln_next;
1153 //        if (sumcut < node->ln_weight)
1154 //        sumcut -= node->ln_weight;
1155
1156         if (was_forced2)
1157             return NULL;
1158
1159         was_forced2 = 1;
1160         selected_lrkp_node = NULL;
1161
1162         goto retry3;
1163     }
1164
1165     found:
1166     if (do_test) {
1167 //    //todo...
1168         node->ln_enable = lrkp_test(node);
1169         if (!node->ln_enable)
1170             goto retry;
1171     }
1172     return node;
1173 }
1174
1175 //static int change_media_sdp(sip_msg_t *msg, struct lrkp_node *n, const char *flags, int type) {
1176 static int change_media_sdp(sip_msg_t *msg, struct lrkproxy_hash_entry *e, const char *flags, enum lrk_operation op) {
1177     struct lump *l;
1178     str body;
1179     str newbody;
1180
1181     int len;
1182     char *start_sdp_o = NULL; //"o=";
1183     char *start_sdp_s = NULL; //"s=";
1184     char *start_sdp_c = NULL; //"c=IN IP4";
1185     char *start_sdp_m = NULL; //"m=audio";
1186     char *ip_selected = NULL;
1187     char *sdp_param_start = NULL;
1188     char *sdp_param_end = NULL;
1189     char *off=NULL;
1190     char sdp_new_o[128];
1191     char sdp_new_s[128];
1192     char sdp_new_c[128];
1193     char sdp_new_m[128];
1194
1195     body.s = get_body(msg);
1196     if (body.s == 0) {
1197                 LM_ERR("failed to get the message body\n");
1198         return -1;
1199     }
1200
1201     body.len = msg->len - (int) (body.s - msg->buf);
1202     if (body.len == 0) {
1203                 LM_DBG("message body has zero length\n");
1204         return -1;
1205     }
1206 //            LM_INFO("body:<%.*s>\n", body.len, body.s);
1207
1208     //allocate new buffer to new sdp buffer.
1209     newbody.len = 1024;
1210     newbody.s = pkg_malloc(newbody.len);
1211     if (newbody.s == NULL) {
1212                 LM_ERR("out of pkg memory\n");
1213         return -1;
1214     }
1215     memset(newbody.s, 0, 1024);
1216
1217     off = body.s;
1218     start_sdp_o = strstr(off, "o=");
1219     start_sdp_s = strstr(off, "s=");
1220     start_sdp_c = strstr(off, "c=IN IP4");
1221     start_sdp_m = strstr(off, "m=audio");
1222
1223     //The external_ip should be set in config file for relaying RTP media between NIC.
1224 //    if (e->node->lrkp_n_c->external_ip && flags) {
1225     if(flags) {
1226         if (strstr(flags, "ei")) {
1227             ip_selected = e->node->lrkp_n_c->internal_ip;// lrk_node->internal_ip;
1228         } else if (strstr(flags, "ie")) {
1229             ip_selected = e->node->lrkp_n_c->external_ip; //lrk_node->external_ip;
1230         } else {
1231             LM_INFO("unknown flags, use internal_ip\n");
1232             ip_selected = e->node->lrkp_n_c->internal_ip;
1233         }
1234     }
1235     else {
1236         LM_INFO("no flags set, use internal_ip\n");
1237         ip_selected = e->node->lrkp_n_c->internal_ip;
1238     }
1239
1240     if (op == OP_OFFER) {
1241         e->dst_ipv4.s = ip_selected;
1242         e->dst_ipv4.len = strlen(e->dst_ipv4.s);
1243
1244         str current_port;
1245         current_port.s = int2str(e->node->lrkp_n_c->current_port, &current_port.len);
1246
1247         if (shm_str_dup(&e->dst_port, &current_port) < 0) {
1248                     LM_ERR("lrkproxy fail to insert dst_port, calllen=%d dst_port=%.*s\n",
1249                            e->callid.len, current_port.len, current_port.s);
1250             lrkproxy_hash_table_free_entry(e);
1251             return 0;
1252         }
1253
1254 //        e->dst_port = e->node->lrkp_n_c->current_port;
1255     }
1256     else if (op == OP_ANSWER){
1257         e->snat_ipv4.s = ip_selected;
1258         e->snat_ipv4.len = strlen(e->snat_ipv4.s);
1259
1260         str current_port;
1261         unsigned int snat_port;
1262
1263         str2int(&e->dst_port, &snat_port);
1264         snat_port += 2;
1265
1266         current_port.s = int2str(snat_port, &current_port.len);
1267
1268         if (shm_str_dup(&e->snat_port, &current_port) < 0) {
1269                     LM_ERR("lrkproxy fail to insert snat_port, calllen=%d snat_port=%.*s\n",
1270                            e->callid.len, current_port.len, current_port.s);
1271             lrkproxy_hash_table_free_entry(e);
1272             return 0;
1273         }
1274
1275 //        e->snat_port = e->dst_port + 2;
1276     }
1277
1278
1279     while (*off != EOB)    //while end of body.
1280     {
1281         sdp_param_start = off;
1282         sdp_param_end = sdp_param_start;
1283         while (*sdp_param_end != CR && *sdp_param_end != LF && *sdp_param_end != EOB) sdp_param_end++;
1284         len = (int) (sdp_param_end - sdp_param_start);
1285         if ((int) (start_sdp_o - off) == 0) {
1286             memset(sdp_new_o, 0, 128);
1287             snprintf(sdp_new_o, 128, "o=lrkproxy %s %s IN IP4 %s\r", SUP_CPROTOVER, REQ_CPROTOVER, ip_selected);
1288             strncat(newbody.s, sdp_new_o, strlen(sdp_new_o));
1289             off += len + 1;
1290             continue;
1291         }
1292         if ((int) (start_sdp_s - off) == 0) {
1293             memset(sdp_new_s, 0, 128);
1294             snprintf(sdp_new_s, 128, "s=lrkproxy Support only Audio Call\r");
1295             strncat(newbody.s, sdp_new_s, strlen(sdp_new_s));
1296             off += len + 1;
1297             continue;
1298         }
1299         if ((int) (start_sdp_c - off) == 0) {
1300             memset(sdp_new_c, 0, 128);
1301             snprintf(sdp_new_c, 128, "c=IN IP4 %s\r", ip_selected);
1302             strncat(newbody.s, sdp_new_c, strlen(sdp_new_c));
1303             off += len + 1;
1304             continue;
1305         }
1306         if ((int)(start_sdp_m - off) == 0){
1307             memset(sdp_new_m, 0, 128);
1308             char *avp_flags = off;
1309 //            int occure = 0;
1310             for (;*avp_flags && !isspace(*avp_flags); avp_flags++);
1311             for (avp_flags++;*avp_flags && !isspace(*avp_flags); avp_flags++);
1312             avp_flags++;
1313             if (op == OP_OFFER)
1314                 snprintf(sdp_new_m, 128, "m=audio %.*s %.*s\r",e->dst_port.len, e->dst_port.s, (int)(len - (avp_flags-off)), avp_flags);
1315 //                snprintf(sdp_new_m, 128, "m=audio %d %.*s\r",e->node->lrkp_n_c->current_port, (int)(len - (avp_flags-off)), avp_flags);
1316             else if (op == OP_ANSWER)
1317                 snprintf(sdp_new_m, 128, "m=audio %.*s %.*s\r",e->snat_port.len, e->snat_port.s, (int)(len - (avp_flags-off)), avp_flags);
1318 //               snprintf(sdp_new_m, 128, "m=audio %d %.*s\r",e->node->lrkp_n_c->current_port, (int)(len - (avp_flags-off)), avp_flags);
1319 //            printf("%.*s\n\n", len - (avp_flags-off), avp_flags);
1320             strncat(newbody.s,sdp_new_m, strlen(sdp_new_m));
1321             off += len+1;
1322             continue;
1323         }
1324
1325         strncat(newbody.s, off, len + 1);
1326         off += len + 1;
1327     }
1328
1329
1330 //    LM_INFO("%.*s", (int)strlen(newbody.s), newbody.s);
1331     l = del_lump(msg, body.s - msg->buf, body.len, 0);
1332     if (!l) {
1333                 LM_ERR("del_lump failed\n");
1334         return -1;
1335     }
1336
1337
1338     if (insert_new_lump_after(l, newbody.s, strlen(newbody.s), 0) == 0) {
1339                 LM_ERR("could not insert new lump\n");
1340         pkg_free(newbody.s);
1341         return -1;
1342     }
1343
1344             LM_BUG("Insert_new_lump successfully\n");
1345
1346     return 1;
1347 }
1348
1349 /* This function assumes p points to a line of requested type. */
1350
1351         static int
1352 set_lrkproxy_set_f(struct sip_msg * msg, char * str1, char * str2)
1353 {
1354         lrkp_set_link_t *lrkl;
1355         pv_value_t val;
1356
1357         lrkl = (lrkp_set_link_t*)str1;
1358
1359         current_msg_id = 0;
1360         selected_lrkp_set = 0;
1361
1362         if(lrkl->rset != NULL) {
1363                 current_msg_id = msg->id;
1364                 selected_lrkp_set = lrkl->rset;
1365         } else {
1366                 if(pv_get_spec_value(msg, lrkl->rpv, &val)<0) {
1367                         LM_ERR("cannot evaluate pv param\n");
1368                         return -1;
1369                 }
1370                 if(!(val.flags & PV_VAL_INT)) {
1371                         LM_ERR("pv param must hold an integer value\n");
1372                         return -1;
1373                 }
1374                 selected_lrkp_set = select_lrkp_set(val.ri);
1375                 if(selected_lrkp_set==NULL) {
1376                         LM_ERR("could not locate lrkproxy set %d\n", val.ri);
1377                         return -1;
1378                 }
1379                 current_msg_id = msg->id;
1380         }
1381         return 1;
1382 }
1383
1384 static int
1385 lrkproxy_manage(struct sip_msg *msg, char *flags, char *ip)
1386 {
1387     int method;
1388     int nosdp;
1389     tm_cell_t *t = NULL;
1390
1391     if (msg->cseq==NULL && ((parse_headers(msg, HDR_CSEQ_F, 0)==-1) ||
1392                             (msg->cseq==NULL)))
1393     {
1394                 LM_ERR("no CSEQ header\n");
1395         return -1;
1396     }
1397
1398     method = get_cseq(msg)->method_id;
1399
1400     if (!(method==METHOD_INVITE || method==METHOD_ACK || method==METHOD_CANCEL
1401           || method==METHOD_BYE || method==METHOD_UPDATE))
1402         return -1;
1403
1404     if (method==METHOD_CANCEL || method==METHOD_BYE)
1405         return lrkproxy_unforce(msg, flags, OP_DELETE, 1);
1406
1407     if (msg->msg_flags & FL_SDP_BODY)
1408         nosdp = 0;
1409     else
1410         nosdp = parse_sdp(msg);
1411
1412     if (msg->first_line.type == SIP_REQUEST) {
1413         if(method==METHOD_ACK && nosdp==0)
1414             return lrkproxy_force(msg, flags, OP_ANSWER, 1);
1415         if(method==METHOD_UPDATE && nosdp==0)
1416             return lrkproxy_force(msg, flags, OP_OFFER, 1);
1417         if(method==METHOD_INVITE && nosdp==0) {
1418             msg->msg_flags |= FL_SDP_BODY;
1419             if(tmb.t_gett!=NULL) {
1420                 t = tmb.t_gett();
1421                 if(t!=NULL && t!=T_UNDEFINED && t->uas.request!=NULL) {
1422                     t->uas.request->msg_flags |= FL_SDP_BODY;
1423                 }
1424             }
1425             if(route_type==FAILURE_ROUTE)
1426                 return lrkproxy_unforce(msg, flags, OP_DELETE, 1);
1427             return lrkproxy_force(msg, flags, OP_OFFER, 1);
1428         }
1429     } else if (msg->first_line.type == SIP_REPLY) {
1430         if (msg->first_line.u.reply.statuscode>=300)
1431             return lrkproxy_unforce(msg, flags, OP_DELETE, 2);
1432         if (nosdp==0) {
1433             if (method==METHOD_UPDATE)
1434                 return lrkproxy_force(msg, flags, OP_ANSWER, 2);
1435             if (tmb.t_gett==NULL || tmb.t_gett()==NULL
1436                 || tmb.t_gett()==T_UNDEFINED)
1437                 return lrkproxy_force(msg, flags, OP_ANSWER, 2);
1438             if (tmb.t_gett()->uas.request->msg_flags & FL_SDP_BODY)
1439                 return lrkproxy_force(msg, flags, OP_ANSWER, 2);
1440             return lrkproxy_force(msg, flags, OP_OFFER, 2);
1441         }
1442     }
1443
1444     return -1;
1445 }
1446
1447 static int
1448 lrkproxy_manage0(struct sip_msg *msg, char *flags, char *ip)
1449 {
1450     return lrkproxy_manage(msg, 0, 0);
1451 }
1452
1453 static int
1454 lrkproxy_manage1(struct sip_msg *msg, char *flags, char *ip)
1455 {
1456     str flag_str;
1457     if(fixup_get_svalue(msg, (gparam_p)flags, &flag_str)<0)
1458     {
1459                 LM_ERR("invalid flags parameter\n");
1460         return -1;
1461     }
1462     return lrkproxy_manage(msg, flag_str.s, 0);
1463 }
1464
1465 static int
1466 lrkproxy_manage2(struct sip_msg *msg, char *flags, char *ip)
1467 {
1468     str flag_str;
1469     str ip_str;
1470     if(fixup_get_svalue(msg, (gparam_p)flags, &flag_str)<0)
1471     {
1472                 LM_ERR("invalid flags parameter\n");
1473         return -1;
1474     }
1475     if(fixup_get_svalue(msg, (gparam_p)ip, &ip_str)<0)
1476     {
1477                 LM_ERR("invalid IP parameter\n");
1478         return -1;
1479     }
1480     return lrkproxy_manage(msg, flag_str.s, ip_str.s);
1481 }
1482
1483
1484 static int lrkproxy_force(struct sip_msg *msg, const char *flags, enum lrk_operation op, int more) {
1485
1486 //    lrk_sdp_info_t lrk_sdp_info;
1487     struct lrkproxy_hash_entry *entry = NULL;
1488     str viabranch = STR_NULL;
1489     str call_id;
1490     int via_id;
1491
1492     if (get_callid(msg, &call_id) == -1) {
1493                 LM_ERR("can't get Call-Id field\n");
1494         return -1;
1495     }
1496
1497     /*We have to choice VIA id,
1498      * for SIP_REQUEST we use VIA1 and for SIP_REPLY we use VIA2 */
1499     via_id = more;
1500
1501     if (get_via_branch(msg, via_id, &viabranch) == -1) {
1502                 LM_ERR("can't get Call-Id field\n");
1503         return -1;
1504     }
1505
1506     if (op == OP_OFFER) {
1507                 LM_INFO ("Here is SIP_REQUEST &  METHOD_INVITE\n");
1508         int more_test = 1;
1509
1510         //select new node based on lrkp_algorithm param.
1511         struct lrkp_node *node = select_lrkp_node(more_test);
1512         if (!node) {
1513                     LM_ERR("can't ping any lrk proxy right now.\n");
1514             return -1;
1515         }
1516
1517                 LM_DBG("selected lrk proxy node: %s\n", node->ln_url.s);
1518
1519         //check if entry not exist.
1520         entry = lrkproxy_hash_table_lookup(call_id, viabranch);
1521         if (entry)
1522             return -1;
1523
1524 //        lrk_get_sdp_info(msg, &lrk_sdp_info);
1525
1526         //build new entry for hash table.
1527 //            struct lrkproxy_hash_entry *entry = shm_malloc(sizeof(struct lrkproxy_hash_entry));
1528         entry = shm_malloc(sizeof(struct lrkproxy_hash_entry));
1529         if (!entry) {
1530                     LM_ERR("lrkproxy hash table fail to create entry for calllen=%d callid=%.*s viabranch=%.*s\n",
1531                            call_id.len, call_id.len, call_id.s,
1532                            viabranch.len, viabranch.s);
1533             return 0;
1534         }
1535         memset(entry, 0, sizeof(struct lrkproxy_hash_entry));
1536
1537         // fill the entry
1538         if (call_id.s && call_id.len > 0) {
1539             if (shm_str_dup(&entry->callid, &call_id) < 0) {
1540                         LM_ERR("lrkproxy hash table fail to instert call_id, calllen=%d callid=%.*s\n",
1541                                call_id.len, call_id.len, call_id.s);
1542                 lrkproxy_hash_table_free_entry(entry);
1543                 return 0;
1544             }
1545         }
1546
1547         if (viabranch.s && viabranch.len > 0) {
1548             if (shm_str_dup(&entry->viabranch, &viabranch) < 0) {
1549                         LM_ERR("lrkproxy hash table fail to insert viabranch, calllen=%d viabranch=%.*s\n",
1550                                call_id.len, viabranch.len, viabranch.s);
1551                 lrkproxy_hash_table_free_entry(entry);
1552                 return 0;
1553             }
1554         }
1555
1556         //fill src_ipv4 and src_port for entry.
1557         str src_ipv4;
1558         if (get_sdp_ipaddr_media(msg, &src_ipv4) == -1) {
1559                     LM_ERR("can't get media src_ipv4 from sdp field\n");
1560             return -1;
1561         }
1562
1563         if (src_ipv4.s && src_ipv4.len > 0) {
1564                     LM_DBG("src_ipv4 from sdp:%.*s\n", src_ipv4.len, src_ipv4.s);
1565             if (shm_str_dup(&entry->src_ipv4, &src_ipv4) < 0) {
1566                         LM_ERR("lrkproxy hash table fail to insert src_ipv4, calllen=%d src_ipv4=%.*s\n",
1567                                call_id.len, src_ipv4.len, src_ipv4.s);
1568                 lrkproxy_hash_table_free_entry(entry);
1569                 return 0;
1570             }
1571         }
1572
1573         str src_port;
1574         if (get_sdp_port_media(msg, &src_port) == -1) {
1575                     LM_ERR("can't get media src_port from sdp field\n");
1576             return -1;
1577         }
1578
1579
1580         if (src_port.s && src_port.len > 0) {
1581                     LM_DBG("src_port from sdp:%.*s\n", src_port.len, src_port.s);
1582             if (shm_str_dup(&entry->src_port, &src_port) < 0) {
1583                         LM_ERR("lrkproxy hash table fail to insert src_port, calllen=%d src_port=%.*s\n",
1584                                call_id.len, src_port.len, src_port.s);
1585                 lrkproxy_hash_table_free_entry(entry);
1586                 return 0;
1587             }
1588         }
1589
1590 //            entry->
1591         entry->node = node;
1592         entry->next = NULL;
1593         entry->tout = get_ticks() + hash_table_tout;
1594
1595         // insert the key<->entry from the hashtable
1596         if (!lrkproxy_hash_table_insert(call_id, viabranch, entry)) {
1597                     LM_ERR(
1598                     "lrkproxy hash table fail to insert node=%.*s for calllen=%d callid=%.*s viabranch=%.*s\n",
1599                     node->ln_url.len, node->ln_url.s, call_id.len,
1600                     call_id.len, call_id.s, viabranch.len, viabranch.s);
1601             lrkproxy_hash_table_free_entry(entry);
1602             return 0;
1603         } else {
1604                     LM_INFO("lrkproxy hash table insert node=%.*s for calllen=%d callid=%.*s viabranch=%.*s\n",
1605                             node->ln_url.len, node->ln_url.s, call_id.len,
1606                             call_id.len, call_id.s, viabranch.len, viabranch.s);
1607
1608                     LM_DBG("lrkproxy hash table insert node=%.*s for calllen=%d callid=%.*s viabranch=%.*s\n",
1609                            node->ln_url.len, node->ln_url.s, call_id.len,
1610                            call_id.len, call_id.s, viabranch.len, viabranch.s);
1611         }
1612
1613
1614         if (flags)
1615             change_media_sdp(msg, entry, flags, op);
1616         else
1617             change_media_sdp(msg, entry, NULL, op);
1618
1619         if (node->lrkp_n_c->current_port >= node->lrkp_n_c->end_port)
1620             node->lrkp_n_c->current_port = node->lrkp_n_c->start_port;
1621         else
1622             node->lrkp_n_c->current_port += 4;
1623
1624     } else if (op == OP_ANSWER) {
1625                 LM_INFO ("Here is SIP_REPLY of METHOD_INVITE\n");
1626
1627
1628         entry = lrkproxy_hash_table_lookup(call_id, viabranch);
1629         if (!entry){
1630                     LM_ERR("No found entry in hash table\n");
1631                     //todo...
1632             return 0;
1633         }
1634
1635         //fill other data for entry
1636         str dnat_ipv4;
1637         if (get_sdp_ipaddr_media(msg, &dnat_ipv4) == -1) {
1638                     LM_ERR("can't get media dnat_ipv4 from sdp field\n");
1639             return -1;
1640         }
1641
1642         if(dnat_ipv4.s && dnat_ipv4.len > 0) {
1643                     LM_DBG("dnat_ipv4 from sdp:%.*s\n", dnat_ipv4.len, dnat_ipv4.s);
1644             if (shm_str_dup(&entry->dnat_ipv4, &dnat_ipv4) < 0) {
1645                         LM_ERR("lrkproxy hash table fail to insert dnat_ipv4, calllen=%d dnat_ipv4=%.*s\n",
1646                                call_id.len, dnat_ipv4.len, dnat_ipv4.s);
1647                 lrkproxy_hash_table_free_entry(entry);
1648                 return 0;
1649             }
1650         }
1651
1652         str dnat_port;
1653         if (get_sdp_port_media(msg, &dnat_port) == -1) {
1654                     LM_ERR("can't get media port from sdp field\n");
1655             return -1;
1656         }
1657
1658
1659         if(dnat_port.s && dnat_port.len > 0) {
1660                     LM_DBG("port from sdp:%.*s\n", dnat_port.len, dnat_port.s);
1661             if (shm_str_dup(&entry->dnat_port, &dnat_port) < 0) {
1662                         LM_ERR("lrkproxy hash table fail to insert dnat_port, calllen=%d dnat_port=%.*s\n",
1663                                call_id.len, dnat_port.len, dnat_port.s);
1664                 lrkproxy_hash_table_free_entry(entry);
1665                 return 0;
1666             }
1667         }
1668
1669
1670         if (flags)
1671             change_media_sdp(msg, entry, flags, op);
1672         else
1673             change_media_sdp(msg, entry, NULL, op);
1674
1675
1676         LM_INFO("selected node: %s\n",entry->node->ln_url.s);
1677         LM_INFO("call_is: %.*s\n",entry->callid.len, entry->callid.s);
1678         LM_INFO("viabranch: %.*s\n",entry->viabranch.len, entry->viabranch.s);
1679         LM_INFO("src_ipv4: %.*s\n",entry->src_ipv4.len, entry->src_ipv4.s);
1680         LM_INFO("src_port: %.*s\n",entry->src_port.len, entry->src_port.s);
1681         LM_INFO("dst_ipv4: %.*s\n",entry->dst_ipv4.len, entry->dst_ipv4.s);
1682         LM_INFO("dst_port: %.*s\n",entry->dst_port.len, entry->dst_port.s);
1683
1684         LM_INFO("dnat_ipv4: %.*s\n",entry->dnat_ipv4.len, entry->dnat_ipv4.s);
1685         LM_INFO("dnat_port: %.*s\n",entry->dnat_port.len, entry->dnat_port.s);
1686         LM_INFO("snat_ipv4: %.*s\n",entry->snat_ipv4.len, entry->snat_ipv4.s);
1687         LM_INFO("snat_port: %.*s\n",entry->snat_port.len, entry->snat_port.s);
1688
1689
1690         lrkp_set_conntrack_rule(entry);
1691
1692     }
1693     return 1;
1694 }
1695
1696 static int lrkproxy_unforce(struct sip_msg *msg, const char *flags, enum lrk_operation op, int more){
1697 //            LM_INFO ("Here is lrkproxy_unforce\n");
1698 //    struct lrkproxy_hash_entry *entry = NULL;
1699     str viabranch = STR_NULL;
1700     str call_id;
1701     int via_id;
1702
1703     if (get_callid(msg, &call_id) == -1) {
1704                 LM_ERR("can't get Call-Id field\n");
1705         return -1;
1706     }
1707
1708     /*We have to choice VIA id,
1709      * for SIP_REQUEST we use VIA1 and for SIP_REPLY we use VIA2 */
1710     via_id = more;
1711
1712     if (get_via_branch(msg, via_id, &viabranch) == -1) {
1713                 LM_ERR("can't get Call-Id field\n");
1714         return -1;
1715     }
1716
1717     if (op == OP_DELETE) {
1718         /* Delete the key<->value from the hashtable */
1719         if (!lrkproxy_hash_table_remove(call_id, viabranch, op)) {
1720                     LM_ERR("lrkproxy hash table failed to remove entry for callen=%d callid=%.*s viabranch=%.*s\n",
1721                            call_id.len, call_id.len, call_id.s,
1722                            viabranch.len, viabranch.s);
1723         } else {
1724                     LM_DBG("lrkproxy hash table remove entry for callen=%d callid=%.*s viabranch=%.*s\n",
1725                            call_id.len, call_id.len, call_id.s,
1726                            viabranch.len, viabranch.s);
1727         }
1728     }
1729     LM_INFO("lrkproxy hash table remove entry for callen=%d callid=%.*s viabranch=%.*s successfully\n",
1730             call_id.len, call_id.len, call_id.s,
1731             viabranch.len, viabranch.s);
1732     return 1;
1733 }