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