all: updated FSF address in GPL text
[sip-router] / modules / nat_traversal / nat_traversal.c
1 /* $Id$
2  *
3  * Copyright (C) 2007-2009 Dan Pascu
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 <stdio.h>
24 #include <stdlib.h>
25 #include <unistd.h>
26 #include <string.h>
27 #include <ctype.h>
28 #include <errno.h>
29 #include <time.h>
30 #include <sys/types.h>
31 #include <arpa/inet.h>
32
33 #include "../../sr_module.h"
34 #include "../../mem/shm_mem.h"
35 #include "../../mem/mem.h"
36 #include "../../lock_ops.h"
37 #include "../../dprint.h"
38 #include "../../str.h"
39 #include "../../pvar.h"
40 #include "../../error.h"
41 #include "../../timer.h"
42 #include "../../resolve.h"
43 #include "../../data_lump.h"
44 #include "../../mod_fix.h"
45 #include "../../script_cb.h"
46 #include "../../timer_proc.h"
47 #include "../../parser/msg_parser.h"
48 #include "../../parser/parse_from.h"
49 #include "../../parser/parse_uri.h"
50 #include "../../parser/parse_expires.h"
51 #include "../../parser/contact/parse_contact.h"
52 #include "../../lib/kcore/statistics.h"
53 #include "../dialog/dlg_load.h"
54 #include "../../modules/tm/tm_load.h"
55 #include "../../modules/sl/sl.h"
56
57
58 MODULE_VERSION
59
60
61 #if defined(__GNUC__) && !defined(__STRICT_ANSI__)
62 # define INLINE inline
63 #else
64 # define INLINE
65 #endif
66
67
68 /* WARNING: Keep this aligned with parser/msg_parser.h! */
69 #define FL_DO_KEEPALIVE (1<<31)
70
71 #define HASH_SIZE    512
72
73
74 #define max(a, b)    ((a)>(b) ? (a) : (b))
75 #define min(a, b)    ((a)<(b) ? (a) : (b))
76
77 #define STR_MATCH(str, buf)  ((str).len==strlen(buf) && memcmp(buf, (str).s, (str).len)==0)
78 #define STR_IMATCH(str, buf) ((str).len==strlen(buf) && strncasecmp(buf, (str).s, (str).len)==0)
79
80 #define STR_MATCH_STR(str, str2)  ((str).len==(str2).len && memcmp((str).s, (str2).s, (str).len)==0)
81 #define STR_IMATCH_STR(str, str2) ((str).len==(str2).len && strncasecmp((str).s, (str2).s, (str).len)==0)
82
83 #define STR_HAS_PREFIX(str, prefix)  ((str).len>(prefix).len && memcmp((prefix).s, (str).s, (prefix).len)==0)
84 #define STR_HAS_IPREFIX(str, prefix) ((str).len>(prefix).len && strncasecmp((prefix).s, (str).s, (prefix).len)==0)
85
86
87 typedef int Bool;
88 #define True  1
89 #define False 0
90
91
92 typedef Bool (*NatTestFunction)(struct sip_msg *msg);
93
94 typedef enum {
95     NTNone=0,
96     NTPrivateContact=1,
97     NTSourceAddress=2,
98     NTPrivateVia=4
99 } NatTestType;
100
101 typedef struct {
102     NatTestType test;
103     NatTestFunction proc;
104 } NatTest;
105
106 typedef struct {
107     const char *name;
108     uint32_t address;
109     uint32_t mask;
110 } NetInfo;
111
112
113 typedef struct SIP_Dialog {
114     struct dlg_cell *dlg;
115     time_t expire;
116     struct SIP_Dialog *next;
117 } SIP_Dialog;
118
119
120 typedef struct NAT_Contact {
121     char *uri;
122     struct socket_info *socket;
123
124     time_t registration_expire;
125     time_t subscription_expire;
126     SIP_Dialog *dialogs;
127
128     struct NAT_Contact *next;
129 } NAT_Contact;
130
131
132 typedef struct HashSlot {
133     NAT_Contact *head;  // pointer to the head of the linked list stored in this slot
134     gen_lock_t lock;
135 } HashSlot;
136
137
138 typedef struct HashTable {
139     HashSlot *slots;
140     unsigned size;      // table size (number of slots)
141 } HashTable;
142
143
144 #define URI_LIST_INITIAL_SIZE 8
145 #define URI_LIST_RESIZE_INCREMENT 8
146
147 typedef struct Dialog_Param {
148     char *caller_uri;
149     char *callee_uri;
150     time_t expire;
151     Bool confirmed;
152     gen_lock_t lock;
153     struct {
154         char **uri;
155         int count;
156         int size;
157     } callee_candidates;
158 } Dialog_Param;
159
160
161 // Module parameters
162 //
163 typedef struct Keepalive_Params {
164     // user specified
165     char *method;
166     char *from;
167     char *extra_headers;
168
169     // internally generated
170     char callid_prefix[20];
171     unsigned callid_counter;
172     unsigned from_tag;
173     char *event_header; // this will be set if method is NOTIFY
174 } Keepalive_Params;
175
176
177 // Function prototypes
178 //
179 static int NAT_Keepalive(struct sip_msg *msg);
180 static int FixContact(struct sip_msg *msg);
181 static int ClientNatTest(struct sip_msg *msg, unsigned int tests);
182
183 static Bool test_private_contact(struct sip_msg *msg);
184 static Bool test_source_address(struct sip_msg *msg);
185 static Bool test_private_via(struct sip_msg *msg);
186
187 static INLINE char* shm_strdup(char *source);
188
189 static int  mod_init(void);
190 static int  child_init(int rank);
191 static void mod_destroy(void);
192 static int  preprocess_request(struct sip_msg *msg, unsigned int flags, void *param);
193 static int  reply_filter(struct sip_msg *reply);
194
195 static int pv_parse_nat_contact_name(pv_spec_p sp, str *in);
196 static int pv_get_keepalive_socket(struct sip_msg *msg, pv_param_t *param, pv_value_t *res);
197 static int pv_get_source_uri(struct sip_msg *msg, pv_param_t *param, pv_value_t *res);
198
199
200 // Module global variables and state
201 //
202 static HashTable *nat_table = NULL;
203
204 static Bool keepalive_disabled = False;
205
206 static unsigned int keepalive_interval = 60;
207
208 static char *keepalive_state_file = "keepalive_state";
209
210 static Keepalive_Params keepalive_params = {"NOTIFY", NULL, "", "", 0, 0, ""};
211
212 struct tm_binds  tm_api;
213 struct dlg_binds dlg_api;
214 Bool have_dlg_api = False;
215
216 static int dialog_flag = -1;
217 static unsigned dialog_default_timeout = 12*3600;  // 12 hours
218
219 stat_var *keepalive_endpoints = 0;
220 stat_var *registered_endpoints = 0;
221 stat_var *subscribed_endpoints = 0;
222 stat_var *dialog_endpoints = 0;
223
224 static NetInfo rfc1918nets[] = {
225     {"10.0.0.0",    0x0a000000UL, 0xff000000UL},
226     {"172.16.0.0",  0xac100000UL, 0xfff00000UL},
227     {"192.168.0.0", 0xc0a80000UL, 0xffff0000UL},
228     {"100.64.0.0",  0x64400000UL, 0xffc00000UL}, // include rfc6598 shared address space as technically the same for our purpose
229     {NULL,          0UL,          0UL}
230 };
231
232 static NatTest NAT_Tests[] = {
233     {NTPrivateContact, test_private_contact},
234     {NTSourceAddress,  test_source_address},
235     {NTPrivateVia,     test_private_via},
236     {NTNone,           NULL}
237 };
238
239 /** SL API structure */
240 sl_api_t slb;
241
242 static cmd_export_t commands[] = {
243     {"nat_keepalive",   (cmd_function)NAT_Keepalive, 0, NULL, 0, REQUEST_ROUTE},
244     {"fix_contact",     (cmd_function)FixContact,    0, NULL, 0, REQUEST_ROUTE | ONREPLY_ROUTE | BRANCH_ROUTE |LOCAL_ROUTE},
245     {"client_nat_test", (cmd_function)ClientNatTest, 1, fixup_uint_null, 0, REQUEST_ROUTE | ONREPLY_ROUTE | FAILURE_ROUTE | BRANCH_ROUTE|LOCAL_ROUTE},
246     {0, 0, 0, 0, 0, 0}
247 };
248
249 static param_export_t parameters[] = {
250     {"keepalive_interval",       INT_PARAM, &keepalive_interval},
251     {"keepalive_method",         STR_PARAM, &keepalive_params.method},
252     {"keepalive_from",           STR_PARAM, &keepalive_params.from},
253     {"keepalive_extra_headers",  STR_PARAM, &keepalive_params.extra_headers},
254     {"keepalive_state_file",     STR_PARAM, &keepalive_state_file},
255     {0, 0, 0}
256 };
257
258 static pv_export_t pvars[] = {
259     {str_init("keepalive.socket"), PVT_OTHER, pv_get_keepalive_socket, NULL, pv_parse_nat_contact_name, NULL, NULL, 0},
260     {str_init("source_uri"), PVT_OTHER, pv_get_source_uri, NULL, NULL, NULL, NULL, 0},
261     {{0, 0}, 0, 0, 0, 0, 0, 0, 0}
262 };
263
264 #ifdef STATISTICS
265 static stat_export_t statistics[] = {
266     {"keepalive_endpoints",  STAT_NO_RESET, &keepalive_endpoints},
267     {"registered_endpoints", STAT_NO_RESET, &registered_endpoints},
268     {"subscribed_endpoints", STAT_NO_RESET, &subscribed_endpoints},
269     {"dialog_endpoints",     STAT_NO_RESET, &dialog_endpoints},
270     {0, 0, 0}
271 };
272 #endif
273
274 struct module_exports exports = {
275     "nat_traversal", // module name
276     DEFAULT_DLFLAGS, // dlopen flags
277     commands,        // exported functions
278     parameters,      // exported parameters
279     NULL,            // exported statistics (initialized early in mod_init)
280     NULL,            // exported MI functions
281     pvars,           // exported pseudo-variables
282     NULL,            // extra processes
283     mod_init,        // module init function (before fork. kids will inherit)
284     reply_filter,    // reply processing function
285     mod_destroy,     // destroy function
286     child_init       // child init function
287 };
288
289
290
291 // SIP_Dialog structure handling functions
292 //
293
294 static SIP_Dialog*
295 SIP_Dialog_new(struct dlg_cell *dlg, time_t expire)
296 {
297     SIP_Dialog *dialog;
298
299     dialog = (SIP_Dialog*)shm_malloc(sizeof(SIP_Dialog));
300     if (!dialog) {
301         LM_ERR("out of memory while creating new SIP_Dialog structure\n");
302         return NULL;
303     }
304     dialog->dlg = dlg;
305     dialog->expire = expire;
306     dialog->next = NULL;
307
308     // we assume expire is always strictly positive on new dialogs
309     update_stat(dialog_endpoints, 1);
310
311     return dialog;
312 }
313
314
315 static void
316 SIP_Dialog_del(SIP_Dialog *dialog)
317 {
318     if (!dialog)
319         return;
320
321     if (dialog->expire > 0)
322         update_stat(dialog_endpoints, -1);
323     shm_free(dialog);
324 }
325
326
327 // Purge expired dialogs from the linked list pointed by dialog
328 //
329 static SIP_Dialog*
330 SIP_Dialog_purge_expired(SIP_Dialog *dialog, time_t now)
331 {
332     SIP_Dialog *next;
333
334     if (dialog==NULL)
335         return NULL;
336
337     dialog->next = SIP_Dialog_purge_expired(dialog->next, now);
338
339     if (now > dialog->expire) {
340         next = dialog->next;
341         SIP_Dialog_del(dialog);
342         return next;
343     }
344
345     return dialog;
346 }
347
348
349 static INLINE void
350 SIP_Dialog_end(SIP_Dialog *dialog)
351 {
352     if (dialog->expire > 0) {
353         dialog->expire = 0;
354         update_stat(dialog_endpoints, -1);
355     }
356 }
357
358
359 // Helpers to handle registration and subscription timeouts for NAT_Contacts
360 //
361 static INLINE void
362 SIP_Registration_update(NAT_Contact *contact, time_t expire)
363 {
364     if (expire > contact->registration_expire) {
365         if (contact->registration_expire == 0)
366             update_stat(registered_endpoints, 1);
367         contact->registration_expire = expire;
368     }
369 }
370
371 static INLINE void
372 SIP_Registration_expire(NAT_Contact *contact, time_t now)
373 {
374     if (contact->registration_expire && now > contact->registration_expire) {
375         update_stat(registered_endpoints, -1);
376         contact->registration_expire = 0;
377     }
378 }
379
380 static INLINE void
381 SIP_Subscription_update(NAT_Contact *contact, time_t expire)
382 {
383     if (expire > contact->subscription_expire) {
384         if (contact->subscription_expire == 0)
385             update_stat(subscribed_endpoints, 1);
386         contact->subscription_expire = expire;
387     }
388 }
389
390 static INLINE void
391 SIP_Subscription_expire(NAT_Contact *contact, time_t now)
392 {
393     if (contact->subscription_expire && now > contact->subscription_expire) {
394         update_stat(subscribed_endpoints, -1);
395         contact->subscription_expire = 0;
396     }
397 }
398
399
400 // NAT_Contact structure handling functions
401 //
402
403 static NAT_Contact*
404 NAT_Contact_new(char *uri, struct socket_info *socket)
405 {
406     NAT_Contact *contact;
407
408     contact = (NAT_Contact*)shm_malloc(sizeof(NAT_Contact));
409     if (!contact) {
410         LM_ERR("out of memory while creating new NAT_Contact structure\n");
411         return NULL;
412     }
413     memset(contact, 0, sizeof(NAT_Contact));
414
415     contact->uri = shm_strdup(uri);
416     if (!contact->uri) {
417         LM_ERR("out of memory while creating new NAT_Contact structure\n");
418         shm_free(contact);
419         return NULL;
420     }
421     contact->socket = socket;
422
423     update_stat(keepalive_endpoints, 1);
424
425     return contact;
426 }
427
428
429 static void
430 NAT_Contact_del(NAT_Contact *contact)
431 {
432     SIP_Dialog *dialog, *next;
433
434     if (!contact)
435         return;
436
437     dialog = contact->dialogs;
438     while (dialog) {
439         next = dialog->next;
440         SIP_Dialog_del(dialog);
441         dialog = next;
442     }
443
444     if (contact->registration_expire > 0)
445         update_stat(registered_endpoints, -1);
446     if (contact->subscription_expire > 0)
447         update_stat(subscribed_endpoints, -1);
448     update_stat(keepalive_endpoints, -1);
449
450     shm_free(contact->uri);
451     shm_free(contact);
452 }
453
454
455 static Bool
456 NAT_Contact_match(NAT_Contact *contact, const char *uri)
457 {
458     return strcmp(contact->uri, uri)==0;
459 }
460
461
462 static SIP_Dialog*
463 NAT_Contact_get_dialog(NAT_Contact *contact, struct dlg_cell *dlg)
464 {
465     SIP_Dialog *dialog;
466
467     dialog = contact->dialogs;
468
469     while (dialog) {
470         if (dialog->dlg == dlg)
471             break;
472         dialog = dialog->next;
473     }
474
475     return dialog;
476 }
477
478
479 static NAT_Contact*
480 NAT_Contact_purge_expired(NAT_Contact *contact, time_t now)
481 {
482     NAT_Contact *next;
483
484     if (contact==NULL)
485         return NULL;
486
487     contact->next = NAT_Contact_purge_expired(contact->next, now);
488
489     SIP_Registration_expire(contact, now);
490     SIP_Subscription_expire(contact, now);
491     contact->dialogs = SIP_Dialog_purge_expired(contact->dialogs, now);
492
493     if (!contact->registration_expire && !contact->subscription_expire && !contact->dialogs) {
494         next = contact->next;
495         NAT_Contact_del(contact);
496         return next;
497     }
498
499     return contact;
500 }
501
502
503 // HashTable structure manipulation
504 //
505
506 #define HASH(table, key)  (hash_string(key) % (table)->size)
507
508 static INLINE unsigned
509 hash_string(const char *key)
510 {
511     register unsigned ret = 0;
512     register unsigned ctr = 0;
513
514     while (*key) {
515         ret ^= *(char*)key++ << ctr;
516         ctr = (ctr + 1) % sizeof (char *);
517     }
518
519     return ret;
520 }
521
522
523 static HashTable*
524 HashTable_new(void)
525 {
526     HashTable *table;
527     int i, j;
528
529     table = shm_malloc(sizeof(HashTable));
530     if (!table) {
531         LM_ERR("cannot allocate shared memory for hash table\n");
532         return NULL;
533     }
534     memset(table, 0, sizeof(HashTable));
535
536     table->size = HASH_SIZE;
537
538     table->slots = shm_malloc(sizeof(HashSlot)*table->size);
539     if (!table->slots) {
540         LM_ERR("cannot allocate shared memory for hash table\n");
541         shm_free(table);
542         return NULL;
543     }
544     memset(table->slots, 0, sizeof(HashSlot)*table->size);
545
546     for (i=0; i<table->size; i++) {
547         if (!lock_init(&table->slots[i].lock)) {
548             LM_ERR("cannot initialize hash table locks\n");
549             for (j=0; j<i; j++)
550                 lock_destroy(&table->slots[j].lock);
551             shm_free(table->slots);
552             shm_free(table);
553             return NULL;
554         }
555     }
556
557     return table;
558 }
559
560
561 static void
562 HashTable_del(HashTable *table)
563 {
564     NAT_Contact *contact, *next;
565     int i;
566
567     for (i=0; i < table->size; i++) {
568         lock_get(&table->slots[i].lock);
569         contact = table->slots[i].head;
570         while (contact) {
571             next = contact->next;
572             NAT_Contact_del(contact);
573             contact = next;
574         }
575         table->slots[i].head = NULL;
576         lock_release(&table->slots[i].lock);
577     }
578
579     shm_free(table->slots);
580     shm_free(table);
581 }
582
583
584 // This function assumes that the caller has locked the slot already
585 //
586 static NAT_Contact*
587 HashTable_search(HashTable *table, char *uri, unsigned slot)
588 {
589     NAT_Contact *contact;
590
591     contact = table->slots[slot].head;
592
593     while (contact) {
594         if (NAT_Contact_match(contact, uri))
595             break;
596         contact = contact->next;
597     }
598
599     return contact;
600 }
601
602
603 // Dialog_Param structure handling functions
604 //
605
606 static Dialog_Param*
607 Dialog_Param_new(void)
608 {
609     Dialog_Param *param;
610
611     param = shm_malloc(sizeof(Dialog_Param));
612     if (!param) {
613         LM_ERR("cannot allocate shared memory for dialog callback param\n");
614         return NULL;
615     }
616     memset(param, 0, sizeof(Dialog_Param));
617
618     param->callee_candidates.uri = shm_malloc(sizeof(char*) * URI_LIST_INITIAL_SIZE);
619     if (!param->callee_candidates.uri) {
620         LM_ERR("cannot allocate shared memory for callee_candidates uri list\n");
621         shm_free(param);
622         return NULL;
623     }
624     memset(param->callee_candidates.uri, 0, sizeof(char*) * URI_LIST_INITIAL_SIZE);
625     param->callee_candidates.size = URI_LIST_INITIAL_SIZE;
626
627     param->expire = time(NULL) + dialog_default_timeout;
628
629     if (!lock_init(&param->lock)) {
630         LM_ERR("cannot initialize dialog param structure lock\n");
631         shm_free(param->callee_candidates.uri);
632         shm_free(param);
633         return NULL;
634     }
635
636     return param;
637 }
638
639
640 static void
641 Dialog_Param_del(Dialog_Param *param)
642 {
643     int i;
644
645     if (!param)
646         return;
647
648     lock_destroy(&param->lock);
649
650     if (param->caller_uri)
651         shm_free(param->caller_uri);
652     if (param->callee_uri)
653         shm_free(param->callee_uri);
654     for (i=0; i<param->callee_candidates.count; i++)
655         shm_free(param->callee_candidates.uri[i]);
656     shm_free(param->callee_candidates.uri);
657     shm_free(param);
658 }
659
660
661 // This function assumes the caller has locked the Dialog_Param while operating on it
662 //
663 static Bool
664 Dialog_Param_has_candidate(Dialog_Param *param, char *candidate)
665 {
666     int i;
667
668     for (i=0; i<param->callee_candidates.count; i++) {
669         if (strcmp(candidate, param->callee_candidates.uri[i])==0) {
670             return True;
671         }
672     }
673
674     return False;
675 }
676
677
678 // This function assumes the caller has locked the Dialog_Param while operating on it
679 //
680 static Bool
681 Dialog_Param_add_candidate(Dialog_Param *param, char *candidate)
682 {
683     char **new_uri, *new_candidate;
684     int new_size;
685
686     if (param->callee_candidates.count == param->callee_candidates.size) {
687         new_size = param->callee_candidates.size + URI_LIST_RESIZE_INCREMENT;
688         LM_DBG("growing callee_candidates list size from %d to %d entries\n", param->callee_candidates.size, new_size);
689         new_uri = shm_realloc(param->callee_candidates.uri, new_size * sizeof(char*));
690         if (!new_uri) {
691             LM_ERR("failed to grow callee_candidates uri list\n");
692             return False;
693         }
694         param->callee_candidates.uri = new_uri;
695         param->callee_candidates.size = new_size;
696     }
697
698     new_candidate = shm_strdup(candidate);
699     if (!new_candidate) {
700         LM_ERR("cannot allocate shared memory for new candidate uri\n");
701         return False;
702     }
703
704     param->callee_candidates.uri[param->callee_candidates.count] = new_candidate;
705     param->callee_candidates.count++;
706
707     return True;
708 }
709
710
711 // Miscellaneous helper functions
712 //
713
714 // returns str with leading whitespace removed
715 static INLINE void
716 ltrim(str *string)
717 {
718     while (string->len>0 && isspace((int)*(string->s))) {
719         string->len--;
720         string->s++;
721     }
722 }
723
724 // returns str with trailing whitespace removed
725 static INLINE void
726 rtrim(str *string)
727 {
728     char *ptr;
729
730     ptr = string->s + string->len - 1;
731     while (string->len>0 && (*ptr==0 || isspace((int)*ptr))) {
732         string->len--;
733         ptr--;
734     }
735 }
736
737 // returns str with leading and trailing whitespace removed
738 static INLINE void
739 trim(str *string)
740 {
741     ltrim(string);
742     rtrim(string);
743 }
744
745
746 static INLINE char*
747 shm_strdup(char *source)
748 {
749     char *copy;
750
751     if (!source)
752         return NULL;
753
754     copy = (char*)shm_malloc(strlen(source) + 1);
755     if (!copy)
756         return NULL;
757     strcpy(copy, source);
758
759     return copy;
760 }
761
762
763 static Bool
764 get_contact_uri(struct sip_msg* msg, struct sip_uri *uri, contact_t **_c)
765 {
766
767     if ((parse_headers(msg, HDR_CONTACT_F, 0) == -1) || !msg->contact)
768         return False;
769
770     if (!msg->contact->parsed && parse_contact(msg->contact) < 0) {
771         LM_ERR("cannot parse the Contact header\n");
772         return False;
773     }
774
775     *_c = ((contact_body_t*)msg->contact->parsed)->contacts;
776
777     if (*_c == NULL) {
778         return False;
779     }
780
781     if (parse_uri((*_c)->uri.s, (*_c)->uri.len, uri) < 0 || uri->host.len <= 0) {
782         LM_ERR("cannot parse the Contact URI\n");
783         return False;
784     }
785
786     return True;
787 }
788
789
790 #define is_private_address(x) (rfc1918address(x)==1 ? 1 : 0)
791
792 // Test if IP in `address' belongs to a RFC1918 network
793 static INLINE int
794 rfc1918address(str *address)
795 {
796     struct ip_addr *ip;
797     uint32_t netaddr;
798     int i;
799
800     ip = str2ip(address);
801     if (ip == NULL)
802         return -1; // invalid address to test
803
804     netaddr = ntohl(ip->u.addr32[0]);
805
806     for (i=0; rfc1918nets[i].name!=NULL; i++) {
807         if ((netaddr & rfc1918nets[i].mask)==rfc1918nets[i].address) {
808             return 1;
809         }
810     }
811
812     return 0;
813 }
814
815
816 // Test if address of signaling is different from address in 1st Via field
817 static Bool
818 test_source_address(struct sip_msg *msg)
819 {
820     Bool different_ip, different_port;
821     int via1_port;
822
823     different_ip = received_test(msg);
824     via1_port = (msg->via1->port ? msg->via1->port : SIP_PORT);
825     different_port = (msg->rcv.src_port != via1_port);
826
827     return (different_ip || different_port);
828 }
829
830
831 // Test if Contact field contains a private IP address as defined in RFC1918
832 static Bool
833 test_private_contact(struct sip_msg *msg)
834 {
835     struct sip_uri uri;
836     contact_t* contact;
837
838     if (!get_contact_uri(msg, &uri, &contact))
839         return False;
840
841     return is_private_address(&(uri.host));
842 }
843
844
845 // Test if top Via field contains a private IP address as defined in RFC1918
846 static Bool
847 test_private_via(struct sip_msg *msg)
848 {
849     return is_private_address(&(msg->via1->host));
850 }
851
852
853 // return the Expires header value (converted to an UNIX timestamp if > 0)
854 static int
855 get_expires(struct sip_msg *msg)
856 {
857     exp_body_t *expires;
858
859     if (parse_headers(msg, HDR_EXPIRES_F, 0) < 0) {
860         LM_ERR("failed to parse the Expires header\n");
861         return 0;
862     }
863     if (!msg->expires)
864         return 0;
865
866     if (parse_expires(msg->expires) < 0) {
867         LM_ERR("failed to parse the Expires header body\n");
868         return 0;
869     }
870
871     expires = (exp_body_t*)msg->expires->parsed;
872
873     return ((expires->valid && expires->val) ? expires->val + time(NULL) : 0);
874 }
875
876
877 // return the highest expire value from all registered contacts in the request
878 static time_t
879 get_register_expire(struct sip_msg *request, struct sip_msg *reply)
880 {
881     struct hdr_field contact_hdr, *hdr, *r_hdr;
882     contact_body_t *contact_body, *r_contact_body;
883     contact_t *contact, *r_contact;
884     param_t *expires_param;
885     time_t now, expire=0;
886     unsigned exp;
887     Bool matched;
888
889     if (!request->contact)
890         return 0;
891
892     if (parse_headers(reply, HDR_EOH_F, 0) < 0) {
893         LM_ERR("failed to parse headers for REGISTER reply\n");
894         return 0;
895     }
896
897     if (!reply->contact)
898         return 0;
899
900     now = time(NULL);
901
902     // request may be R/O (if we are called from the TM callback),
903     // thus we copy the hdr_field structures before parsing them
904
905     for (hdr=request->contact; hdr; hdr = next_sibling_hdr(hdr)) {
906         if (!hdr->parsed) {
907             memcpy(&contact_hdr, hdr, sizeof(struct hdr_field));
908             if (parse_contact(&contact_hdr) < 0) {
909                 LM_ERR("failed to parse the Contact header body\n");
910                 continue;
911             }
912             contact_body = (contact_body_t*)contact_hdr.parsed;
913         } else {
914             contact_body = (contact_body_t*)hdr->parsed;
915         }
916
917         if (contact_body->star) {
918             if (!hdr->parsed)
919                 clean_hdr_field(&contact_hdr);
920             return 0;
921         }
922
923         for (contact=contact_body->contacts; contact; contact=contact->next) {
924             for (r_hdr=reply->contact, matched=False; r_hdr && !matched; r_hdr=next_sibling_hdr(r_hdr)) {
925                 if (!r_hdr->parsed && parse_contact(r_hdr) < 0) {
926                     LM_ERR("failed to parse the Contact header body in reply\n");
927                     continue;
928                 }
929                 r_contact_body = (contact_body_t*)r_hdr->parsed;
930                 for (r_contact=r_contact_body->contacts; r_contact; r_contact=r_contact->next) {
931                     if (STR_MATCH_STR(contact->uri, r_contact->uri)) {
932                         expires_param = r_contact->expires;
933                         if (expires_param && expires_param->body.len && str2int(&expires_param->body, &exp) == 0)
934                             expire = max(expire, exp);
935                         matched = True;
936                         break;
937                     }
938                 }
939             }
940         }
941
942         if (!hdr->parsed) {
943             clean_hdr_field(&contact_hdr);
944         }
945     }
946
947     LM_DBG("maximum expire for all contacts: %u\n", (unsigned)expire);
948
949     return (expire ? expire + now : 0);
950 }
951
952
953 static char*
954 get_source_uri(struct sip_msg *msg)
955 {
956     static char uri[64];
957     snprintf(uri, 64, "sip:%s:%d", ip_addr2a(&msg->rcv.src_ip), msg->rcv.src_port);
958     return uri;
959 }
960
961
962 static void
963 keepalive_registration(struct sip_msg *request, time_t expire)
964 {
965     NAT_Contact *contact;
966     unsigned h;
967     char *uri;
968
969     uri = get_source_uri(request);
970
971     h = HASH(nat_table, uri);
972     lock_get(&nat_table->slots[h].lock);
973
974     contact = HashTable_search(nat_table, uri, h);
975     if (contact) {
976         SIP_Registration_update(contact, expire);
977     } else {
978         contact = NAT_Contact_new(uri, request->rcv.bind_address);
979         if (contact) {
980             SIP_Registration_update(contact, expire);
981             contact->next = nat_table->slots[h].head;
982             nat_table->slots[h].head = contact;
983         } else {
984             LM_ERR("cannot allocate shared memory for new NAT contact\n");
985         }
986     }
987
988     lock_release(&nat_table->slots[h].lock);
989 }
990
991
992 static void
993 keepalive_subscription(struct sip_msg *request, time_t expire)
994 {
995     NAT_Contact *contact;
996     unsigned h;
997     char *uri;
998
999     uri = get_source_uri(request);
1000
1001     h = HASH(nat_table, uri);
1002     lock_get(&nat_table->slots[h].lock);
1003
1004     contact = HashTable_search(nat_table, uri, h);
1005     if (contact) {
1006         SIP_Subscription_update(contact, expire);
1007     } else {
1008         contact = NAT_Contact_new(uri, request->rcv.bind_address);
1009         if (contact) {
1010             SIP_Subscription_update(contact, expire);
1011             contact->next = nat_table->slots[h].head;
1012             nat_table->slots[h].head = contact;
1013         } else {
1014             LM_ERR("cannot allocate shared memory for new NAT contact\n");
1015         }
1016     }
1017
1018     lock_release(&nat_table->slots[h].lock);
1019 }
1020
1021
1022 static void
1023 __dialog_early(struct dlg_cell *dlg, int type, struct dlg_cb_params *_params)
1024 {
1025     Dialog_Param *param = (Dialog_Param*)*_params->param;
1026     NAT_Contact *contact;
1027     SIP_Dialog *dialog;
1028     unsigned h;
1029     char *uri;
1030
1031     lock_get(&param->lock);
1032
1033     if (param->confirmed) {
1034         // this 1xx is late; dialog already confirmed by 200 OK; ignore it
1035         lock_release(&param->lock);
1036         return;
1037     }
1038
1039     uri = get_source_uri(_params->rpl);
1040     if (!Dialog_Param_has_candidate(param, uri)) {
1041         if (!Dialog_Param_add_candidate(param, uri)) {
1042             LM_ERR("cannot add callee candidate uri to the list\n");
1043         } else {
1044             h = HASH(nat_table, uri);
1045             lock_get(&nat_table->slots[h].lock);
1046
1047             contact = HashTable_search(nat_table, uri, h);
1048             if (contact) {
1049                 dialog = NAT_Contact_get_dialog(contact, dlg);
1050                 if (!dialog) {
1051                     dialog = SIP_Dialog_new(dlg, param->expire);
1052                     if (dialog) {
1053                         dialog->next = contact->dialogs;
1054                         contact->dialogs = dialog;
1055                     } else {
1056                         LM_ERR("cannot allocate shared memory for new SIP dialog\n");
1057                     }
1058                 }
1059             }
1060
1061             lock_release(&nat_table->slots[h].lock);
1062         }
1063     }
1064
1065     lock_release(&param->lock);
1066 }
1067
1068
1069 static void
1070 __dialog_confirmed(struct dlg_cell *dlg, int type, struct dlg_cb_params *_params)
1071 {
1072     Dialog_Param *param = (Dialog_Param*)*_params->param;
1073     NAT_Contact *contact;
1074     SIP_Dialog *dialog;
1075     char *callee_uri, *uri;
1076     unsigned h;
1077     int i;
1078
1079     lock_get(&param->lock);
1080
1081     param->confirmed = True;
1082
1083     callee_uri = get_source_uri(_params->rpl);
1084
1085     // remove all keepalives on unanswered branches
1086     for (i=0; i<param->callee_candidates.count; i++) {
1087         uri = param->callee_candidates.uri[i];
1088
1089         if (strcmp(uri, callee_uri) != 0) {
1090             // this is an unanswered branch
1091             h = HASH(nat_table, uri);
1092             lock_get(&nat_table->slots[h].lock);
1093
1094             contact = HashTable_search(nat_table, uri, h);
1095             if (contact) {
1096                 dialog = NAT_Contact_get_dialog(contact, dlg);
1097                 if (dialog) {
1098                     SIP_Dialog_end(dialog);
1099                 }
1100             }
1101
1102             lock_release(&nat_table->slots[h].lock);
1103         }
1104
1105         shm_free(param->callee_candidates.uri[i]);
1106         param->callee_candidates.uri[i] = NULL;
1107     }
1108
1109     param->callee_candidates.count = 0;
1110
1111     // add dialog keepalive for answered branch, if needed and not already there
1112     h = HASH(nat_table, callee_uri);
1113     lock_get(&nat_table->slots[h].lock);
1114
1115     contact = HashTable_search(nat_table, callee_uri, h);
1116     if (contact) {
1117         dialog = NAT_Contact_get_dialog(contact, dlg);
1118         if (!dialog) {
1119             dialog = SIP_Dialog_new(dlg, param->expire);
1120             if (dialog) {
1121                 dialog->next = contact->dialogs;
1122                 contact->dialogs = dialog;
1123             } else {
1124                 LM_ERR("cannot allocate shared memory for new SIP dialog\n");
1125             }
1126         }
1127         // free old uri in case this callback is called more than once (shouldn't normally happen)
1128         if (param->callee_uri)
1129             shm_free(param->callee_uri);
1130         param->callee_uri = shm_strdup(callee_uri);
1131         if (!param->callee_uri) {
1132             LM_ERR("cannot allocate shared memory for callee_uri in dialog param\n");
1133         }
1134     }
1135
1136     lock_release(&nat_table->slots[h].lock);
1137
1138     lock_release(&param->lock);
1139 }
1140
1141
1142 static void
1143 __dialog_destroy(struct dlg_cell *dlg, int type, struct dlg_cb_params *_params)
1144 {
1145     Dialog_Param *param = (Dialog_Param*)*_params->param;
1146     NAT_Contact *contact;
1147     SIP_Dialog *dialog;
1148     unsigned h;
1149     int i;
1150
1151     if (!param)
1152         return;
1153
1154     // If nat_table is NULL, it's because it was already removed during
1155     // shutdown by mod_destroy. However we can still receive dialog destroy
1156     // notifications when the dialog module removes dialogs on shutdown.
1157     if (!nat_table) {
1158         Dialog_Param_del(param);
1159         *_params->param = NULL;
1160         return;
1161     }
1162
1163     if (param->caller_uri) {
1164         h = HASH(nat_table, param->caller_uri);
1165         lock_get(&nat_table->slots[h].lock);
1166
1167         contact = HashTable_search(nat_table, param->caller_uri, h);
1168         if (contact) {
1169             dialog = NAT_Contact_get_dialog(contact, dlg);
1170             if (dialog) {
1171                 SIP_Dialog_end(dialog);
1172             }
1173         }
1174
1175         lock_release(&nat_table->slots[h].lock);
1176     }
1177
1178     if (param->callee_uri) {
1179         h = HASH(nat_table, param->callee_uri);
1180         lock_get(&nat_table->slots[h].lock);
1181
1182         contact = HashTable_search(nat_table, param->callee_uri, h);
1183         if (contact) {
1184             dialog = NAT_Contact_get_dialog(contact, dlg);
1185             if (dialog) {
1186                 SIP_Dialog_end(dialog);
1187             }
1188         }
1189
1190         lock_release(&nat_table->slots[h].lock);
1191     }
1192
1193     lock_get(&param->lock);
1194
1195     // remove all keepalives on unanswered branches. this is neded because
1196     // we may transit from early to ended without going through confirmed
1197     for (i=0; i<param->callee_candidates.count; i++) {
1198         h = HASH(nat_table, param->callee_candidates.uri[i]);
1199         lock_get(&nat_table->slots[h].lock);
1200
1201         contact = HashTable_search(nat_table, param->callee_candidates.uri[i], h);
1202         if (contact) {
1203             dialog = NAT_Contact_get_dialog(contact, dlg);
1204             if (dialog) {
1205                 SIP_Dialog_end(dialog);
1206             }
1207         }
1208
1209         lock_release(&nat_table->slots[h].lock);
1210
1211         shm_free(param->callee_candidates.uri[i]);
1212         param->callee_candidates.uri[i] = NULL;
1213     }
1214
1215     param->callee_candidates.count = 0;
1216
1217     lock_release(&param->lock);
1218
1219     Dialog_Param_del(param);
1220
1221     *_params->param = NULL;
1222 }
1223
1224
1225 static void
1226 __dialog_created(struct dlg_cell *dlg, int type, struct dlg_cb_params *_params)
1227 {
1228     struct sip_msg *request = _params->req;
1229     NAT_Contact *contact;
1230     SIP_Dialog *dialog;
1231     Dialog_Param *param;
1232     unsigned h;
1233     char *uri;
1234
1235     if (request->REQ_METHOD != METHOD_INVITE)
1236         return;
1237
1238     param = Dialog_Param_new();
1239     if (!param) {
1240         LM_ERR("cannot create dialog callback param\n");
1241         return;
1242     }
1243
1244     if (dlg_api.register_dlgcb(dlg, DLGCB_DESTROY, __dialog_destroy, param, NULL) != 0) {
1245         LM_ERR("cannot register callback for dialog destruction\n");
1246         Dialog_Param_del(param);
1247         return;
1248     }
1249
1250     if (dlg_api.register_dlgcb(dlg, DLGCB_EARLY, __dialog_early, param, NULL) != 0)
1251         LM_ERR("cannot register callback for dialog early replies\n");
1252     if (dlg_api.register_dlgcb(dlg, DLGCB_CONFIRMED_NA, __dialog_confirmed, param, NULL) != 0)
1253         LM_ERR("cannot register callback for dialog confirmation\n");
1254
1255     if ((request->msg_flags & FL_DO_KEEPALIVE) == 0)
1256         return;
1257
1258     uri = get_source_uri(request);
1259     param->caller_uri = shm_strdup(uri);
1260     if (!param->caller_uri) {
1261         LM_ERR("cannot allocate shared memory for caller_uri in dialog param\n");
1262         return;
1263     }
1264
1265     h = HASH(nat_table, uri);
1266     lock_get(&nat_table->slots[h].lock);
1267
1268     contact = HashTable_search(nat_table, uri, h);
1269     if (contact) {
1270         dialog = SIP_Dialog_new(dlg, param->expire);
1271         if (dialog) {
1272             dialog->next = contact->dialogs;
1273             contact->dialogs = dialog;
1274         } else {
1275             LM_ERR("cannot allocate shared memory for new SIP dialog\n");
1276         }
1277     } else {
1278         contact = NAT_Contact_new(uri, request->rcv.bind_address);
1279         if (contact) {
1280             contact->dialogs = SIP_Dialog_new(dlg, param->expire);
1281             if (contact->dialogs) {
1282                 contact->next = nat_table->slots[h].head;
1283                 nat_table->slots[h].head = contact;
1284             } else {
1285                 LM_ERR("cannot allocate shared memory for new SIP dialog\n");
1286                 NAT_Contact_del(contact);
1287             }
1288         } else {
1289             LM_ERR("cannot allocate shared memory for new NAT contact\n");
1290         }
1291     }
1292
1293     lock_release(&nat_table->slots[h].lock);
1294 }
1295
1296
1297 // callback to handle all SL generated replies
1298 //
1299 static void
1300 __sl_reply_out(sl_cbp_t *slcbp)
1301 {
1302     struct sip_msg reply;
1303     struct sip_msg *request;
1304     time_t expire;
1305
1306         request = slcbp->req;
1307     if (request->REQ_METHOD == METHOD_INVITE)
1308         return;
1309
1310     if ((request->msg_flags & FL_DO_KEEPALIVE) == 0)
1311         return;
1312
1313     if (slcbp->code >= 200 && slcbp->code < 300) {
1314         memset(&reply, 0, sizeof(struct sip_msg));
1315         reply.buf = slcbp->reply->s;
1316         reply.len = slcbp->reply->len;
1317
1318         if (parse_msg(reply.buf, reply.len, &reply) != 0) {
1319             LM_ERR("cannot parse outgoing SL reply for keepalive"
1320                                         " information\n");
1321             return;
1322         }
1323
1324         switch (request->REQ_METHOD) {
1325         case METHOD_SUBSCRIBE:
1326             expire = get_expires(&reply);
1327             if (expire > 0)
1328                 keepalive_subscription(request, expire);
1329             break;
1330         case METHOD_REGISTER:
1331             expire = get_register_expire(request, &reply);
1332             if (expire > 0)
1333                 keepalive_registration(request, expire);
1334             break;
1335         default:
1336             LM_ERR("called with keepalive flag set for unsupported method\n");
1337             break;
1338         }
1339
1340         free_sip_msg(&reply);
1341     }
1342 }
1343
1344
1345 // callback to handle incoming replies for the request's transactions
1346 //
1347 static void
1348 __tm_reply_in(struct cell *trans, int type, struct tmcb_params *param)
1349 {
1350     time_t expire;
1351
1352     if (param->req==NULL || param->rpl==NULL)
1353         return;
1354
1355     if (param->code >= 200 && param->code < 300) {
1356         switch (param->req->REQ_METHOD) {
1357         case METHOD_SUBSCRIBE:
1358             expire = get_expires(param->rpl);
1359             if (expire > 0)
1360                 keepalive_subscription(param->req, expire);
1361             break;
1362         case METHOD_REGISTER:
1363             expire = get_register_expire(param->req, param->rpl);
1364             if (expire > 0)
1365                 keepalive_registration(param->req, expire);
1366             break;
1367         }
1368     }
1369 }
1370
1371
1372 // Keepalive NAT for an UA while it has registered contacts or active dialogs
1373 //
1374 static int
1375 NAT_Keepalive(struct sip_msg *msg)
1376 {
1377
1378     if (keepalive_disabled)
1379         return -1;
1380
1381     // keepalive is only supported for UDP dialogs
1382     if (msg->rcv.proto!=PROTO_UDP)
1383         return -1;
1384
1385     switch (msg->REQ_METHOD) {
1386
1387     case METHOD_REGISTER:
1388         // make the expires & contact headers available later in the TM cloned msg
1389         if (parse_headers(msg, HDR_EOH_F, 0) < 0) {
1390             LM_ERR("failed to parse headers in REGISTER request\n");
1391             return -1;
1392         }
1393         // fallthrough
1394     case METHOD_SUBSCRIBE:
1395         msg->msg_flags |= FL_DO_KEEPALIVE;
1396         if (tm_api.register_tmcb(msg, 0, TMCB_RESPONSE_IN, __tm_reply_in, 0, 0) <= 0) {
1397             LM_ERR("cannot register TM callback for incoming replies\n");
1398             return -1;
1399         }
1400         return 1;
1401
1402     case METHOD_INVITE:
1403         if (!have_dlg_api) {
1404             LM_ERR("cannot keep alive dialog without the dialog module being loaded\n");
1405             return -1;
1406         }
1407         msg->msg_flags |= FL_DO_KEEPALIVE;
1408         setflag(msg, dialog_flag); // have the dialog module trace this dialog
1409         return 1;
1410
1411     default:
1412         LM_ERR("unsupported method for keepalive\n");
1413         return -1;
1414     }
1415
1416 }
1417
1418
1419 // Replace IP:Port in Contact field with the source address of the packet.
1420 static int
1421 FixContact(struct sip_msg *msg)
1422 {
1423     str before_host, after, newip;
1424     unsigned short port, newport;
1425     contact_t* contact;
1426     struct lump* anchor;
1427     struct sip_uri uri;
1428     int len, offset;
1429     char *buf;
1430
1431     if (!get_contact_uri(msg, &uri, &contact))
1432         return -1;
1433
1434     newip.s = ip_addr2a(&msg->rcv.src_ip);
1435     newip.len = strlen(newip.s);
1436     newport = msg->rcv.src_port;
1437
1438     port = uri.port_no ? uri.port_no : 5060;
1439
1440     // Don't do anything if the address is the same, just return success.
1441     if (STR_MATCH_STR(uri.host, newip) && port==newport)
1442         return 1;
1443
1444     if (uri.port.len == 0)
1445         uri.port.s = uri.host.s + uri.host.len;
1446
1447     before_host.s   = contact->uri.s;
1448     before_host.len = uri.host.s - contact->uri.s;
1449     after.s   = uri.port.s + uri.port.len;
1450     after.len = contact->uri.s + contact->uri.len - after.s;
1451
1452     len = before_host.len + newip.len + after.len + 20;
1453
1454     // first try to alloc mem. if we fail we don't want to have the lump
1455     // deleted and not replaced. at least this way we keep the original.
1456     buf = pkg_malloc(len);
1457     if (buf == NULL) {
1458         LM_ERR("out of memory\n");
1459         return -1;
1460     }
1461
1462     offset = contact->uri.s - msg->buf;
1463     anchor = del_lump(msg, offset, contact->uri.len, HDR_CONTACT_F);
1464
1465     if (!anchor) {
1466         pkg_free(buf);
1467         return -1;
1468     }
1469
1470     len = sprintf(buf, "%.*s%s:%d%.*s", before_host.len, before_host.s,
1471                   newip.s, newport, after.len, after.s);
1472
1473     if (insert_new_lump_after(anchor, buf, len, HDR_CONTACT_F) == 0) {
1474         pkg_free(buf);
1475         return -1;
1476     }
1477
1478     contact->uri.s   = buf;
1479     contact->uri.len = len;
1480
1481     return 1;
1482 }
1483
1484
1485 static int
1486 ClientNatTest(struct sip_msg *msg, unsigned int tests)
1487 {
1488     int i;
1489
1490     for (i=0; NAT_Tests[i].test!=NTNone; i++) {
1491         if ((tests & NAT_Tests[i].test)!=0 && NAT_Tests[i].proc(msg)) {
1492             return 1;
1493         }
1494     }
1495
1496     return -1; // all failed
1497 }
1498
1499
1500 #define FROM_PREFIX "sip:keepalive@"
1501
1502 static void
1503 send_keepalive(NAT_Contact *contact)
1504 {
1505     char buffer[8192], *from_uri, *ptr;
1506     static char from[64] = FROM_PREFIX;
1507     static char *from_ip = from + sizeof(FROM_PREFIX) - 1;
1508     static struct socket_info *last_socket = NULL;
1509     struct hostent* hostent;
1510         struct dest_info dst;
1511     int nat_port, len;
1512     str nat_ip;
1513
1514     if (keepalive_params.from == NULL) {
1515         if (contact->socket != last_socket) {
1516             memcpy(from_ip, contact->socket->address_str.s, contact->socket->address_str.len);
1517             from_ip[contact->socket->address_str.len] = 0;
1518             last_socket = contact->socket;
1519         }
1520         from_uri = from;
1521     } else {
1522         from_uri = keepalive_params.from;
1523     }
1524
1525     len = snprintf(buffer, sizeof(buffer),
1526                    "%s %s SIP/2.0\r\n"
1527                    "Via: SIP/2.0/UDP %.*s:%d;branch=0\r\n"
1528                    "From: %s;tag=%x\r\n"
1529                    "To: %s\r\n"
1530                    "Call-ID: %s-%x-%x@%.*s\r\n"
1531                    "CSeq: 1 %s\r\n"
1532                    "%s%s"
1533                    "Content-Length: 0\r\n\r\n",
1534                    keepalive_params.method, contact->uri,
1535                    contact->socket->address_str.len,
1536                    contact->socket->address_str.s, contact->socket->port_no,
1537                    from_uri, keepalive_params.from_tag++,
1538                    contact->uri, keepalive_params.callid_prefix,
1539                    keepalive_params.callid_counter++, get_ticks(),
1540                    contact->socket->address_str.len,
1541                    contact->socket->address_str.s,
1542                    keepalive_params.method,
1543                    keepalive_params.event_header,
1544                    keepalive_params.extra_headers);
1545
1546     if (len >= sizeof(buffer)) {
1547         LM_ERR("keepalive message is longer than %lu bytes\n", (unsigned long)sizeof(buffer));
1548         return;
1549     }
1550
1551         init_dest_info(&dst);
1552     //nat_ip.s = strchr(contact->uri, ':') + 1;
1553     nat_ip.s = &contact->uri[4]; // skip over "sip:"
1554     ptr = strchr(nat_ip.s, ':');
1555     nat_ip.len = ptr - nat_ip.s;
1556     nat_port = strtol(ptr+1, NULL, 10);
1557     hostent = sip_resolvehost(&nat_ip, NULL, NULL);
1558     hostent2su(&dst.to, hostent, 0, nat_port);
1559         dst.proto=PROTO_UDP;
1560         dst.send_sock=contact->socket;
1561     udp_send(&dst, buffer, len);
1562 }
1563
1564
1565 static void
1566 keepalive_timer(unsigned int ticks, void *data)
1567 {
1568     static unsigned iteration = 0;
1569     NAT_Contact *contact;
1570     HashSlot *slot;
1571     time_t now;
1572     int i;
1573
1574     now = time(NULL);
1575
1576     for (i=0; i<nat_table->size; i++) {
1577
1578         if ((i % keepalive_interval) != iteration)
1579             continue;
1580
1581         slot = &nat_table->slots[i];
1582
1583         lock_get(&slot->lock);
1584
1585         slot->head = NAT_Contact_purge_expired(slot->head, now);
1586         contact = slot->head;
1587
1588         lock_release(&slot->lock);
1589
1590         while (contact) {
1591             send_keepalive(contact);
1592             contact = contact->next;
1593         }
1594     }
1595
1596     iteration = (iteration+1) % keepalive_interval;
1597 }
1598
1599
1600 // Functions to save and restore the keepalive NAT table. They should only be
1601 // called from mod_init/mod_destroy as they access shm memory without locking
1602 //
1603
1604 #define STATE_FILE_HEADER "# Automatically generated file from internal keepalive state. Do NOT modify!\n"
1605
1606 static void
1607 save_keepalive_state(void)
1608 {
1609     NAT_Contact *contact;
1610     FILE *f;
1611     int i;
1612
1613     if (!keepalive_state_file)
1614         return;
1615
1616     f = fopen(keepalive_state_file, "w");
1617     if (!f) {
1618         LM_ERR("failed to open keepalive state file for writing: %s\n", strerror(errno));
1619         return;
1620     }
1621
1622     fprintf(f, STATE_FILE_HEADER);
1623
1624     for (i=0; i<nat_table->size; i++) {
1625         contact = nat_table->slots[i].head;
1626         while (contact) {
1627             fprintf(f, "%s %.*s %ld %ld\n",
1628                     contact->uri,
1629                     contact->socket->sock_str.len, contact->socket->sock_str.s,
1630                     (long int)contact->registration_expire,
1631                     (long int)contact->subscription_expire);
1632             contact = contact->next;
1633         }
1634     }
1635
1636     if (ferror(f))
1637         LM_ERR("couldn't write keepalive state file: %s\n", strerror(errno));
1638
1639     fclose(f);
1640 }
1641
1642
1643 static void
1644 restore_keepalive_state(void)
1645 {
1646     char uri[64], socket[64];
1647     time_t rtime, stime, now;
1648     NAT_Contact *contact;
1649     struct socket_info *sock;
1650     int port, proto, res;
1651     unsigned h;
1652     str host;
1653     FILE *f;
1654
1655     if (!keepalive_state_file)
1656         return;
1657
1658     f = fopen(keepalive_state_file, "r");
1659     if (!f) {
1660         if (errno != ENOENT)
1661             LM_ERR("failed to open keepalive state file for reading: %s\n", strerror(errno));
1662         return;
1663     }
1664
1665     now = time(NULL);
1666
1667     res = fscanf(f, STATE_FILE_HEADER); // skip header
1668
1669     while (True) {
1670         res = fscanf(f, "%63s %63s %ld %ld", uri, socket, &rtime, &stime);
1671         if (res == EOF) {
1672             if (ferror(f))
1673                 LM_ERR("error while reading keepalive state file: %s\n", strerror(errno));
1674             break;
1675         } else if (res != 4) {
1676             LM_ERR("invalid/corrupted keepalive state file. ignoring remaining entries.\n");
1677             break;
1678         } else {
1679             if (now > rtime && now > stime)
1680                 continue; // expired entry
1681
1682             if (parse_phostport(socket, &host.s, &host.len, &port, &proto) < 0)
1683                 continue;
1684
1685             sock = grep_sock_info(&host, (unsigned short)port, (unsigned short)proto);
1686             if (!sock)
1687                 continue; // socket no longer available since last time. ignore.
1688
1689             h = HASH(nat_table, uri);
1690             contact = NAT_Contact_new(uri, sock);
1691             if (contact) {
1692                 SIP_Registration_update(contact, rtime);
1693                 SIP_Subscription_update(contact, stime);
1694                 contact->next = nat_table->slots[h].head;
1695                 nat_table->slots[h].head = contact;
1696             } else {
1697                 LM_ERR("cannot allocate shared memory for new NAT contact\n");
1698                 break;
1699             }
1700         }
1701     }
1702
1703     fclose(f);
1704 }
1705
1706
1707 // Module management: initialization/destroy/function-parameter-fixing/...
1708 //
1709
1710 static int
1711 mod_init(void)
1712 {
1713         sl_cbelem_t slcb;
1714     int *param;
1715         modparam_t type;
1716
1717     if (keepalive_interval <= 0) {
1718         LM_NOTICE("keepalive functionality is disabled from the configuration\n");
1719         keepalive_disabled = True;
1720         return 0;
1721     }
1722
1723         /* bind the SL API */
1724         if (sl_load_api(&slb)!=0) {
1725                 LM_ERR("cannot bind to SL API\n");
1726                 return -1;
1727         }
1728     // set SL module callback function
1729         memset(&slcb, 0, sizeof(sl_cbelem_t));
1730         slcb.type = SLCB_REPLY_READY;
1731         slcb.cbf = __sl_reply_out;
1732     if (slb.register_cb(&slcb) != 0) {
1733         LM_ERR("cannot register callback for stateless outgoing replies\n");
1734         return -1;
1735     }
1736
1737     // bind to the TM API
1738     if (load_tm_api(&tm_api)!=0) {
1739         LM_ERR("cannot load the tm module API\n");
1740         return -1;
1741     }
1742
1743     // bind to the dialog API
1744     if (load_dlg_api(&dlg_api)==0) {
1745         // load dlg_flag and default_timeout parameters from the dialog module
1746         param = find_param_export(find_module_by_name("dialog"),
1747                                 "dlg_flag", INT_PARAM, &type);
1748         if (param) {
1749                 have_dlg_api = True;
1750
1751                 dialog_flag = *param;
1752
1753                 param = find_param_export(find_module_by_name("dialog"),
1754                                         "default_timeout", INT_PARAM, &type);
1755                 if (!param) {
1756                     LM_ERR("cannot find default_timeout parameter in the dialog module\n");
1757                     return -1;
1758                 }
1759                 dialog_default_timeout = *param;
1760
1761                 // register dialog creation callback
1762                 if (dlg_api.register_dlgcb(NULL, DLGCB_CREATED, __dialog_created, NULL, NULL) != 0) {
1763                     LM_ERR("cannot register callback for dialog creation\n");
1764                     return -1;
1765                 }
1766
1767                 // register a pre-script callback to automatically enable dialog tracing
1768                 if (register_script_cb(preprocess_request, PRE_SCRIPT_CB|REQUEST_CB, 0)!=0) {
1769                     LM_ERR("could not register request preprocessing callback\n");
1770                     return -1;
1771                 }
1772         }
1773     }
1774     if (!have_dlg_api) {
1775         LM_NOTICE("keeping alive dialogs is disabled because the dialog module is not loaded\n");
1776     }
1777
1778     // initialize the keepalive message parameters
1779     if (keepalive_params.from!=NULL && *(keepalive_params.from)==0) {
1780         LM_WARN("ignoring empty keepalive_from parameter\n");
1781         keepalive_params.from = NULL;
1782     }
1783     if (strcasecmp(keepalive_params.method, "NOTIFY")==0)
1784         keepalive_params.event_header = "Event: keep-alive\r\n";
1785     snprintf(keepalive_params.callid_prefix, 20, "%x", rand());
1786     keepalive_params.callid_counter = rand();
1787     keepalive_params.from_tag = rand();
1788
1789 #ifdef STATISTICS
1790     // we need the statistics initialized before restoring the keepalive state
1791     if (register_module_stats(exports.name, statistics) < 0) {
1792         LM_ERR("failed to initialize module statistics\n");
1793         return -1;
1794     }
1795 #endif /*STATISTICS*/
1796
1797     // create hash table to hold NAT contacts
1798     nat_table = HashTable_new();
1799     if (!nat_table) {
1800         LM_ERR("cannot create hash table to store NAT endpoints\n");
1801         return -1;
1802     }
1803     restore_keepalive_state();
1804
1805     // check keepalive interval and add keepalive timer process
1806     if (keepalive_interval < 10) {
1807         LM_WARN("keepalive_interval should be at least 10 seconds\n");
1808         LM_NOTICE("using 10 seconds for keepalive_interval\n");
1809         keepalive_interval = 10;
1810     }
1811         register_dummy_timers(1);
1812
1813     return 0;
1814 }
1815
1816 static int
1817 child_init(int rank)
1818 {
1819         if (rank==PROC_MAIN) {
1820                 if(fork_dummy_timer(PROC_TIMER, "TIMER NT", 1 /*socks flag*/,
1821                                         keepalive_timer, NULL, 1 /*sec*/)<0) {
1822                         LM_ERR("failed to register keepalive timer process\n");
1823                         return -1;
1824                 }
1825         }
1826         return 0;
1827 }
1828
1829 static void
1830 mod_destroy(void)
1831 {
1832     if (nat_table) {
1833         save_keepalive_state();
1834         HashTable_del(nat_table);
1835         nat_table = NULL;
1836     }
1837 }
1838
1839
1840 // Preprocess a request before it is processed in the main script route
1841 //
1842 // Here we enable dialog tracing to be able to automatically extend an
1843 // existing registration keepalive to a destination, for the duration of
1844 // the dialog, even if the dialog source is not kept alive by explicitly
1845 // calling nat_keepalive(). This is needed to still be able to forward
1846 // messages to the callee, even if the registration keepalive expires
1847 // during the dialog and it is not renewed.
1848 //
1849 static int
1850 preprocess_request(struct sip_msg *msg, unsigned int flags, void *_param)
1851 {
1852     str totag;
1853
1854     if (msg->first_line.u.request.method_value!=METHOD_INVITE)
1855         return 1;
1856
1857     if (parse_headers(msg, HDR_TO_F, 0) == -1) {
1858         LM_ERR("failed to parse To header\n");
1859         return -1;
1860     }
1861     if (!msg->to) {
1862         LM_ERR("missing To header\n");
1863         return -1;
1864     }
1865     totag = get_to(msg)->tag_value;
1866     if (totag.s==0 || totag.len==0) {
1867         setflag(msg, dialog_flag);
1868     }
1869
1870     return 1;
1871 }
1872
1873
1874 // Filter out replies to keepalive messages
1875 //
1876 static int
1877 reply_filter(struct sip_msg *reply)
1878 {
1879     struct cseq_body *cseq;
1880     static str prefix = {NULL, 0};
1881     str call_id;
1882
1883     parse_headers(reply, HDR_VIA2_F, 0);
1884     if (reply->via2)
1885         return 1;
1886
1887     // check if the method from CSeq header matches our method
1888     if (!reply->cseq && parse_headers(reply, HDR_CSEQ_F, 0) < 0) {
1889         LM_ERR("failed to parse the CSeq header\n");
1890         return -1;
1891     }
1892     if (!reply->cseq) {
1893         LM_ERR("missing CSeq header\n");
1894         return -1;
1895     }
1896     cseq = reply->cseq->parsed;
1897     if (!STR_MATCH(cseq->method, keepalive_params.method))
1898         return 1;
1899
1900     // check if callid_prefix matches
1901     if (!reply->callid && parse_headers(reply, HDR_CALLID_F, 0) < 0) {
1902         LM_ERR("failed to parse the Call-ID header\n");
1903         return -1;
1904     }
1905     if (!reply->callid) {
1906         LM_ERR("missing Call-ID header\n");
1907         return -1;
1908     }
1909     call_id = reply->callid->body;
1910     if (prefix.s == NULL) {
1911         prefix.s = keepalive_params.callid_prefix;
1912         prefix.len = strlen(prefix.s);
1913     }
1914     if (!STR_HAS_PREFIX(call_id, prefix) || call_id.s[prefix.len]!='-')
1915         return 1;
1916
1917     return 0;
1918 }
1919
1920
1921 // Pseudo variable management
1922 //
1923
1924 static int
1925 pv_parse_nat_contact_name(pv_spec_p sp, str *in)
1926 {
1927     char *p;
1928     char *s;
1929     pv_spec_p nsp = 0;
1930
1931     if(in==NULL || in->s==NULL || sp==NULL)
1932         return -1;
1933     p = in->s;
1934     if (*p==PV_MARKER) {
1935         nsp = (pv_spec_p)pkg_malloc(sizeof(pv_spec_t));
1936         if (nsp==NULL) {
1937             LM_ERR("cannot allocate private memory\n");
1938             return -1;
1939         }
1940         s = pv_parse_spec(in, nsp);
1941         if (s==NULL) {
1942             LM_ERR("invalid name [%.*s]\n", in->len, in->s);
1943             pv_spec_free(nsp);
1944             return -1;
1945         }
1946         sp->pvp.pvn.type = PV_NAME_PVAR;
1947         sp->pvp.pvn.u.dname = (void*)nsp;
1948         return 0;
1949     }
1950
1951     sp->pvp.pvn.type = PV_NAME_INTSTR;
1952     sp->pvp.pvn.u.isname.type = AVP_NAME_STR;
1953     sp->pvp.pvn.u.isname.name.s = *in;
1954
1955     return 0;
1956 }
1957
1958
1959 static int
1960 pv_get_keepalive_socket(struct sip_msg *msg, pv_param_t *param, pv_value_t *res)
1961 {
1962     static char uri[128];
1963     NAT_Contact *contact;
1964     pv_value_t tv;
1965     unsigned h;
1966
1967     if (msg==NULL || param==NULL || res==NULL)
1968         return -1;
1969
1970     if (pv_get_spec_name(msg, param, &tv)!=0 || (!(tv.flags&PV_VAL_STR))) {
1971         LM_ERR("invalid NAT contact uri\n");
1972         return -1;
1973     }
1974
1975     if (tv.rs.len > sizeof(uri)-1) {
1976         LM_ERR("NAT contact uri too long\n");
1977         return -1;
1978     }
1979
1980     strncpy(uri, tv.rs.s, tv.rs.len);
1981     uri[tv.rs.len] = 0;
1982
1983     h = HASH(nat_table, uri);
1984     lock_get(&nat_table->slots[h].lock);
1985
1986     contact = HashTable_search(nat_table, uri, h);
1987     if (!contact) {
1988         lock_release(&nat_table->slots[h].lock);
1989         return pv_get_null(msg, param, res);
1990     }
1991
1992     res->rs = contact->socket->sock_str;
1993     res->flags = PV_VAL_STR;
1994
1995     lock_release(&nat_table->slots[h].lock);
1996
1997     return 0;
1998 }
1999
2000
2001 static int
2002 pv_get_source_uri(struct sip_msg *msg, pv_param_t *param, pv_value_t *res)
2003 {
2004     static char uri[128];
2005
2006     if (msg==NULL || res==NULL)
2007         return -1;
2008
2009     snprintf(uri, 64, "sip:%s:%d", ip_addr2a(&msg->rcv.src_ip), msg->rcv.src_port);
2010
2011     switch (msg->rcv.proto) {
2012     case PROTO_TCP:
2013         strcat(uri, ";transport=tcp");
2014         break;
2015     case PROTO_TLS:
2016         strcat(uri, ";transport=tls");
2017         break;
2018     case PROTO_SCTP:
2019         strcat(uri, ";transport=sctp");
2020         break;
2021     case PROTO_WS:
2022     case PROTO_WSS:
2023         strcat(uri, ";transport=ws");
2024         break;
2025     }
2026
2027     res->rs.s = uri;
2028     res->rs.len = strlen(uri);
2029     res->flags = PV_VAL_STR;
2030
2031     return 0;
2032 }
2033
2034