Increase max packet size to 4096
[asterisk/asterisk.git] / channels / chan_sip.c
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * Implementation of Session Initiation Protocol
5  * 
6  * Copyright (C) 2004, Digium, Inc.
7  *
8  * Mark Spencer <markster@digium.com>
9  *
10  * This program is free software, distributed under the terms of
11  * the GNU General Public License
12  */
13
14
15 #include <stdio.h>
16 #include <ctype.h>
17 #include <string.h>
18 #include <asterisk/lock.h>
19 #include <asterisk/channel.h>
20 #include <asterisk/channel_pvt.h>
21 #include <asterisk/config.h>
22 #include <asterisk/logger.h>
23 #include <asterisk/module.h>
24 #include <asterisk/pbx.h>
25 #include <asterisk/options.h>
26 #include <asterisk/lock.h>
27 #include <asterisk/sched.h>
28 #include <asterisk/io.h>
29 #include <asterisk/rtp.h>
30 #include <asterisk/acl.h>
31 #include <asterisk/manager.h>
32 #include <asterisk/callerid.h>
33 #include <asterisk/cli.h>
34 #include <asterisk/md5.h>
35 #include <asterisk/app.h>
36 #include <asterisk/musiconhold.h>
37 #include <asterisk/dsp.h>
38 #include <asterisk/features.h>
39 #include <asterisk/acl.h>
40 #include <asterisk/srv.h>
41 #include <asterisk/astdb.h>
42 #include <asterisk/causes.h>
43 #include <asterisk/utils.h>
44 #ifdef OSP_SUPPORT
45 #include <asterisk/astosp.h>
46 #endif
47 #include <sys/socket.h>
48 #include <sys/ioctl.h>
49 #include <net/if.h>
50 #include <errno.h>
51 #include <unistd.h>
52 #include <stdlib.h>
53 #include <fcntl.h>
54 #include <netdb.h>
55 #include <arpa/inet.h>
56 #include <signal.h>
57 #include <sys/signal.h>
58 #include <netinet/in_systm.h>
59 #include <netinet/ip.h>
60
61 #ifndef DEFAULT_USERAGENT
62 #define DEFAULT_USERAGENT "Asterisk PBX"
63 #endif
64  
65 #define VIDEO_CODEC_MASK        0x1fc0000 /* Video codecs from H.261 thru AST_FORMAT_MAX_VIDEO */
66 #ifndef IPTOS_MINCOST
67 #define IPTOS_MINCOST 0x02
68 #endif
69
70 /* #define VOCAL_DATA_HACK */
71
72 #define SIPDUMPER
73 #define DEFAULT_DEFAULT_EXPIRY  120
74 #define DEFAULT_MAX_EXPIRY      3600
75
76 /* guard limit must be larger than guard secs */
77 /* guard min must be < 1000, and should be >= 250 */
78 #define EXPIRY_GUARD_SECS       15      /* How long before expiry do we reregister */
79 #define EXPIRY_GUARD_LIMIT      30      /* Below here, we use EXPIRY_GUARD_PCT instead of EXPIRY_GUARD_SECS */
80 #define EXPIRY_GUARD_MIN        500     /* This is the minimum guard time applied. If GUARD_PCT turns out
81                                         to be lower than this, it will use this time instead. This is in
82                                         milliseconds. */
83 #define EXPIRY_GUARD_PCT        0.20    /* Percentage of expires timeout to use when below EXPIRY_GUARD_LIMIT */
84
85 #ifndef MAX
86 #define MAX(a,b) ((a) > (b) ? (a) : (b))
87 #endif
88
89 #define CALLERID_UNKNOWN        "Unknown"
90
91 /* --- Choices for DTMF support in SIP channel */
92 #define SIP_DTMF_RFC2833        (1 << 0)
93 #define SIP_DTMF_INBAND         (1 << 1)
94 #define SIP_DTMF_INFO           (1 << 2)
95
96 static int max_expiry = DEFAULT_MAX_EXPIRY;
97 static int default_expiry = DEFAULT_DEFAULT_EXPIRY;
98
99 #define DEFAULT_MAXMS           2000            /* Must be faster than 2 seconds by default */
100 #define DEFAULT_FREQ_OK         60 * 1000               /* How often to check for the host to be up */
101 #define DEFAULT_FREQ_NOTOK      10 * 1000               /* How often to check, if the host is down... */
102
103 #define DEFAULT_RETRANS         1000                    /* How frequently to retransmit */
104 #define MAX_RETRANS             5                       /* Try only 5 times for retransmissions */
105
106                                                         /* SIP Debug            */
107 #define DEBUG_READ      0                               /* Recieved data        */
108 #define DEBUG_SEND      1                               /* Transmit data        */
109
110 static char *desc = "Session Initiation Protocol (SIP)";
111 static char *type = "SIP";
112 static char *tdesc = "Session Initiation Protocol (SIP)";
113 static char *config = "sip.conf";
114
115 #define DEFAULT_SIP_PORT        5060    /* From RFC 2543 */
116 #define SIP_MAX_PACKET  4096            /* Also from RFC 2543, should sub headers tho */
117
118 #define ALLOWED_METHODS "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER"
119
120 static char default_useragent[AST_MAX_EXTENSION] = DEFAULT_USERAGENT;
121
122 static char default_context[AST_MAX_EXTENSION] = "default";
123
124 static char default_language[MAX_LANGUAGE] = "";
125
126 static char default_callerid[AST_MAX_EXTENSION] = "asterisk";
127
128 static char default_fromdomain[AST_MAX_EXTENSION] = "";
129
130 static char notifymime[AST_MAX_EXTENSION] = "application/simple-message-summary";
131
132 static int srvlookup = 0;
133
134 static int pedanticsipchecking = 0;
135
136 static int autocreatepeer = 0;          
137
138 static int relaxdtmf = 0;
139
140 static int global_rtptimeout = 0;
141
142 static int global_rtpholdtimeout = 0;
143
144 static int global_trustrpid = 0;
145
146 static int global_progressinband = 0;
147
148 #ifdef OSP_SUPPORT
149 static int global_ospauth = 0;
150 #endif
151
152 static int usecnt =0;
153 AST_MUTEX_DEFINE_STATIC(usecnt_lock);
154
155 /* Protect the interface list (of sip_pvt's) */
156 AST_MUTEX_DEFINE_STATIC(iflock);
157
158 /* Protect the monitoring thread, so only one process can kill or start it, and not
159    when it's doing something critical. */
160 AST_MUTEX_DEFINE_STATIC(netlock);
161
162 AST_MUTEX_DEFINE_STATIC(monlock);
163
164 /* This is the thread for the monitor which checks for input on the channels
165    which are not currently in use.  */
166 static pthread_t monitor_thread = AST_PTHREADT_NULL;
167
168 static int restart_monitor(void);
169
170 /* Codecs that we support by default: */
171 static int global_capability = AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_GSM | AST_FORMAT_H263;
172 static int noncodeccapability = AST_RTP_DTMF;
173
174 static char ourhost[256];
175 static struct in_addr __ourip;
176 static int ourport;
177
178 static int sipdebug = 0;
179 static struct sockaddr_in debugaddr;
180
181 static int tos = 0;
182
183 static int videosupport = 0;
184
185 static int global_dtmfmode = SIP_DTMF_RFC2833;          /* DTMF mode default */
186 static int recordhistory = 0;
187 static int global_promiscredir;
188
189 static char global_musicclass[MAX_LANGUAGE] = "";       /* Global music on hold class */
190 static char global_realm[AST_MAX_EXTENSION] = "asterisk";       /* Default realm */
191 static char regcontext[AST_MAX_EXTENSION] = "";
192
193 /* Expire slowly */
194 static int expiry = 900;
195
196 static struct sched_context *sched;
197 static struct io_context *io;
198 /* The private structures of the  sip channels are linked for
199    selecting outgoing channels */
200    
201 #define SIP_MAX_HEADERS         64
202 #define SIP_MAX_LINES           64
203
204 #define DEC_IN_USE      0
205 #define INC_IN_USE      1
206 #define DEC_OUT_USE     2
207 #define INC_OUT_USE     3
208
209 static struct sip_codec_pref {
210         int codec;
211         struct sip_codec_pref *next;
212 } *prefs;
213
214 /* sip_request: The data grabbed from the UDP socket */
215 struct sip_request {
216   char *rlPart1; /* SIP Method Name or "SIP/2.0" protocol version */
217   char *rlPart2; /* The Request URI or Response Status */
218         int len;
219         int headers;                                    /* SIP Headers */
220         char *header[SIP_MAX_HEADERS];
221         int lines;                                              /* SDP Content */
222         char *line[SIP_MAX_LINES];
223         char data[SIP_MAX_PACKET];
224 };
225
226 struct sip_pkt;
227
228 struct sip_route {
229         struct sip_route *next;
230         char hop[0];
231 };
232
233 struct sip_history {
234         char event[80];
235         struct sip_history *next;
236 };
237
238 /* sip_pvt: PVT structures are used for each SIP conversation, ie. a call  */
239 static struct sip_pvt {
240         ast_mutex_t lock;                       /* Channel private lock */
241         char callid[80];                        /* Global CallID */
242         char randdata[80];                      /* Random data */
243         unsigned int ocseq;                     /* Current outgoing seqno */
244         unsigned int icseq;                     /* Current incoming seqno */
245         unsigned int callgroup;                 /* Call group */
246         unsigned int pickupgroup;               /* Pickup group */
247         int lastinvite;                         /* Last Cseq of invite */
248         int alreadygone;                        /* Whether or not we've already been destroyed by or peer */
249         int needdestroy;                        /* if we need to be destroyed */
250         int capability;                         /* Special capability (codec) */
251         int novideo;                            /* Didn't get video in invite, don't offer */
252         int jointcapability;                    /* Supported capability at both ends (codecs ) */
253         int peercapability;                     /* Supported peer capability */
254         int prefcodec;                          /* Preferred codec (outbound only) */
255         int noncodeccapability;
256         int callingpres;                        /* Calling presentation */
257         int outgoing;                           /* Outgoing or incoming call? */
258         int authtries;                          /* Times we've tried to authenticate */
259         int insecure;                           /* Don't check source port/ip */
260         int expiry;                             /* How long we take to expire */
261         int branch;                             /* One random number */
262         int canreinvite;                        /* Do we support reinvite */
263         int ringing;                            /* Have sent 180 ringing */
264         int progress;                           /* Have sent 183 message progress */
265         int tag;                                /* Another random number */
266         int nat;                                /* Whether to try to support NAT */
267         int sessionid;                          /* SDP Session ID */
268         int sessionversion;                     /* SDP Session Version */
269         struct sockaddr_in sa;                  /* Our peer */
270         struct sockaddr_in redirip;             /* Where our RTP should be going if not to us */
271         struct sockaddr_in vredirip;            /* Where our Video RTP should be going if not to us */
272         int redircodecs;                                /* Redirect codecs */
273         struct sockaddr_in recv;                /* Received as */
274         struct in_addr ourip;                   /* Our IP */
275         struct ast_channel *owner;              /* Who owns us */
276         char exten[AST_MAX_EXTENSION];          /* Extension where to start */
277         char refer_to[AST_MAX_EXTENSION];       /* Place to store REFER-TO extension */
278         char referred_by[AST_MAX_EXTENSION];    /* Place to store REFERRED-BY extension */
279         char refer_contact[AST_MAX_EXTENSION];  /* Place to store Contact info from a REFER extension */
280         struct sip_pvt *refer_call;             /* Call we are referring */
281         struct sip_route *route;                /* Head of linked list of routing steps (fm Record-Route) */
282         int route_persistant;                   /* Is this the "real" route? */
283         char from[256];                         /* The From: header */
284         char useragent[256];                    /* User agent in SIP request */
285         char context[AST_MAX_EXTENSION];        /* Context for this call */
286         char fromdomain[AST_MAX_EXTENSION];     /* Domain to show in the from field */
287         char fromuser[AST_MAX_EXTENSION];       /* Domain to show in the user field */
288         char tohost[AST_MAX_EXTENSION];         /* Host we should put in the "to" field */
289         char language[MAX_LANGUAGE];            /* Default language for this call */
290         char musicclass[MAX_LANGUAGE];          /* Music on Hold class */
291         char rdnis[256];                        /* Referring DNIS */
292         char theirtag[256];                     /* Their tag */
293         char username[256];
294         char peername[256];
295         char authname[256];                     /* Who we use for authentication */
296         char uri[256];                          /* Original requested URI */
297         char peersecret[256];
298         char peermd5secret[256];
299         char cid_num[256];                      /* Caller*ID */
300         char cid_name[256];                     /* Caller*ID */
301         char via[256];
302         char fullcontact[128];          /* Extra parameters to go in the "To" header */
303         char accountcode[20];                   /* Account code */
304         char our_contact[256];                  /* Our contact header */
305         char realm[256];                        /* Authorization realm */
306         char nonce[256];                        /* Authorization nonce */
307         char opaque[256];                       /* Opaque nonsense */
308         char qop[80];                           /* Quality of Protection, since SIP wasn't complicated enough yet. */
309         char domain[256];                       /* Authorization nonce */
310         char lastmsg[256];                      /* Last Message sent/received */
311         int amaflags;                           /* AMA Flags */
312         int pendinginvite;                      /* Any pending invite */
313         int needreinvite;                       /* Do we need to send another reinvite? */
314         int pendingbye;                         /* Need to send bye after we ack? */
315         int gotrefer;                           /* Got a refer? */
316 #ifdef OSP_SUPPORT
317         int ospauth;                            /* Allow OSP Authentication */
318         int osphandle;                          /* OSP Handle for call */
319         time_t ospstart;                        /* OSP Start time */
320 #endif
321         struct sip_request initreq;             /* Initial request */
322         
323         int maxtime;                            /* Max time for first response */
324         int initid;                             /* Auto-congest ID if appropriate */
325         int autokillid;                         /* Auto-kill ID */
326         time_t lastrtprx;                       /* Last RTP received */
327         int rtptimeout;                         /* RTP timeout time */
328         int rtpholdtimeout;                     /* RTP timeout when on hold */
329
330         int subscribed;
331         int stateid;
332         int dialogver;
333         int promiscredir;                       /* Promiscuous redirection */
334         
335         int trustrpid;
336         int progressinband;
337         
338         int dtmfmode;
339         struct ast_dsp *vad;
340         
341         struct sip_peer *peerpoke;              /* If this calls is to poke a peer, which one */
342         struct sip_registry *registry;          /* If this is a REGISTER call, to which registry */
343         struct ast_rtp *rtp;                    /* RTP Session */
344         struct ast_rtp *vrtp;                   /* Video RTP session */
345         struct sip_pkt *packets;                /* Packets scheduled for re-transmission */
346         struct sip_history *history;    /* History of this SIP dialog */
347         struct sip_pvt *next;                   /* Next call in chain */
348 } *iflist = NULL;
349
350 #define FLAG_RESPONSE (1 << 0)
351 #define FLAG_FATAL (1 << 1)
352
353 /* sip packet - read in sipsock_read, transmitted in send_request */
354 struct sip_pkt {
355         struct sip_pkt *next;                           /* Next packet */
356         int retrans;                                            /* Retransmission number */
357         int seqno;                                                      /* Sequence number */
358         int flags;                                                      /* non-zero if this is a response packet (e.g. 200 OK) */
359         struct sip_pvt *owner;                          /* Owner call */
360         int retransid;                                          /* Retransmission ID */
361         int packetlen;                                          /* Length of packet */
362         char data[0];
363 };      
364
365 /* Structure for SIP user data. User's place calls to us */
366 struct sip_user {
367         /* Users who can access various contexts */
368         char name[80];
369         char secret[80];
370         char md5secret[80];
371         char context[80];
372         char cid_num[80];
373         char cid_name[80];
374         char accountcode[20];
375         char language[MAX_LANGUAGE];
376         char musicclass[MAX_LANGUAGE];  /* Music on Hold class */
377         char useragent[256];            /* User agent in SIP request */
378         unsigned int callgroup;
379         unsigned int pickupgroup;
380         int nat;
381         int hascallerid;
382         int amaflags;
383         int callingpres;
384         int insecure;
385         int canreinvite;
386         int capability;
387 #ifdef OSP_SUPPORT
388         int ospauth;                            /* Allow OSP Authentication */
389 #endif
390         int dtmfmode;
391         int inUse;
392         int incominglimit;
393         int outUse;
394         int outgoinglimit;
395         int promiscredir;
396         int trustrpid;
397         int progressinband;
398         struct ast_ha *ha;
399         int temponly;
400         struct sip_user *next;
401 };
402
403 /* Structure for SIP peer data, we place calls to peers if registred  or fixed IP address (host) */
404 struct sip_peer {
405         char name[80];
406         char secret[80];
407         char md5secret[80];
408         char context[80];               /* JK02: peers need context too to allow parking etc */
409         char username[80];
410         char tohost[80];
411         char regexten[AST_MAX_EXTENSION];       /* Extension to register (if regcontext is used) */
412         char fromuser[80];
413         char fromdomain[80];
414         char fullcontact[128];
415         char mailbox[AST_MAX_EXTENSION];
416         char language[MAX_LANGUAGE];
417         char musicclass[MAX_LANGUAGE];  /* Music on Hold class */
418         char useragent[256];            /* User agent in SIP request */
419         int lastmsgssent;
420         time_t  lastmsgcheck;
421         int dynamic;
422         int expire;
423         int expiry;
424         int capability;
425         int rtptimeout;
426         int rtpholdtimeout;
427         int insecure;
428 #ifdef OSP_SUPPORT
429         int ospauth;                            /* Allow OSP Authentication */
430 #endif  
431         int nat;
432         int canreinvite;
433         unsigned int callgroup;
434         unsigned int pickupgroup;
435         int promiscredir;
436         int dtmfmode;
437         int trustrpid;
438         int progressinband;
439         struct sockaddr_in addr;
440         struct in_addr mask;
441
442         /* Qualification */
443         struct sip_pvt *call;           /* Call pointer */
444         int pokeexpire;                         /* When to expire poke */
445         int lastms;                                     /* How long last response took (in ms), or -1 for no response */
446         int maxms;                                      /* Max ms we will accept for the host to be up, 0 to not monitor */
447         struct timeval ps;                      /* Ping send time */
448         
449         struct sockaddr_in defaddr;
450         struct ast_ha *ha;
451         int delme;
452         int selfdestruct;
453         int lastmsg;
454         int temponly;
455         struct sip_peer *next;
456 };
457
458 AST_MUTEX_DEFINE_STATIC(sip_reload_lock);
459 static int sip_reloading = 0;
460
461 #define REG_STATE_UNREGISTERED 0
462 #define REG_STATE_REGSENT          1
463 #define REG_STATE_AUTHSENT         2
464 #define REG_STATE_REGISTERED   3
465 #define REG_STATE_REJECTED         4
466 #define REG_STATE_TIMEOUT          5
467 #define REG_STATE_NOAUTH           6
468
469 #define SIP_NAT_NEVER           0
470 #define SIP_NAT_RFC3581         (1 << 0)
471 #define SIP_NAT_ROUTE           (1 << 2)
472 #define SIP_NAT_ALWAYS          (SIP_NAT_ROUTE | SIP_NAT_RFC3581)
473
474 /* sip_registry: Registrations with other SIP proxies */
475 struct sip_registry {
476         int portno;                             /* Optional port override */
477         char username[80];              /* Who we are registering as */
478         char authuser[80];              /* Who we *authenticate* as */
479         char hostname[80];
480         char secret[80];                /* Password or key name in []'s */      
481         char md5secret[80];
482         char contact[80];               /* Contact extension */
483         char random[80];
484         int expire;                     /* Sched ID of expiration */
485         int timeout;                    /* sched id of sip_reg_timeout */
486         int refresh;                    /* How often to refresh */
487         struct sip_pvt *call;           /* create a sip_pvt structure for each outbound "registration call" in progress */
488         int regstate;
489         int callid_valid;               /* 0 means we haven't chosen callid for this registry yet. */
490         char callid[80];                /* Global CallID for this registry */
491         unsigned int ocseq;             /* Sequence number we got to for REGISTERs for this registry */
492         struct sockaddr_in us;          /* Who the server thinks we are */
493         struct sip_registry *next;
494 };
495
496 /*--- The user list: Users and friends ---*/
497 static struct ast_user_list {
498         struct sip_user *users;
499         ast_mutex_t lock;
500 } userl;
501
502 /*--- The peer list: Peers and Friends ---*/
503 static struct ast_peer_list {
504         struct sip_peer *peers;
505         ast_mutex_t lock;
506 } peerl;
507
508 /*--- The register list: Other SIP proxys we register with and call ---*/
509 static struct ast_register_list {
510         struct sip_registry *registrations;
511         ast_mutex_t lock;
512         int recheck;
513 } regl;
514
515
516 #define REINVITE_INVITE         1
517 #define REINVITE_UPDATE         2
518
519 static int __sip_do_register(struct sip_registry *r);
520
521 static int sipsock  = -1;
522 static int global_nat = SIP_NAT_RFC3581;
523 static int global_canreinvite = REINVITE_INVITE;
524
525
526 static struct sockaddr_in bindaddr;
527 static struct sockaddr_in externip;
528 static struct ast_ha *localaddr;
529
530 static struct ast_frame  *sip_read(struct ast_channel *ast);
531 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req);
532 static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans);
533 static int transmit_response_with_auth(struct sip_pvt *p, char *msg, struct sip_request *req, char *rand, int reliable, char *header);
534 static int transmit_request(struct sip_pvt *p, char *msg, int inc, int reliable, int newbranch);
535 static int transmit_request_with_auth(struct sip_pvt *p, char *msg, int inc, int reliable, int newbranch);
536 static int transmit_invite(struct sip_pvt *p, char *msg, int sendsdp, char *auth, char *authheader, char *vxml_url,char *distinctive_ring, char *osptoken,int init);
537 static int transmit_reinvite_with_sdp(struct sip_pvt *p);
538 static int transmit_info_with_digit(struct sip_pvt *p, char digit);
539 static int transmit_message_with_text(struct sip_pvt *p, char *text);
540 static int transmit_refer(struct sip_pvt *p, char *dest);
541 static struct sip_peer *temp_peer(char *name);
542 static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader, char *msg, int init);
543 static void free_old_route(struct sip_route *route);
544 static int build_reply_digest(struct sip_pvt *p, char *orig_header, char *digest, int digest_len);
545 static int update_user_counter(struct sip_pvt *fup, int event);
546 static void prune_peers(void);
547 static int sip_do_reload(void);
548
549
550 /*--- sip_debug_test_addr: See if we pass debug IP filter */
551 static inline int sip_debug_test_addr(struct sockaddr_in *addr) 
552 {
553         if (sipdebug == 0)
554                 return 0;
555         if (debugaddr.sin_addr.s_addr) {
556                 if (((ntohs(debugaddr.sin_port) != 0)
557                         && (debugaddr.sin_port != addr->sin_port))
558                         || (debugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
559                         return 0;
560         }
561         return 1;
562 }
563
564 static inline int sip_debug_test_pvt(struct sip_pvt *p) 
565 {
566         if (sipdebug == 0)
567                 return 0;
568         return sip_debug_test_addr(((p->nat & SIP_NAT_ROUTE) ? &p->recv : &p->sa));
569 }
570
571
572 /*--- __sip_xmit: Transmit SIP message ---*/
573 static int __sip_xmit(struct sip_pvt *p, char *data, int len)
574 {
575         int res;
576         char iabuf[INET_ADDRSTRLEN];
577         if (p->nat & SIP_NAT_ROUTE)
578             res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->recv, sizeof(struct sockaddr_in));
579         else
580             res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->sa, sizeof(struct sockaddr_in));
581         if (res != len) {
582                 ast_log(LOG_WARNING, "sip_xmit of %p (len %d) to %s returned %d: %s\n", data, len, ast_inet_ntoa(iabuf, sizeof(iabuf), p->sa.sin_addr), res, strerror(errno));
583         }
584         return res;
585 }
586
587 static void sip_destroy(struct sip_pvt *p);
588
589 /*--- ast_sip_ouraddrfor: NAT fix - decide which IP address to use for ASterisk server? ---*/
590 /* Only used for outbound registrations */
591 static int ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us)
592 {
593         /*
594          * Using the localaddr structure built up with localnet statements
595          * apply it to their address to see if we need to substitute our
596          * externip or can get away with our internal bindaddr
597          */
598         struct sockaddr_in theirs;
599         theirs.sin_addr = *them;
600         if (localaddr && externip.sin_addr.s_addr &&
601            ast_apply_ha(localaddr, &theirs)) {
602                 char iabuf[INET_ADDRSTRLEN];
603                 memcpy(us, &externip.sin_addr, sizeof(struct in_addr));
604                 ast_inet_ntoa(iabuf, sizeof(iabuf), *(struct in_addr *)&them->s_addr);
605                 ast_log(LOG_DEBUG, "Target address %s is not local, substituting externip\n", iabuf);
606         }
607         else if (bindaddr.sin_addr.s_addr)
608                 memcpy(us, &bindaddr.sin_addr, sizeof(struct in_addr));
609         else
610                 return ast_ouraddrfor(them, us);
611         return 0;
612 }
613
614 static int append_history(struct sip_pvt *p, char *event, char *data)
615 {
616         struct sip_history *hist, *prev;
617         char *c;
618         if (!recordhistory)
619                 return 0;
620         hist = malloc(sizeof(struct sip_history));
621         if (hist) {
622                 memset(hist, 0, sizeof(struct sip_history));
623                 snprintf(hist->event, sizeof(hist->event), "%-15s %s", event, data);
624                 /* Trim up nicely */
625                 c = hist->event;
626                 while(*c) {
627                         if ((*c == '\r') || (*c == '\n')) {
628                                 *c = '\0';
629                                 break;
630                         }
631                         c++;
632                 }
633                 /* Enqueue into history */
634                 prev = p->history;
635                 if (prev) {
636                         while(prev->next)
637                                 prev = prev->next;
638                         prev->next = hist;
639                 } else {
640                         p->history = hist;
641                 }
642         }
643         return 0;
644 }
645
646 /*--- retrans_pkt: Retransmit SIP message if no answer ---*/
647 static int retrans_pkt(void *data)
648 {
649         struct sip_pkt *pkt=data, *prev, *cur;
650         int res = 0;
651         char iabuf[INET_ADDRSTRLEN];
652         ast_mutex_lock(&pkt->owner->lock);
653         if (pkt->retrans < MAX_RETRANS) {
654                 pkt->retrans++;
655                 if (sip_debug_test_pvt(pkt->owner)) {
656                         if (pkt->owner->nat & SIP_NAT_ROUTE)
657                                 ast_verbose("Retransmitting #%d (NAT):\n%s\n to %s:%d\n", pkt->retrans, pkt->data, ast_inet_ntoa(iabuf, sizeof(iabuf), pkt->owner->recv.sin_addr), ntohs(pkt->owner->recv.sin_port));
658                         else
659                                 ast_verbose("Retransmitting #%d (no NAT):\n%s\n to %s:%d\n", pkt->retrans, pkt->data, ast_inet_ntoa(iabuf, sizeof(iabuf), pkt->owner->sa.sin_addr), ntohs(pkt->owner->sa.sin_port));
660                 }
661                 append_history(pkt->owner, "ReTx", pkt->data);
662                 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
663                 res = 1;
664         } else {
665                 ast_log(LOG_WARNING, "Maximum retries exceeded on call %s for seqno %d (%s %s)\n", pkt->owner->callid, pkt->seqno, (pkt->flags & FLAG_FATAL) ? "Critical" : "Non-critical", (pkt->flags & FLAG_RESPONSE) ? "Response" : "Request");
666                 append_history(pkt->owner, "MaxRetries", pkt->flags & FLAG_FATAL ? "(Critical)" : "(Non-critical)");
667                 pkt->retransid = -1;
668                 if (pkt->flags & FLAG_FATAL) {
669                         while(pkt->owner->owner && ast_mutex_trylock(&pkt->owner->owner->lock)) {
670                                 ast_mutex_unlock(&pkt->owner->lock);
671                                 usleep(1);
672                                 ast_mutex_lock(&pkt->owner->lock);
673                         }
674                         if (pkt->owner->owner) {
675                                 ast_queue_hangup(pkt->owner->owner);
676                                 ast_mutex_unlock(&pkt->owner->owner->lock);
677                         } else {
678                                 /* If no owner, destroy now */
679                                 pkt->owner->needdestroy = 1;
680                         }
681                 }
682                 /* In any case, go ahead and remove the packet */
683                 prev = NULL;
684                 cur = pkt->owner->packets;
685                 while(cur) {
686                         if (cur == pkt)
687                                 break;
688                         prev = cur;
689                         cur = cur->next;
690                 }
691                 if (cur) {
692                         if (prev)
693                                 prev->next = cur->next;
694                         else
695                                 pkt->owner->packets = cur->next;
696                         ast_mutex_unlock(&pkt->owner->lock);
697                         free(cur);
698                         pkt = NULL;
699                 } else
700                         ast_log(LOG_WARNING, "Weird, couldn't find packet owner!\n");
701         }
702         if (pkt)
703                 ast_mutex_unlock(&pkt->owner->lock);
704         return res;
705 }
706
707 /*--- __sip_reliable_xmit: transmit packet with retransmits ---*/
708 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal)
709 {
710         struct sip_pkt *pkt;
711         pkt = malloc(sizeof(struct sip_pkt) + len + 1);
712         if (!pkt)
713                 return -1;
714         memset(pkt, 0, sizeof(struct sip_pkt));
715         memcpy(pkt->data, data, len);
716         pkt->packetlen = len;
717         pkt->next = p->packets;
718         pkt->owner = p;
719         pkt->seqno = seqno;
720         pkt->flags = resp;
721         pkt->data[len] = '\0';
722         if (fatal)
723                 pkt->flags |= FLAG_FATAL;
724         /* Schedule retransmission */
725         pkt->retransid = ast_sched_add(sched, DEFAULT_RETRANS, retrans_pkt, pkt);
726         pkt->next = p->packets;
727         p->packets = pkt;
728         __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
729         if (!strncasecmp(pkt->data, "INVITE", 6)) {
730                 /* Note this is a pending invite */
731                 p->pendinginvite = seqno;
732         }
733         return 0;
734 }
735
736 /*--- __sip_autodestruct: Kill a call (called by scheduler) ---*/
737 static int __sip_autodestruct(void *data)
738 {
739         struct sip_pvt *p = data;
740         p->autokillid = -1;
741         ast_log(LOG_DEBUG, "Auto destroying call '%s'\n", p->callid);
742         append_history(p, "AutoDestroy", "");
743         if (p->owner) {
744                 ast_log(LOG_WARNING, "Autodestruct on call '%s' with owner in place\n", p->callid);
745                 ast_queue_hangup(p->owner);
746         } else {
747                 sip_destroy(p);
748         }
749         return 0;
750 }
751
752 /*--- sip_scheddestroy: Schedule destruction of SIP call ---*/
753 static int sip_scheddestroy(struct sip_pvt *p, int ms)
754 {
755         char tmp[80];
756         if (sip_debug_test_pvt(p))
757                 ast_verbose("Scheduling destruction of call '%s' in %d ms\n", p->callid, ms);
758         if (recordhistory) {
759                 snprintf(tmp, sizeof(tmp), "%d ms", ms);
760                 append_history(p, "SchedDestroy", tmp);
761         }
762         if (p->autokillid > -1)
763                 ast_sched_del(sched, p->autokillid);
764         p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, p);
765         return 0;
766 }
767
768 /*--- sip_cancel_destroy: Cancel destruction of SIP call ---*/
769 static int sip_cancel_destroy(struct sip_pvt *p)
770 {
771         if (p->autokillid > -1)
772                 ast_sched_del(sched, p->autokillid);
773         append_history(p, "CancelDestroy", "");
774         p->autokillid = -1;
775         return 0;
776 }
777
778 /*--- __sip_ack: Acknowledges receipt of a packet and stops retransmission ---*/
779 static int __sip_ack(struct sip_pvt *p, int seqno, int resp, const char *msg)
780 {
781         struct sip_pkt *cur, *prev = NULL;
782         int res = -1;
783         int resetinvite = 0;
784         /* Just in case... */
785         if (!msg) msg = "___NEVER___";
786         cur = p->packets;
787         while(cur) {
788                 if ((cur->seqno == seqno) && ((cur->flags & FLAG_RESPONSE) == resp) &&
789                         ((cur->flags & FLAG_RESPONSE) || 
790                          (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
791                         if (!resp && (seqno == p->pendinginvite)) {
792                                 ast_log(LOG_DEBUG, "Acked pending invite %d\n", p->pendinginvite);
793                                 p->pendinginvite = 0;
794                                 resetinvite = 1;
795                         }
796                         /* this is our baby */
797                         if (prev)
798                                 prev->next = cur->next;
799                         else
800                                 p->packets = cur->next;
801                         if (cur->retransid > -1)
802                                 ast_sched_del(sched, cur->retransid);
803                         free(cur);
804                         res = 0;
805                         break;
806                 }
807                 prev = cur;
808                 cur = cur->next;
809         }
810         ast_log(LOG_DEBUG, "Stopping retransmission on '%s' of %s %d: %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
811         return res;
812 }
813
814 /* Pretend to ack all packets */
815 static int __sip_pretend_ack(struct sip_pvt *p)
816 {
817         while(p->packets) {
818                 __sip_ack(p, p->packets->seqno, (p->packets->flags & FLAG_RESPONSE), p->packets->data);
819         }
820         return 0;
821 }
822
823 /*--- __sip_semi_ack: Acks receipt of packet, keep it around (used for provisional responses) ---*/
824 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp, const char *msg)
825 {
826         struct sip_pkt *cur;
827         int res = -1;
828         cur = p->packets;
829         while(cur) {
830                 if ((cur->seqno == seqno) && ((cur->flags & FLAG_RESPONSE) == resp) &&
831                         ((cur->flags & FLAG_RESPONSE) || 
832                          (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
833                         /* this is our baby */
834                         if (cur->retransid > -1)
835                                 ast_sched_del(sched, cur->retransid);
836                         cur->retransid = -1;
837                         res = 0;
838                         break;
839                 }
840                 cur = cur->next;
841         }
842         ast_log(LOG_DEBUG, "(Provisional) Stopping retransmission (but retaining packet) on '%s' %s %d: %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
843         return res;
844 }
845
846 static void parse(struct sip_request *req);
847 static char *get_header(struct sip_request *req, char *name);
848 static void copy_request(struct sip_request *dst,struct sip_request *src);
849
850 static void parse_copy(struct sip_request *dst, struct sip_request *src)
851 {
852         memset(dst, 0, sizeof(*dst));
853         memcpy(dst->data, src->data, sizeof(dst->data));
854         dst->len = src->len;
855         parse(dst);
856 }
857 /*--- send_response: Transmit response on SIP request---*/
858 static int send_response(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
859 {
860         int res;
861         char iabuf[INET_ADDRSTRLEN];
862         struct sip_request tmp;
863         char tmpmsg[80];
864         if (sip_debug_test_pvt(p)) {
865                 if (p->nat & SIP_NAT_ROUTE)
866                         ast_verbose("%sTransmitting (NAT):\n%s\n to %s:%d\n", reliable ? "Reliably " : "", req->data, ast_inet_ntoa(iabuf, sizeof(iabuf), p->recv.sin_addr), ntohs(p->recv.sin_port));
867                 else
868                         ast_verbose("%sTransmitting (no NAT):\n%s\n to %s:%d\n", reliable ? "Reliably " : "", req->data, ast_inet_ntoa(iabuf, sizeof(iabuf), p->sa.sin_addr), ntohs(p->sa.sin_port));
869         }
870         if (reliable) {
871                 if (recordhistory) {
872                         parse_copy(&tmp, req);
873                         snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
874                         append_history(p, "TxRespRel", tmpmsg);
875                 }
876                 res = __sip_reliable_xmit(p, seqno, 1, req->data, req->len, (reliable > 1));
877         } else {
878                 if (recordhistory) {
879                         parse_copy(&tmp, req);
880                         snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
881                         append_history(p, "TxResp", tmpmsg);
882                 }
883                 res = __sip_xmit(p, req->data, req->len);
884         }
885         if (res > 0)
886                 res = 0;
887         return res;
888 }
889
890 /*--- send_request: Send SIP Request to the other part of the dialogue ---*/
891 static int send_request(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
892 {
893         int res;
894         char iabuf[INET_ADDRSTRLEN];
895         struct sip_request tmp;
896         char tmpmsg[80];
897         if (sip_debug_test_pvt(p)) {
898                 if (p->nat & SIP_NAT_ROUTE)
899                         ast_verbose("%sTransmitting:\n%s (NAT) to %s:%d\n", reliable ? "Reliably " : "", req->data, ast_inet_ntoa(iabuf, sizeof(iabuf), p->recv.sin_addr), ntohs(p->recv.sin_port));
900                 else
901                         ast_verbose("%sTransmitting:\n%s (no NAT) to %s:%d\n", reliable ? "Reliably " : "", req->data, ast_inet_ntoa(iabuf, sizeof(iabuf), p->sa.sin_addr), ntohs(p->sa.sin_port));
902         }
903         if (reliable) {
904                 if (recordhistory) {
905                         parse_copy(&tmp, req);
906                         snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
907                         append_history(p, "TxReqRel", tmpmsg);
908                 }
909                 res = __sip_reliable_xmit(p, seqno, 0, req->data, req->len, (reliable > 1));
910         } else {
911                 if (recordhistory) {
912                         parse_copy(&tmp, req);
913                         snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
914                         append_history(p, "TxReq", tmpmsg);
915                 }
916                 res = __sip_xmit(p, req->data, req->len);
917         }
918         return res;
919 }
920
921 /*--- url_decode: Decode SIP URL  ---*/
922 static void url_decode(char *s) 
923 {
924         char *o = s;
925         unsigned int tmp;
926         while(*s) {
927                 switch(*s) {
928                 case '%':
929                         if (strlen(s) > 2) {
930                                 if (sscanf(s + 1, "%2x", &tmp) == 1) {
931                                         *o = tmp;
932                                         s += 2; /* Will be incremented once more when we break out */
933                                         break;
934                                 }
935                         }
936                         /* Fall through if something wasn't right with the formatting */
937                 default:
938                         *o = *s;
939                 }
940                 s++;
941                 o++;
942         }
943         *o = '\0';
944 }
945
946 /*--- ditch_braces: Pick out text in braces from character string  ---*/
947 static char *ditch_braces(char *tmp)
948 {
949         char *c = tmp;
950         char *n;
951         char *q;
952         if ((q = strchr(tmp, '"')) ) {
953                 c = q + 1;
954                 if ((q = strchr(c, '"')) )
955                         c = q + 1;
956                 else {
957                         ast_log(LOG_WARNING, "No closing quote in '%s'\n", tmp);
958                         c = tmp;
959                 }
960         }
961         if ((n = strchr(c, '<')) ) {
962                 c = n + 1;
963                 while(*c && *c != '>') c++;
964                 if (*c != '>') {
965                         ast_log(LOG_WARNING, "No closing brace in '%s'\n", tmp);
966                 } else {
967                         *c = '\0';
968                 }
969                 return n+1;
970         }
971         return c;
972 }
973
974 /*--- sip_sendtext: Send SIP MESSAGE text within a call ---*/
975 /*      Called from PBX core text message functions */
976 static int sip_sendtext(struct ast_channel *ast, char *text)
977 {
978         struct sip_pvt *p = ast->pvt->pvt;
979         int debug=sip_debug_test_pvt(p);
980
981         if (debug)
982                 ast_verbose("Sending text %s on %s\n", text, ast->name);
983         if (!p)
984                 return -1;
985         if (!text || ast_strlen_zero(text))
986                 return 0;
987         if (debug)
988                 ast_verbose("Really sending text %s on %s\n", text, ast->name);
989         transmit_message_with_text(p, text);
990         return 0;       
991 }
992
993 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, const char *username, int expirey)
994 {
995         char port[10];
996         char ipaddr[20];
997         char regseconds[20];
998         time_t nowtime;
999         
1000         time(&nowtime);
1001         nowtime += expirey;
1002         snprintf(regseconds, sizeof(regseconds), "%ld", nowtime);
1003         ast_inet_ntoa(ipaddr, sizeof(ipaddr), sin->sin_addr);
1004         snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
1005         ast_update_realtime("sipfriends", "name", peername, "ipaddr", ipaddr, "port", port, "regseconds", regseconds, "username", username, NULL);
1006 }
1007
1008 static void register_peer_exten(struct sip_peer *peer, int onoff)
1009 {
1010         unsigned char multi[256]="";
1011         char *stringp, *ext;
1012         if (!ast_strlen_zero(regcontext)) {
1013                 strncpy(multi, ast_strlen_zero(peer->regexten) ? peer->name : peer->regexten, sizeof(multi) - 1);
1014                 stringp = multi;
1015                 while((ext = strsep(&stringp, "&"))) {
1016                         if (onoff)
1017                                 ast_add_extension(regcontext, 1, ext, 1, NULL, NULL, "Noop", strdup(peer->name), free, type);
1018                         else
1019                                 ast_context_remove_extension(regcontext, ext, 1, NULL);
1020                 }
1021         }
1022 }
1023
1024 static void destroy_peer(struct sip_peer *peer)
1025 {
1026         /* Delete it, it needs to disappear */
1027         if (peer->call)
1028                 sip_destroy(peer->call);
1029         if (peer->expire > -1)
1030                 ast_sched_del(sched, peer->expire);
1031         if (peer->pokeexpire > -1)
1032                 ast_sched_del(sched, peer->pokeexpire);
1033         register_peer_exten(peer, 0);
1034         ast_free_ha(peer->ha);
1035         free(peer);
1036 }
1037
1038 /*--- update_peer: Update peer data in database (if used) ---*/
1039 static void update_peer(struct sip_peer *p, int expiry)
1040 {
1041         if (p->temponly)
1042                 realtime_update_peer(p->name, &p->addr, p->username, expiry);
1043 }
1044
1045 static struct sip_peer *build_peer(const char *name, struct ast_variable *v);
1046
1047 static struct sip_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
1048 {
1049         struct ast_variable *var, *tmp=NULL;
1050         char iabuf[80];
1051         struct sip_peer *peer=NULL;
1052         time_t nowtime, regseconds;
1053         int dynamic=0;
1054         
1055         if (sin)
1056                 ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr);
1057         if (peername) 
1058                 var = ast_load_realtime("sipfriends", "name", peername, NULL);
1059         else
1060                 var = ast_load_realtime("sipfriends", "ipaddr", iabuf, NULL);
1061         if (var) {
1062                 /* Make sure it's not a user only... */
1063                 peer = build_peer(peername, var);
1064                 if (peer) {
1065                         /* Add some finishing touches, addresses, etc */
1066                         peer->temponly = 1;
1067                         tmp = var;
1068                         while(tmp) {
1069                                 if (!strcasecmp(tmp->name, "type")) {
1070                                         if (strcasecmp(tmp->value, "friend") &&
1071                                                 strcasecmp(tmp->value, "peer")) {
1072                                                 /* Whoops, we weren't supposed to exist! */
1073                                                 destroy_peer(peer);
1074                                                 peer = NULL;
1075                                                 break;
1076                                         } 
1077                                 } else if (!strcasecmp(tmp->name, "regseconds")) {
1078                                         if (sscanf(tmp->value, "%li", &regseconds) != 1)
1079                                                 regseconds = 0;
1080                                 } else if (!strcasecmp(tmp->name, "ipaddr")) {
1081                                         inet_aton(tmp->value, &(peer->addr.sin_addr));
1082                                 } else if (!strcasecmp(tmp->name, "port")) {
1083                                         peer->addr.sin_port = htons(atoi(tmp->value));
1084                                 } else if (!strcasecmp(tmp->name, "host")) {
1085                                         if (!strcasecmp(tmp->value, "dynamic"))
1086                                                 dynamic = 1;
1087                                 }
1088                                 tmp = tmp->next;
1089                         }
1090                         if (peer && dynamic) {
1091                                 time(&nowtime);
1092                                 if ((nowtime - regseconds) > 0) {
1093                                         memset(&peer->addr, 0, sizeof(peer->addr));
1094                                         if (option_debug)
1095                                                 ast_log(LOG_DEBUG, "Bah, we're expired (%ld/%ld/%ld)!\n", nowtime - regseconds, regseconds, nowtime);
1096                                 }
1097                         }
1098                 }
1099                 ast_destroy_realtime(var);
1100         }
1101         return peer;
1102 }
1103
1104 /*--- find_peer: Locate peer by name or ip address */
1105 static struct sip_peer *find_peer(const char *peer, struct sockaddr_in *sin)
1106 {
1107         struct sip_peer *p = NULL;
1108
1109         p = peerl.peers;
1110         if (peer) {
1111                 /* Find by peer name */
1112                 while(p) {
1113                         if (!strcasecmp(p->name, peer)) {
1114                                 break;
1115                         }
1116                         p = p->next;
1117                 }       
1118         }
1119         else {
1120                 /* Find by sin */
1121                 while(p) {
1122                         if (!inaddrcmp(&p->addr, sin) || 
1123                                         (p->insecure &&
1124                                         (p->addr.sin_addr.s_addr == sin->sin_addr.s_addr))) {
1125                                 break;
1126                         }
1127                         p = p->next;
1128                 }
1129         }
1130
1131         if (!p) {
1132                 p = realtime_peer(peer, sin);
1133         }
1134
1135         return(p);
1136 }
1137
1138 static void destroy_user(struct sip_user *user)
1139 {
1140         ast_free_ha(user->ha);
1141         free(user);
1142 }
1143
1144 static struct sip_user *build_user(const char *name, struct ast_variable *v);
1145 static struct sip_user *realtime_user(const char *username)
1146 {
1147         struct ast_variable *var;
1148         struct ast_variable *tmp;
1149         struct sip_user *user=NULL;
1150         var = ast_load_realtime("sipfriends", "name", username, NULL);
1151         if (var) {
1152                 /* Make sure it's not a user only... */
1153                 user = build_user(username, var);
1154                 if (user) {
1155                         /* Add some finishing touches, addresses, etc */
1156                         user->temponly = 1;
1157                         tmp = var;
1158                         while(tmp) {
1159                                 if (!strcasecmp(tmp->name, "type")) {
1160                                         if (strcasecmp(tmp->value, "friend") &&
1161                                                 strcasecmp(tmp->value, "user")) {
1162                                                 /* Whoops, we weren't supposed to exist! */
1163                                                 destroy_user(user);
1164                                                 user = NULL;
1165                                                 break;
1166                                         } 
1167                                 }
1168                                 tmp = tmp->next;
1169                         }
1170                 }
1171                 ast_destroy_realtime(var);
1172         }
1173         return user;
1174 }
1175
1176 /*--- find_user: Locate user by name */
1177 static struct sip_user *find_user(char *name)
1178 {
1179         struct sip_user *u = NULL;
1180
1181         u = userl.users;
1182         while(u) {
1183                 if (!strcasecmp(u->name, name)) {
1184                         break;
1185                 }
1186                 u = u->next;
1187         }
1188         if (!u) {
1189                 u = realtime_user(name);
1190         }
1191         return(u);
1192 }
1193
1194 /*--- create_addr: create address structure from peer definition ---*/
1195 /*      Or, if peer not found, find it in the global DNS */
1196 /*      returns TRUE on failure, FALSE on success */
1197 static int create_addr(struct sip_pvt *r, char *opeer)
1198 {
1199         struct hostent *hp;
1200         struct ast_hostent ahp;
1201         struct sip_peer *p;
1202         int found=0;
1203         char *port;
1204         char *callhost;
1205         int portno;
1206         char host[256], *hostn;
1207         char peer[256]="";
1208
1209         strncpy(peer, opeer, sizeof(peer) - 1);
1210         port = strchr(peer, ':');
1211         if (port) {
1212                 *port = '\0';
1213                 port++;
1214         }
1215         r->sa.sin_family = AF_INET;
1216         ast_mutex_lock(&peerl.lock);
1217         p = find_peer(peer, NULL);
1218
1219         if (p) {
1220                         found++;
1221                         r->capability = p->capability;
1222                         r->nat = p->nat;
1223                         if (r->rtp) {
1224                                 ast_log(LOG_DEBUG, "Setting NAT on RTP to %d\n", (r->nat & SIP_NAT_ROUTE));
1225                                 ast_rtp_setnat(r->rtp, (r->nat & SIP_NAT_ROUTE));
1226                         }
1227                         if (r->vrtp) {
1228                                 ast_log(LOG_DEBUG, "Setting NAT on VRTP to %d\n", (r->nat & SIP_NAT_ROUTE));
1229                                 ast_rtp_setnat(r->vrtp, (r->nat & SIP_NAT_ROUTE));
1230                         }
1231                         strncpy(r->peername, p->username, sizeof(r->peername)-1);
1232                         strncpy(r->authname, p->username, sizeof(r->authname)-1);
1233                         strncpy(r->peersecret, p->secret, sizeof(r->peersecret)-1);
1234                         strncpy(r->peermd5secret, p->md5secret, sizeof(r->peermd5secret)-1);
1235                         strncpy(r->username, p->username, sizeof(r->username)-1);
1236                         strncpy(r->tohost, p->tohost, sizeof(r->tohost)-1);
1237                         strncpy(r->fullcontact, p->fullcontact, sizeof(r->fullcontact)-1);
1238                         if (!r->initreq.headers && !ast_strlen_zero(p->fromdomain)) {
1239                                 if ((callhost = strchr(r->callid, '@'))) {
1240                                         strncpy(callhost + 1, p->fromdomain, sizeof(r->callid) - (callhost - r->callid) - 2);
1241                                 }
1242                         }
1243                         if (ast_strlen_zero(r->tohost)) {
1244                                 if (p->addr.sin_addr.s_addr)
1245                                         ast_inet_ntoa(r->tohost, sizeof(r->tohost), p->addr.sin_addr);
1246                                 else
1247                                         ast_inet_ntoa(r->tohost, sizeof(r->tohost), p->defaddr.sin_addr);
1248                         }
1249                         if (!ast_strlen_zero(p->fromdomain))
1250                                 strncpy(r->fromdomain, p->fromdomain, sizeof(r->fromdomain)-1);
1251                         if (!ast_strlen_zero(p->fromuser))
1252                                 strncpy(r->fromuser, p->fromuser, sizeof(r->fromuser)-1);
1253                         r->insecure = p->insecure;
1254                         r->canreinvite = p->canreinvite;
1255                         r->maxtime = p->maxms;
1256                         r->callgroup = p->callgroup;
1257                         r->pickupgroup = p->pickupgroup;
1258                         if (p->dtmfmode) {
1259                                 r->dtmfmode = p->dtmfmode;
1260                                 if (r->dtmfmode & SIP_DTMF_RFC2833)
1261                                         r->noncodeccapability |= AST_RTP_DTMF;
1262                                 else
1263                                         r->noncodeccapability &= ~AST_RTP_DTMF;
1264                         }
1265                         r->promiscredir = p->promiscredir;
1266                         strncpy(r->context, p->context,sizeof(r->context)-1);
1267                         if ((p->addr.sin_addr.s_addr || p->defaddr.sin_addr.s_addr) &&
1268                                 (!p->maxms || ((p->lastms > 0)  && (p->lastms <= p->maxms)))) {
1269                                 if (p->addr.sin_addr.s_addr) {
1270                                         r->sa.sin_addr = p->addr.sin_addr;
1271                                         r->sa.sin_port = p->addr.sin_port;
1272                                 } else {
1273                                         r->sa.sin_addr = p->defaddr.sin_addr;
1274                                         r->sa.sin_port = p->defaddr.sin_port;
1275                                 }
1276                                 memcpy(&r->recv, &r->sa, sizeof(r->recv));
1277                         } else {
1278                                 if (p->temponly) {
1279                                         destroy_peer(p);
1280                                 }
1281                                 p = NULL;
1282                         }
1283         }
1284         ast_mutex_unlock(&peerl.lock);
1285         if (!p && !found) {
1286                 hostn = peer;
1287                 if (port)
1288                         portno = atoi(port);
1289                 else
1290                         portno = DEFAULT_SIP_PORT;
1291                 if (srvlookup) {
1292                         char service[256];
1293                         int tportno;
1294                         int ret;
1295                         snprintf(service, sizeof(service), "_sip._udp.%s", peer);
1296                         ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service);
1297                         if (ret > 0) {
1298                                 hostn = host;
1299                                 portno = tportno;
1300                         }
1301                 }
1302                 hp = ast_gethostbyname(hostn, &ahp);
1303                 if (hp) {
1304                         strncpy(r->tohost, peer, sizeof(r->tohost) - 1);
1305                         memcpy(&r->sa.sin_addr, hp->h_addr, sizeof(r->sa.sin_addr));
1306                         r->sa.sin_port = htons(portno);
1307                         memcpy(&r->recv, &r->sa, sizeof(r->recv));
1308                         return 0;
1309                 } else {
1310                         ast_log(LOG_WARNING, "No such host: %s\n", peer);
1311                         return -1;
1312                 }
1313         } else if (!p)
1314                 return -1;
1315         else {
1316                 if (p->temponly) {
1317                         destroy_peer(p);
1318                 }
1319                 return 0;
1320         }
1321 }
1322
1323 /*--- auto_congest: Scheduled congestion on a call ---*/
1324 static int auto_congest(void *nothing)
1325 {
1326         struct sip_pvt *p = nothing;
1327         ast_mutex_lock(&p->lock);
1328         p->initid = -1;
1329         if (p->owner) {
1330                 if (!ast_mutex_trylock(&p->owner->lock)) {
1331                         ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name);
1332                         ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
1333                         ast_mutex_unlock(&p->owner->lock);
1334                 }
1335         }
1336         ast_mutex_unlock(&p->lock);
1337         return 0;
1338 }
1339
1340 /*--- sip_prefs_free: Free codec list in preference structure ---*/
1341 static void sip_prefs_free(void)
1342 {
1343         struct sip_codec_pref *cur, *next;
1344         cur = prefs;
1345         while(cur) {
1346                 next = cur->next;
1347                 free(cur);
1348                 cur = next;
1349         }
1350         prefs = NULL;
1351 }
1352
1353 /*--- sip_pref_remove: Remove codec from pref list ---*/
1354 static void sip_pref_remove(int format)
1355 {
1356         struct sip_codec_pref *cur, *prev=NULL;
1357         cur = prefs;
1358         while(cur) {
1359                 if (cur->codec == format) {
1360                         if (prev)
1361                                 prev->next = cur->next;
1362                         else
1363                                 prefs = cur->next;
1364                         free(cur);
1365                         return;
1366                 }
1367                 prev = cur;
1368                 cur = cur->next;
1369         }
1370 }
1371
1372 /*--- sip_pref_append: Append codec to list ---*/
1373 static int sip_pref_append(int format)
1374 {
1375         struct sip_codec_pref *cur, *tmp;
1376         sip_pref_remove(format);
1377         tmp = (struct sip_codec_pref *)malloc(sizeof(struct sip_codec_pref));
1378         if (!tmp)
1379                 return -1;
1380         memset(tmp, 0, sizeof(struct sip_codec_pref));
1381         tmp->codec = format;
1382         if (prefs) {
1383                 cur = prefs;
1384                 while(cur->next)
1385                         cur = cur->next;
1386                 cur->next = tmp;
1387         } else
1388                 prefs = tmp;
1389         return 0;
1390 }
1391
1392 /*--- sip_codec_choose: Pick a codec ---*/
1393 static int sip_codec_choose(int formats)
1394 {
1395         struct sip_codec_pref *cur;
1396         formats &= ((AST_FORMAT_MAX_AUDIO << 1) - 1);
1397         cur = prefs;
1398         while(cur) {
1399                 if (formats & cur->codec)
1400                         return cur->codec;
1401                 cur = cur->next;
1402         }
1403         return ast_best_codec(formats);
1404 }
1405
1406 /*--- sip_call: Initiate SIP call from PBX ---*/
1407 /*      used from the dial() application      */
1408 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
1409 {
1410         int res;
1411         struct sip_pvt *p;
1412         char *vxml_url = NULL;
1413         char *distinctive_ring = NULL;
1414         char *osptoken = NULL;
1415 #ifdef OSP_SUPPORT
1416         char *osphandle = NULL;
1417 #endif  
1418         struct varshead *headp;
1419         struct ast_var_t *current;
1420         
1421         p = ast->pvt->pvt;
1422         if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
1423                 ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
1424                 return -1;
1425         }
1426         /* Check whether there is vxml_url, distinctive ring variables */
1427
1428         headp=&ast->varshead;
1429         AST_LIST_TRAVERSE(headp,current,entries) {
1430                 /* Check whether there is a VXML_URL variable */
1431                 if (strcasecmp(ast_var_name(current),"VXML_URL")==0)
1432                 {
1433                         vxml_url = ast_var_value(current);
1434                 } else
1435                 /* Check whether there is a ALERT_INFO variable */
1436                 if (strcasecmp(ast_var_name(current),"ALERT_INFO")==0)
1437                 {
1438                         distinctive_ring = ast_var_value(current);
1439                 }
1440 #ifdef OSP_SUPPORT
1441                 else if (!strcasecmp(ast_var_name(current), "OSPTOKEN")) {
1442                         osptoken = ast_var_value(current);
1443                 } else if (!strcasecmp(ast_var_name(current), "OSPHANDLE")) {
1444                         osphandle = ast_var_value(current);
1445                 }
1446 #endif
1447         }
1448         
1449         res = 0;
1450         p->outgoing = 1;
1451 #ifdef OSP_SUPPORT
1452         if (!osptoken || !osphandle || (sscanf(osphandle, "%i", &p->osphandle) != 1)) {
1453                 /* Force Disable OSP support */
1454                 osptoken = NULL;
1455                 osphandle = NULL;
1456                 p->osphandle = -1;
1457         }
1458 #endif
1459         ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);
1460         res = update_user_counter(p,INC_OUT_USE);
1461         if ( res != -1 ) {
1462                 p->callingpres = ast->cid.cid_pres;
1463                 p->jointcapability = p->capability;
1464                 transmit_invite(p, "INVITE", 1, NULL, NULL, vxml_url,distinctive_ring, osptoken, 1);
1465                 if (p->maxtime) {
1466                         /* Initialize auto-congest time */
1467                         p->initid = ast_sched_add(sched, p->maxtime * 4, auto_congest, p);
1468                 }
1469         }
1470         return res;
1471 }
1472
1473 /*---  __sip_destroy: Execute destrucion of call structure, release memory---*/
1474 static void __sip_destroy(struct sip_pvt *p, int lockowner)
1475 {
1476         struct sip_pvt *cur, *prev = NULL;
1477         struct sip_pkt *cp;
1478         struct sip_history *hist;
1479
1480         if (sip_debug_test_pvt(p))
1481                 ast_verbose("Destroying call '%s'\n", p->callid);
1482         if (p->stateid > -1)
1483                 ast_extension_state_del(p->stateid, NULL);
1484         if (p->initid > -1)
1485                 ast_sched_del(sched, p->initid);
1486         if (p->autokillid > -1)
1487                 ast_sched_del(sched, p->autokillid);
1488
1489         if (p->rtp) {
1490                 ast_rtp_destroy(p->rtp);
1491         }
1492         if (p->vrtp) {
1493                 ast_rtp_destroy(p->vrtp);
1494         }
1495         if (p->route) {
1496                 free_old_route(p->route);
1497                 p->route = NULL;
1498         }
1499         if (p->registry) {
1500                 /* Carefully unlink from registry */
1501                 struct sip_registry *reg;
1502                 ast_mutex_lock(&regl.lock);
1503                 reg = regl.registrations;
1504                 while(reg) {
1505                         if ((reg == p->registry) && (p->registry->call == p))
1506                                 p->registry->call=NULL;
1507                         reg = reg->next;
1508                 }
1509                 ast_mutex_unlock(&regl.lock);
1510         }
1511         /* Unlink us from the owner if we have one */
1512         if (p->owner) {
1513                 if (lockowner)
1514                         ast_mutex_lock(&p->owner->lock);
1515                 ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
1516                 p->owner->pvt->pvt = NULL;
1517                 if (lockowner)
1518                         ast_mutex_unlock(&p->owner->lock);
1519         }
1520         /* Clear history */
1521         while(p->history) {
1522                 hist = p->history;
1523                 p->history = p->history->next;
1524                 free(hist);
1525         }
1526         cur = iflist;
1527         while(cur) {
1528                 if (cur == p) {
1529                         if (prev)
1530                                 prev->next = cur->next;
1531                         else
1532                                 iflist = cur->next;
1533                         break;
1534                 }
1535                 prev = cur;
1536                 cur = cur->next;
1537         }
1538         if (!cur) {
1539                 ast_log(LOG_WARNING, "%p is not in list?!?! \n", cur);
1540         } else {
1541                 if (p->initid > -1)
1542                         ast_sched_del(sched, p->initid);
1543                 while((cp = p->packets)) {
1544                         p->packets = p->packets->next;
1545                         if (cp->retransid > -1)
1546                                 ast_sched_del(sched, cp->retransid);
1547                         free(cp);
1548                 }
1549                 ast_mutex_destroy(&p->lock);
1550                 free(p);
1551         }
1552 }
1553
1554 /*--- update_user_counter: Handle incominglimit and outgoinglimit for SIP users ---*/
1555 /* Note: This is going to be replaced by app_groupcount */
1556 static int update_user_counter(struct sip_pvt *fup, int event)
1557 {
1558         char name[256] = "";
1559         struct sip_user *u;
1560         strncpy(name, fup->username, sizeof(name) - 1);
1561         ast_mutex_lock(&userl.lock);
1562         u = find_user(name);
1563         if (!u) {
1564                 ast_log(LOG_DEBUG, "%s is not a local user\n", name);
1565                 ast_mutex_unlock(&userl.lock);
1566                 return 0;
1567         }
1568         switch(event) {
1569                 /* incoming and outgoing affects the inUse counter */
1570                 case DEC_OUT_USE:
1571                 case DEC_IN_USE:
1572                         if ( u->inUse > 0 ) {
1573                                 u->inUse--;
1574                         } else {
1575                                 u->inUse = 0;
1576                         }
1577                         break;
1578                 case INC_IN_USE:
1579                 case INC_OUT_USE:
1580                         if (u->incominglimit > 0 ) {
1581                                 if (u->inUse >= u->incominglimit) {
1582                                         ast_log(LOG_ERROR, "Call from user '%s' rejected due to usage limit of %d\n", u->name, u->incominglimit);
1583                                         /* inc inUse as well */
1584                                         if ( event == INC_OUT_USE ) {
1585                                                 u->inUse++;
1586                                         }
1587                                         ast_mutex_unlock(&userl.lock);
1588                                         if (u->temponly) {
1589                                                 destroy_user(u);
1590                                         }
1591                                         return -1; 
1592                                 }
1593                         }
1594                         u->inUse++;
1595                         ast_log(LOG_DEBUG, "Call from user '%s' is %d out of %d\n", u->name, u->inUse, u->incominglimit);
1596                         break;
1597                 /* we don't use these anymore
1598                 case DEC_OUT_USE:
1599                         if ( u->outUse > 0 ) {
1600                                 u->outUse--;
1601                         } else {
1602                                 u->outUse = 0;
1603                         }
1604                         break;
1605                 case INC_OUT_USE:
1606                         if ( u->outgoinglimit > 0 ) {
1607                                 if ( u->outUse >= u->outgoinglimit ) {
1608                                         ast_log(LOG_ERROR, "Outgoing call from user '%s' rejected due to usage limit of %d\n", u->name, u->outgoinglimit);
1609                                         ast_mutex_unlock(&userl.lock);
1610                                         if (u->temponly) {
1611                                                 destroy_user(u);
1612                                         }
1613                                         return -1;
1614                                 }
1615                         }
1616                         u->outUse++;
1617                         break;
1618                 */
1619                 default:
1620                         ast_log(LOG_ERROR, "update_user_counter(%s,%d) called with no event!\n",u->name,event);
1621         }
1622         ast_mutex_unlock(&userl.lock);
1623         if (u->temponly) {
1624                 destroy_user(u);
1625         }
1626         return 0;
1627 }
1628
1629 /*--- sip_destroy: Destroy SIP call structure ---*/
1630 static void sip_destroy(struct sip_pvt *p)
1631 {
1632         ast_mutex_lock(&iflock);
1633         __sip_destroy(p, 1);
1634         ast_mutex_unlock(&iflock);
1635 }
1636
1637
1638 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal);
1639
1640 static int hangup_sip2cause(int cause)
1641 {
1642 /* Possible values from causes.h
1643         AST_CAUSE_NOTDEFINED    AST_CAUSE_NORMAL        AST_CAUSE_BUSY
1644         AST_CAUSE_FAILURE       AST_CAUSE_CONGESTION    AST_CAUSE_UNALLOCATED
1645 */
1646
1647         switch(cause) {
1648                 case 404:       /* Not found */
1649                         return AST_CAUSE_UNALLOCATED;
1650                 case 483:       /* Too many hops */
1651                         return AST_CAUSE_FAILURE;
1652                 case 486:
1653                         return AST_CAUSE_BUSY;
1654                 default:
1655                         return AST_CAUSE_NORMAL;
1656         }
1657         /* Never reached */
1658         return 0;
1659 }
1660
1661 static char *hangup_cause2sip(int cause)
1662 {
1663         switch(cause)
1664         {
1665                 case AST_CAUSE_FAILURE:
1666                         return "500 Server internal failure";
1667                 case AST_CAUSE_CONGESTION:
1668                         return "503 Service Unavailable";
1669                 case AST_CAUSE_BUSY:
1670                         return "486 Busy";
1671                 default:
1672                         return NULL;
1673         }
1674         /* Never reached */
1675         return 0;
1676 }
1677
1678 /*--- sip_hangup: Hangup SIP call */
1679 static int sip_hangup(struct ast_channel *ast)
1680 {
1681         struct sip_pvt *p = ast->pvt->pvt;
1682         int needcancel = 0;
1683         int needdestroy = 0;
1684         if (option_debug)
1685                 ast_log(LOG_DEBUG, "sip_hangup(%s)\n", ast->name);
1686         if (!ast->pvt->pvt) {
1687                 ast_log(LOG_DEBUG, "Asked to hangup channel not connected\n");
1688                 return 0;
1689         }
1690         ast_mutex_lock(&p->lock);
1691 #ifdef OSP_SUPPORT
1692         if ((p->osphandle > -1) && (ast->_state == AST_STATE_UP)) {
1693                 ast_osp_terminate(p->osphandle, AST_CAUSE_NORMAL, p->ospstart, time(NULL) - p->ospstart);
1694         }
1695 #endif  
1696         if ( p->outgoing ) {
1697                 ast_log(LOG_DEBUG, "update_user_counter(%s) - decrement outUse counter\n", p->username);
1698                 update_user_counter(p, DEC_OUT_USE);
1699         } else {
1700                 ast_log(LOG_DEBUG, "update_user_counter(%s) - decrement inUse counter\n", p->username);
1701                 update_user_counter(p, DEC_IN_USE);
1702         }
1703         /* Determine how to disconnect */
1704         if (p->owner != ast) {
1705                 ast_log(LOG_WARNING, "Huh?  We aren't the owner?\n");
1706                 ast_mutex_unlock(&p->lock);
1707                 return 0;
1708         }
1709         if (!ast || (ast->_state != AST_STATE_UP))
1710                 needcancel = 1;
1711         /* Disconnect */
1712         p = ast->pvt->pvt;
1713         if (p->vad) {
1714             ast_dsp_free(p->vad);
1715         }
1716         p->owner = NULL;
1717         ast->pvt->pvt = NULL;
1718
1719         ast_mutex_lock(&usecnt_lock);
1720         usecnt--;
1721         ast_mutex_unlock(&usecnt_lock);
1722         ast_update_use_count();
1723
1724         needdestroy = 1; 
1725         /* Start the process if it's not already started */
1726         if (!p->alreadygone && !ast_strlen_zero(p->initreq.data)) {
1727                 if (needcancel) {
1728                         if (p->outgoing) {
1729                                 transmit_request_with_auth(p, "CANCEL", p->ocseq, 1, 0);
1730                                 /* Actually don't destroy us yet, wait for the 487 on our original 
1731                                    INVITE, but do set an autodestruct just in case we never get it. */
1732                                 needdestroy = 0;
1733                                 sip_scheddestroy(p, 15000);
1734                                 if ( p->initid != -1 ) {
1735                                         /* channel still up - reverse dec of inUse counter
1736                                            only if the channel is not auto-congested */
1737                                         if ( p->outgoing ) {
1738                                                 update_user_counter(p, INC_OUT_USE);
1739                                         }
1740                                         else {
1741                                                 update_user_counter(p, INC_IN_USE);
1742                                         }
1743                                 }
1744                         } else {
1745                                 char *res;
1746                                 if (ast->hangupcause && ((res = hangup_cause2sip(ast->hangupcause)))) {
1747                                         transmit_response_reliable(p, res, &p->initreq, 1);
1748                                 } else 
1749                                         transmit_response_reliable(p, "403 Forbidden", &p->initreq, 1);
1750                         }
1751                 } else {
1752                         if (!p->pendinginvite) {
1753                                 /* Send a hangup */
1754                                 transmit_request_with_auth(p, "BYE", 0, 1, 1);
1755                         } else {
1756                                 /* Note we will need a BYE when this all settles out
1757                                    but we can't send one while we have "INVITE" outstanding. */
1758                                 p->pendingbye = 1;
1759                                 p->needreinvite = 0;
1760                         }
1761                 }
1762         }
1763         p->needdestroy = needdestroy;
1764         ast_mutex_unlock(&p->lock);
1765         return 0;
1766 }
1767
1768 /*--- sip_answer: Answer SIP call , send 200 OK on Invite */
1769 static int sip_answer(struct ast_channel *ast)
1770 {
1771         int res = 0,fmt;
1772         char *codec;
1773         struct sip_pvt *p = ast->pvt->pvt;
1774
1775         ast_mutex_lock(&p->lock);
1776         if (ast->_state != AST_STATE_UP) {
1777 #ifdef OSP_SUPPORT      
1778                 time(&p->ospstart);
1779 #endif
1780         
1781                 codec=pbx_builtin_getvar_helper(p->owner,"SIP_CODEC");
1782                 if (codec) {
1783                         fmt=ast_getformatbyname(codec);
1784                         if (fmt) {
1785                                 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC) variable\n",codec);
1786                                 if (p->jointcapability & fmt) {
1787                                         p->jointcapability &= fmt;
1788                                         p->capability &= fmt;
1789                                 } else
1790                                         ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because it is not shared by both ends.\n");
1791                         } else ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n",codec);
1792                 }
1793
1794                 ast_setstate(ast, AST_STATE_UP);
1795                 if (option_debug)
1796                         ast_log(LOG_DEBUG, "sip_answer(%s)\n", ast->name);
1797                 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, 1);
1798         }
1799         ast_mutex_unlock(&p->lock);
1800         return res;
1801 }
1802
1803 /*--- sip_write: Send response, support audio media ---*/
1804 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
1805 {
1806         struct sip_pvt *p = ast->pvt->pvt;
1807         int res = 0;
1808         if (frame->frametype == AST_FRAME_VOICE) {
1809                 if (!(frame->subclass & ast->nativeformats)) {
1810                         ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
1811                                 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
1812                         return 0;
1813                 }
1814                 if (p) {
1815                         ast_mutex_lock(&p->lock);
1816                         if (p->rtp) {
1817                                 if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) {
1818                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1819                                         p->progress = 1;
1820                                 }
1821                                 res =  ast_rtp_write(p->rtp, frame);
1822                         }
1823                         ast_mutex_unlock(&p->lock);
1824                 }
1825         } else if (frame->frametype == AST_FRAME_VIDEO) {
1826                 if (p) {
1827                         ast_mutex_lock(&p->lock);
1828                         if (p->vrtp) {
1829                                 if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) {
1830                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1831                                         p->progress = 1;
1832                                 }
1833                                 res =  ast_rtp_write(p->vrtp, frame);
1834                         }
1835                         ast_mutex_unlock(&p->lock);
1836                 }
1837         } else if (frame->frametype == AST_FRAME_IMAGE) {
1838                 return 0;
1839         } else {
1840                 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
1841                 return 0;
1842         }
1843
1844         return res;
1845 }
1846
1847 /*--- sip_fixup: Fix up a channel:  If a channel is consumed, this is called.
1848         Basically update any ->owner links ----*/
1849 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
1850 {
1851         struct sip_pvt *p = newchan->pvt->pvt;
1852         ast_mutex_lock(&p->lock);
1853         if (p->owner != oldchan) {
1854                 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
1855                 ast_mutex_unlock(&p->lock);
1856                 return -1;
1857         }
1858         p->owner = newchan;
1859         ast_mutex_unlock(&p->lock);
1860         return 0;
1861 }
1862
1863 /*--- sip_senddigit: Send DTMF character on SIP channel */
1864 /*    within one call, we're able to transmit in many methods simultaneously */
1865 static int sip_senddigit(struct ast_channel *ast, char digit)
1866 {
1867         struct sip_pvt *p = ast->pvt->pvt;
1868         if (p && (p->dtmfmode & SIP_DTMF_INFO)) {
1869                 transmit_info_with_digit(p, digit);
1870         }
1871         if (p && p->rtp && (p->dtmfmode & SIP_DTMF_RFC2833)) {
1872                 ast_rtp_senddigit(p->rtp, digit);
1873         }
1874         /* If in-band DTMF is desired, send that */
1875         if (p->dtmfmode & SIP_DTMF_INBAND)
1876                 return -1;
1877         return 0;
1878 }
1879
1880
1881 /*--- sip_transfer: Transfer SIP call */
1882 static int sip_transfer(struct ast_channel *ast, char *dest)
1883 {
1884         struct sip_pvt *p = ast->pvt->pvt;
1885         int res;
1886         res = transmit_refer(p, dest);
1887         return res;
1888 }
1889
1890 /*--- sip_indicate: Play indication to user */
1891 /* With SIP a lot of indications is sent as messages, letting the device play
1892    the indication - busy signal, congestion etc */
1893 static int sip_indicate(struct ast_channel *ast, int condition)
1894 {
1895         struct sip_pvt *p = ast->pvt->pvt;
1896         switch(condition) {
1897         case AST_CONTROL_RINGING:
1898                 if (ast->_state == AST_STATE_RING) {
1899                         if (!p->progress) {
1900                                 transmit_response(p, "180 Ringing", &p->initreq);
1901                                 p->ringing = 1;
1902                                 if (!p->progressinband)
1903                                         break;
1904                         } else {
1905                                 /* Oops, we've sent progress tones.  Let Asterisk do it instead */
1906                         }
1907                 }
1908                 return -1;
1909         case AST_CONTROL_BUSY:
1910                 if (ast->_state != AST_STATE_UP) {
1911                         transmit_response(p, "486 Busy Here", &p->initreq);
1912                         p->alreadygone = 1;
1913                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1914                         break;
1915                 }
1916                 return -1;
1917         case AST_CONTROL_CONGESTION:
1918                 if (ast->_state != AST_STATE_UP) {
1919                         transmit_response(p, "503 Service Unavailable", &p->initreq);
1920                         p->alreadygone = 1;
1921                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1922                         break;
1923                 }
1924                 return -1;
1925         case AST_CONTROL_PROGRESS:
1926         case AST_CONTROL_PROCEEDING:
1927                 if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) {
1928                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1929                         p->progress = 1;
1930                         break;
1931                 }
1932                 return -1;
1933         case -1:
1934                 return -1;
1935         default:
1936                 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
1937                 return -1;
1938         }
1939         return 0;
1940 }
1941
1942
1943
1944 /*--- sip_new: Initiate a call in the SIP channel */
1945 /*      called from sip_request_call (calls from the pbx ) */
1946 static struct ast_channel *sip_new(struct sip_pvt *i, int state, char *title)
1947 {
1948         struct ast_channel *tmp;
1949         int fmt;
1950         ast_mutex_unlock(&i->lock);
1951         /* Don't hold a sip pvt lock while we allocate a channel */
1952         tmp = ast_channel_alloc(1);
1953         ast_mutex_lock(&i->lock);
1954         if (tmp) {
1955                 /* Select our native format based on codec preference until we receive
1956                    something from another device to the contrary. */
1957                 if (i->jointcapability)
1958                         tmp->nativeformats = sip_codec_choose(i->jointcapability);
1959                 else if (i->capability)
1960                         tmp->nativeformats = sip_codec_choose(i->capability);
1961                 else
1962                         tmp->nativeformats = sip_codec_choose(global_capability);
1963                 fmt = ast_best_codec(tmp->nativeformats);
1964                 if (title)
1965                         snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%04x", title, rand() & 0xffff);
1966                 else
1967                         if (strchr(i->fromdomain,':'))
1968                         {
1969                                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", strchr(i->fromdomain,':')+1, (int)(long)(i));
1970                         }
1971                         else
1972                         {
1973                                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", i->fromdomain, (int)(long)(i));
1974                         }
1975                 tmp->type = type;
1976                 if (i->dtmfmode & SIP_DTMF_INBAND) {
1977                     i->vad = ast_dsp_new();
1978                     ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
1979                     if (relaxdtmf)
1980                         ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
1981                 }
1982                 tmp->fds[0] = ast_rtp_fd(i->rtp);
1983                 tmp->fds[1] = ast_rtcp_fd(i->rtp);
1984                 if (i->vrtp) {
1985                         tmp->fds[2] = ast_rtp_fd(i->vrtp);
1986                         tmp->fds[3] = ast_rtcp_fd(i->vrtp);
1987                 }
1988                 if (state == AST_STATE_RING)
1989                         tmp->rings = 1;
1990                 tmp->adsicpe = AST_ADSI_UNAVAILABLE;
1991                 tmp->writeformat = fmt;
1992                 tmp->pvt->rawwriteformat = fmt;
1993                 tmp->readformat = fmt;
1994                 tmp->pvt->rawreadformat = fmt;
1995                 tmp->pvt->pvt = i;
1996                 tmp->pvt->send_text = sip_sendtext;
1997                 tmp->pvt->call = sip_call;
1998                 tmp->pvt->hangup = sip_hangup;
1999                 tmp->pvt->answer = sip_answer;
2000                 tmp->pvt->read = sip_read;
2001                 tmp->pvt->write = sip_write;
2002                 tmp->pvt->write_video = sip_write;
2003                 tmp->pvt->indicate = sip_indicate;
2004                 tmp->pvt->transfer = sip_transfer;
2005                 tmp->pvt->fixup = sip_fixup;
2006                 tmp->pvt->send_digit = sip_senddigit;
2007
2008                 tmp->pvt->bridge = ast_rtp_bridge;
2009
2010                 tmp->callgroup = i->callgroup;
2011                 tmp->pickupgroup = i->pickupgroup;
2012                 tmp->cid.cid_pres = i->callingpres;
2013                 if (!ast_strlen_zero(i->accountcode))
2014                         strncpy(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode)-1);
2015                 if (i->amaflags)
2016                         tmp->amaflags = i->amaflags;
2017                 if (!ast_strlen_zero(i->language))
2018                         strncpy(tmp->language, i->language, sizeof(tmp->language)-1);
2019                 if (!ast_strlen_zero(i->musicclass))
2020                         strncpy(tmp->musicclass, i->musicclass, sizeof(tmp->musicclass)-1);
2021                 i->owner = tmp;
2022                 ast_mutex_lock(&usecnt_lock);
2023                 usecnt++;
2024                 ast_mutex_unlock(&usecnt_lock);
2025                 strncpy(tmp->context, i->context, sizeof(tmp->context)-1);
2026                 strncpy(tmp->exten, i->exten, sizeof(tmp->exten)-1);
2027                 if (!ast_strlen_zero(i->cid_num)) 
2028                         tmp->cid.cid_num = strdup(i->cid_num);
2029                 if (!ast_strlen_zero(i->cid_name))
2030                         tmp->cid.cid_name = strdup(i->cid_name);
2031                 if (!ast_strlen_zero(i->rdnis))
2032                         tmp->cid.cid_rdnis = strdup(i->rdnis);
2033                 if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
2034                         tmp->cid.cid_dnid = strdup(i->exten);
2035                 tmp->priority = 1;
2036                 if (!ast_strlen_zero(i->domain)) {
2037                         pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
2038                 }
2039                 if (!ast_strlen_zero(i->useragent)) {
2040                         pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
2041                 }
2042                 if (!ast_strlen_zero(i->callid)) {
2043                         pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
2044                 }
2045                 ast_setstate(tmp, state);
2046                 if (state != AST_STATE_DOWN) {
2047                         if (ast_pbx_start(tmp)) {
2048                                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
2049                                 ast_hangup(tmp);
2050                                 tmp = NULL;
2051                         }
2052                 }
2053         } else
2054                 ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
2055         return tmp;
2056 }
2057
2058 static struct cfalias {
2059         char *fullname;
2060         char *shortname;
2061 } aliases[] = {
2062         { "Content-Type", "c" },
2063         { "Content-Encoding", "e" },
2064         { "From", "f" },
2065         { "Call-ID", "i" },
2066         { "Contact", "m" },
2067         { "Content-Length", "l" },
2068         { "Subject", "s" },
2069         { "To", "t" },
2070         { "Supported", "k" },
2071         { "Refer-To", "r" },
2072         { "Allow-Events", "u" },
2073         { "Event", "o" },
2074         { "Via", "v" },
2075 };
2076
2077 /*--- get_sdp_by_line: Reads one line of SIP message body */
2078 static char* get_sdp_by_line(char* line, char *name, int nameLen) {
2079   if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
2080     char* r = line + nameLen + 1;
2081     while (*r && (*r < 33)) ++r;
2082     return r;
2083   }
2084
2085   return "";
2086 }
2087
2088 /*--- get_sdp: Gets all kind of SIP message bodies, including SDP,
2089    but the name wrongly applies _only_ sdp */
2090 static char *get_sdp(struct sip_request *req, char *name) {
2091   int x;
2092   int len = strlen(name);
2093   char *r;
2094
2095   for (x=0; x<req->lines; x++) {
2096     r = get_sdp_by_line(req->line[x], name, len);
2097     if (r[0] != '\0') return r;
2098   }
2099   return "";
2100 }
2101
2102
2103 static void sdpLineNum_iterator_init(int* iterator) {
2104   *iterator = 0;
2105 }
2106
2107 static char* get_sdp_iterate(int* iterator,
2108                              struct sip_request *req, char *name) {
2109   int len = strlen(name);
2110   char *r;
2111   while (*iterator < req->lines) {
2112     r = get_sdp_by_line(req->line[(*iterator)++], name, len);
2113     if (r[0] != '\0') return r;
2114   }
2115   return "";
2116 }
2117
2118 static char *__get_header(struct sip_request *req, char *name, int *start)
2119 {
2120         int x;
2121         int len = strlen(name);
2122         char *r;
2123         if (pedanticsipchecking) {
2124                 /* Technically you can place arbitrary whitespace both before and after the ':' in
2125                    a header, although RFC3261 clearly says you shouldn't before, and place just
2126                    one afterwards.  If you shouldn't do it, what absolute idiot decided it was 
2127                    a good idea to say you can do it, and if you can do it, why in the hell would 
2128                    you say you shouldn't.  */
2129                 for (x=*start;x<req->headers;x++) {
2130                         if (!strncasecmp(req->header[x], name, len)) {
2131                                 r = req->header[x] + len;
2132                                 while(*r && (*r < 33))
2133                                         r++;
2134                                 if (*r == ':') {
2135                                         r++ ;
2136                                         while(*r && (*r < 33))
2137                                                 r++;
2138                                         *start = x+1;
2139                                         return r;
2140                                 }
2141                         }
2142                 }
2143         } else {
2144                 /* We probably shouldn't even bother counting whitespace afterwards but
2145                    I guess for backwards compatibility we will */
2146                 for (x=*start;x<req->headers;x++) {
2147                         if (!strncasecmp(req->header[x], name, len) && 
2148                                         (req->header[x][len] == ':')) {
2149                                                 r = req->header[x] + len + 1;
2150                                                 while(*r && (*r < 33))
2151                                                                 r++;
2152                                                 *start = x+1;
2153                                                 return r;
2154                         }
2155                 }
2156         }
2157         /* Try aliases */
2158         for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++) 
2159                 if (!strcasecmp(aliases[x].fullname, name))
2160                         return __get_header(req, aliases[x].shortname, start);
2161
2162         /* Don't return NULL, so get_header is always a valid pointer */
2163         return "";
2164 }
2165
2166 /*--- get_header: Get header from SIP request ---*/
2167 static char *get_header(struct sip_request *req, char *name)
2168 {
2169         int start = 0;
2170         return __get_header(req, name, &start);
2171 }
2172
2173 /*--- sip_rtp_read: Read RTP from network ---*/
2174 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p)
2175 {
2176         /* Retrieve audio/etc from channel.  Assumes p->lock is already held. */
2177         struct ast_frame *f;
2178         static struct ast_frame null_frame = { AST_FRAME_NULL, };
2179         switch(ast->fdno) {
2180         case 0:
2181                 f = ast_rtp_read(p->rtp);       /* RTP Audio */
2182                 break;
2183         case 1:
2184                 f = ast_rtcp_read(p->rtp);      /* RTCP Control Channel */
2185                 break;
2186         case 2:
2187                 f = ast_rtp_read(p->vrtp);      /* RTP Video */
2188                 break;
2189         case 3:
2190                 f = ast_rtcp_read(p->vrtp);     /* RTCP Control Channel for video */
2191                 break;
2192         default:
2193                 f = &null_frame;
2194         }
2195         /* Don't send RFC2833 if we're not supposed to */
2196         if (f && (f->frametype == AST_FRAME_DTMF) && !(p->dtmfmode & SIP_DTMF_RFC2833))
2197                 return &null_frame;
2198         if (p->owner) {
2199                 /* We already hold the channel lock */
2200                 if (f->frametype == AST_FRAME_VOICE) {
2201                         if (f->subclass != p->owner->nativeformats) {
2202                                 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
2203                                 p->owner->nativeformats = f->subclass;
2204                                 ast_set_read_format(p->owner, p->owner->readformat);
2205                                 ast_set_write_format(p->owner, p->owner->writeformat);
2206                         }
2207             if ((p->dtmfmode & SIP_DTMF_INBAND) && p->vad) {
2208                    f = ast_dsp_process(p->owner,p->vad,f);
2209                    if (f && (f->frametype == AST_FRAME_DTMF)) 
2210                         ast_log(LOG_DEBUG, "Detected DTMF '%c'\n", f->subclass);
2211             }
2212                 }
2213         }
2214         return f;
2215 }
2216
2217 /*--- sip_read: Read SIP RTP from channel */
2218 static struct ast_frame *sip_read(struct ast_channel *ast)
2219 {
2220         struct ast_frame *fr;
2221         struct sip_pvt *p = ast->pvt->pvt;
2222         ast_mutex_lock(&p->lock);
2223         fr = sip_rtp_read(ast, p);
2224         time(&p->lastrtprx);
2225         ast_mutex_unlock(&p->lock);
2226         return fr;
2227 }
2228
2229 /*--- build_callid: Build SIP CALLID header ---*/
2230 static void build_callid(char *callid, int len, struct in_addr ourip, char *fromdomain)
2231 {
2232         int res;
2233         int val;
2234         int x;
2235         char iabuf[INET_ADDRSTRLEN];
2236         for (x=0;x<4;x++) {
2237                 val = rand();
2238                 res = snprintf(callid, len, "%08x", val);
2239                 len -= res;
2240                 callid += res;
2241         }
2242         if (!ast_strlen_zero(fromdomain))
2243                 snprintf(callid, len, "@%s", fromdomain);
2244         else
2245         /* It's not important that we really use our right IP here... */
2246                 snprintf(callid, len, "@%s", ast_inet_ntoa(iabuf, sizeof(iabuf), ourip));
2247 }
2248
2249 /*--- sip_alloc: Allocate SIP_PVT structure and set defaults ---*/
2250 static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useglobal_nat)
2251 {
2252         struct sip_pvt *p;
2253         char iabuf[INET_ADDRSTRLEN];
2254
2255         p = malloc(sizeof(struct sip_pvt));
2256         if (!p)
2257                 return NULL;
2258         /* Keep track of stuff */
2259         memset(p, 0, sizeof(struct sip_pvt));
2260         ast_mutex_init(&p->lock);
2261         p->initid = -1;
2262         p->autokillid = -1;
2263         p->stateid = -1;
2264 #ifdef OSP_SUPPORT
2265         p->osphandle = -1;
2266 #endif  
2267         if (sin) {
2268                 memcpy(&p->sa, sin, sizeof(p->sa));
2269                 if (ast_sip_ouraddrfor(&p->sa.sin_addr,&p->ourip))
2270                         memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2271         } else {
2272                 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2273         }
2274         p->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2275         if (videosupport)
2276                 p->vrtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2277         p->branch = rand();     
2278         p->tag = rand();
2279         
2280         /* Start with 101 instead of 1 */
2281         p->ocseq = 101;
2282         if (!p->rtp) {
2283                 ast_log(LOG_WARNING, "Unable to create RTP session: %s\n", strerror(errno));
2284                 ast_mutex_destroy(&p->lock);
2285                 free(p);
2286                 return NULL;
2287         }
2288         ast_rtp_settos(p->rtp, tos);
2289         if (p->vrtp)
2290                 ast_rtp_settos(p->vrtp, tos);
2291         if (useglobal_nat && sin) {
2292                 /* Setup NAT structure according to global settings if we have an address */
2293                 p->nat = global_nat;
2294                 memcpy(&p->recv, sin, sizeof(p->recv));
2295                 ast_rtp_setnat(p->rtp, (p->nat & SIP_NAT_ROUTE));
2296                 if (p->vrtp)
2297                         ast_rtp_setnat(p->vrtp, (p->nat & SIP_NAT_ROUTE));
2298         }
2299
2300         strncpy(p->fromdomain, default_fromdomain, sizeof(p->fromdomain) - 1);
2301         /* z9hG4bK is a magic cookie.  See RFC 3261 section 8.1.1.7 */
2302         if (p->nat != SIP_NAT_NEVER)
2303                 snprintf(p->via, sizeof(p->via), "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x;rport", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ourport, p->branch);
2304         else
2305                 snprintf(p->via, sizeof(p->via), "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ourport, p->branch);
2306         if (!callid)
2307                 build_callid(p->callid, sizeof(p->callid), p->ourip, p->fromdomain);
2308         else
2309                 strncpy(p->callid, callid, sizeof(p->callid) - 1);
2310         /* Assume reinvite OK and via INVITE */
2311         p->canreinvite = global_canreinvite;
2312         /* Assign default music on hold class */
2313         strncpy(p->musicclass, global_musicclass, sizeof(p->musicclass) - 1);
2314         p->dtmfmode = global_dtmfmode;
2315         p->promiscredir = global_promiscredir;
2316         p->trustrpid = global_trustrpid;
2317         p->progressinband = global_progressinband;
2318 #ifdef OSP_SUPPORT
2319         p->ospauth = global_ospauth;
2320 #endif
2321         p->rtptimeout = global_rtptimeout;
2322         p->rtpholdtimeout = global_rtpholdtimeout;
2323         p->capability = global_capability;
2324         if (p->dtmfmode & SIP_DTMF_RFC2833)
2325                 p->noncodeccapability |= AST_RTP_DTMF;
2326         strncpy(p->context, default_context, sizeof(p->context) - 1);
2327         /* Add to list */
2328         ast_mutex_lock(&iflock);
2329         p->next = iflist;
2330         iflist = p;
2331         ast_mutex_unlock(&iflock);
2332         if (option_debug)
2333                 ast_log(LOG_DEBUG, "Allocating new SIP call for %s\n", callid);
2334         return p;
2335 }
2336
2337 /*--- find_call: Connect incoming SIP message to current call or create new call structure */
2338 /*               Called by handle_request ,sipsock_read */
2339 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin)
2340 {
2341         struct sip_pvt *p;
2342         char *callid;
2343         char tmp[256] = "";
2344         char iabuf[INET_ADDRSTRLEN];
2345         char *cmd;
2346         char *tag = "", *c;
2347
2348         callid = get_header(req, "Call-ID");
2349
2350         if (pedanticsipchecking) {
2351                 /* In principle Call-ID's uniquely identify a call, however some vendors
2352                    (i.e. Pingtel) send multiple calls with the same Call-ID and different
2353                    tags in order to simplify billing.  The RFC does state that we have to
2354                    compare tags in addition to the call-id, but this generate substantially
2355                    more overhead which is totally unnecessary for the vast majority of sane
2356                    SIP implementations, and thus Asterisk does not enable this behavior
2357                    by default. Short version: You'll need this option to support conferencing
2358                    on the pingtel */
2359                 strncpy(tmp, req->header[0], sizeof(tmp) - 1);
2360                 cmd = tmp;
2361                 c = strchr(tmp, ' ');
2362                 if (c)
2363                         *c = '\0';
2364                 if (!strcasecmp(cmd, "SIP/2.0"))
2365                         strncpy(tmp, get_header(req, "To"), sizeof(tmp) - 1);
2366                 else
2367                         strncpy(tmp, get_header(req, "From"), sizeof(tmp) - 1);
2368                 tag = strstr(tmp, "tag=");
2369                 if (tag) {
2370                         tag += 4;
2371                         c = strchr(tag, ';');
2372                         if (c)
2373                                 *c = '\0';
2374                 }
2375                         
2376         }
2377                 
2378         if (ast_strlen_zero(callid)) {
2379                 ast_log(LOG_WARNING, "Call missing call ID from '%s'\n", ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr));
2380                 return NULL;
2381         }
2382         ast_mutex_lock(&iflock);
2383         p = iflist;
2384         while(p) {
2385                 if (!strcmp(p->callid, callid) && 
2386                         (!pedanticsipchecking || !tag || ast_strlen_zero(p->theirtag) || !strcmp(p->theirtag, tag))) {
2387                         /* Found the call */
2388                         ast_mutex_lock(&p->lock);
2389                         ast_mutex_unlock(&iflock);
2390                         return p;
2391                 }
2392                 p = p->next;
2393         }
2394         ast_mutex_unlock(&iflock);
2395         p = sip_alloc(callid, sin, 1);
2396         if (p)
2397                 ast_mutex_lock(&p->lock);
2398         return p;
2399 }
2400
2401 /*--- sip_register: Parse register=> line in sip.conf and add to registry */
2402 static int sip_register(char *value, int lineno)
2403 {
2404         struct sip_registry *reg;
2405         char copy[256] = "";
2406         char *username=NULL, *hostname=NULL, *secret=NULL, *authuser=NULL;
2407         char *porta=NULL;
2408         char *contact=NULL;
2409         char *stringp=NULL;
2410         
2411         if (!value)
2412                 return -1;
2413         strncpy(copy, value, sizeof(copy)-1);
2414         stringp=copy;
2415         username = stringp;
2416         hostname = strrchr(stringp, '@');
2417         if (hostname) {
2418                 *hostname = '\0';
2419                 hostname++;
2420         }
2421         if (!username || ast_strlen_zero(username) || !hostname || ast_strlen_zero(hostname)) {
2422                 ast_log(LOG_WARNING, "Format for registration is user[:secret[:authuser]]@host[:port][/contact] at line %d", lineno);
2423                 return -1;
2424         }
2425         stringp=username;
2426         username = strsep(&stringp, ":");
2427         if (username) {
2428                 secret = strsep(&stringp, ":");
2429                 if (secret) 
2430                         authuser = strsep(&stringp, ":");
2431         }
2432         stringp = hostname;
2433         hostname = strsep(&stringp, "/");
2434         if (hostname) 
2435                 contact = strsep(&stringp, "/");
2436         if (!contact || ast_strlen_zero(contact))
2437                 contact = "s";
2438         stringp=hostname;
2439         hostname = strsep(&stringp, ":");
2440         porta = strsep(&stringp, ":");
2441         
2442         if (porta && !atoi(porta)) {
2443                 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
2444                 return -1;
2445         }
2446         reg = malloc(sizeof(struct sip_registry));
2447         if (reg) {
2448                 memset(reg, 0, sizeof(struct sip_registry));
2449                 strncpy(reg->contact, contact, sizeof(reg->contact) - 1);
2450                 if (username)
2451                         strncpy(reg->username, username, sizeof(reg->username)-1);
2452                 if (hostname)
2453                         strncpy(reg->hostname, hostname, sizeof(reg->hostname)-1);
2454                 if (authuser)
2455                         strncpy(reg->authuser, authuser, sizeof(reg->authuser)-1);
2456                 if (secret)
2457                         strncpy(reg->secret, secret, sizeof(reg->secret)-1);
2458                 reg->expire = -1;
2459                 reg->timeout =  -1;
2460                 reg->refresh = default_expiry;
2461                 reg->portno = porta ? atoi(porta) : 0;
2462                 reg->callid_valid = 0;
2463                 reg->ocseq = 101;
2464                 ast_mutex_lock(&regl.lock);
2465                 reg->next = regl.registrations;
2466                 regl.registrations = reg;
2467                 ast_mutex_unlock(&regl.lock);
2468         } else {
2469                 ast_log(LOG_ERROR, "Out of memory\n");
2470                 return -1;
2471         }
2472         return 0;
2473 }
2474
2475 /*--- lws2sws: Parse multiline SIP headers into one header */
2476 /* This is enabled if pedanticsipchecking is enabled */
2477 static int lws2sws(char *msgbuf, int len) 
2478
2479         int h = 0, t = 0; 
2480         int lws = 0; 
2481
2482         for (; h < len;) { 
2483                 /* Eliminate all CRs */ 
2484                 if (msgbuf[h] == '\r') { 
2485                         h++; 
2486                         continue; 
2487                 } 
2488                 /* Check for end-of-line */ 
2489                 if (msgbuf[h] == '\n') { 
2490                 /* Check for end-of-message */ 
2491                         if (h + 1 == len) 
2492                         break; 
2493                 /* Check for a continuation line */ 
2494                 if (msgbuf[h + 1] == ' ') { 
2495                 /* Merge continuation line */ 
2496                         h++; 
2497                         continue; 
2498                 } 
2499                 /* Propagate LF and start new line */ 
2500                 msgbuf[t++] = msgbuf[h++]; 
2501                 lws = 0;
2502                 continue; 
2503         } 
2504
2505         if (msgbuf[h] == ' ' || msgbuf[h] == '\t') { 
2506                 if (lws) { 
2507                         h++; 
2508                         continue; 
2509                 } 
2510                 msgbuf[t++] = msgbuf[h++]; 
2511                 lws = 1; 
2512                 continue; 
2513         } 
2514         msgbuf[t++] = msgbuf[h++]; 
2515         if (lws) 
2516                 lws = 0; 
2517         } 
2518         msgbuf[t] = '\0'; 
2519         return t; 
2520 }
2521
2522 /*--- parse: Parse a SIP message ----*/
2523 static void parse(struct sip_request *req)
2524 {
2525         /* Divide fields by NULL's */
2526         char *c;
2527         int f = 0;
2528         c = req->data;
2529
2530         /* First header starts immediately */
2531         req->header[f] = c;
2532         while(*c) {
2533                 if (*c == '\n') {
2534                         /* We've got a new header */
2535                         *c = 0;
2536
2537 #if 0
2538                         printf("Header: %s (%d)\n", req->header[f], strlen(req->header[f]));
2539 #endif                  
2540                         if (ast_strlen_zero(req->header[f])) {
2541                                 /* Line by itself means we're now in content */
2542                                 c++;
2543                                 break;
2544                         }
2545                         if (f >= SIP_MAX_HEADERS - 1) {
2546                                 ast_log(LOG_WARNING, "Too many SIP headers...\n");
2547                         } else
2548                                 f++;
2549                         req->header[f] = c + 1;
2550                 } else if (*c == '\r') {
2551                         /* Ignore but eliminate \r's */
2552                         *c = 0;
2553                 }
2554                 c++;
2555         }
2556         /* Check for last header */
2557         if (!ast_strlen_zero(req->header[f])) 
2558                 f++;
2559         req->headers = f;
2560         /* Now we process any mime content */
2561         f = 0;
2562         req->line[f] = c;
2563         while(*c) {
2564                 if (*c == '\n') {
2565                         /* We've got a new line */
2566                         *c = 0;
2567 #if 0
2568                         printf("Line: %s (%d)\n", req->line[f], strlen(req->line[f]));
2569 #endif                  
2570                         if (f >= SIP_MAX_LINES - 1) {
2571                                 ast_log(LOG_WARNING, "Too many SDP lines...\n");
2572                         } else
2573                                 f++;
2574                         req->line[f] = c + 1;
2575                 } else if (*c == '\r') {
2576                         /* Ignore and eliminate \r's */
2577                         *c = 0;
2578                 }
2579                 c++;
2580         }
2581         /* Check for last line */
2582         if (!ast_strlen_zero(req->line[f])) 
2583                 f++;
2584         req->lines = f;
2585         if (*c) 
2586                 ast_log(LOG_WARNING, "Odd content, extra stuff left over ('%s')\n", c);
2587 }
2588
2589 /*--- process_sdp: Process SIP SDP ---*/
2590 static int process_sdp(struct sip_pvt *p, struct sip_request *req)
2591 {
2592         char *m;
2593         char *c;
2594         char *a;
2595         char host[258];
2596         char iabuf[INET_ADDRSTRLEN];
2597         int len = -1;
2598         int portno=0;
2599         int vportno=0;
2600         int peercapability, peernoncodeccapability;
2601         int vpeercapability=0, vpeernoncodeccapability=0;
2602         struct sockaddr_in sin;
2603         char *codecs;
2604         struct hostent *hp;
2605         struct ast_hostent ahp;
2606         int codec;
2607         int iterator;
2608         int sendonly = 0;
2609         int x;
2610         int debug=sip_debug_test_pvt(p);
2611
2612         /* Update our last rtprx when we receive an SDP, too */
2613         time(&p->lastrtprx);
2614
2615         /* Get codec and RTP info from SDP */
2616         if (strcasecmp(get_header(req, "Content-Type"), "application/sdp")) {
2617                 ast_log(LOG_NOTICE, "Content is '%s', not 'application/sdp'\n", get_header(req, "Content-Type"));
2618                 return -1;
2619         }
2620         m = get_sdp(req, "m");
2621         c = get_sdp(req, "c");
2622         if (ast_strlen_zero(m) || ast_strlen_zero(c)) {
2623                 ast_log(LOG_WARNING, "Insufficient information for SDP (m = '%s', c = '%s')\n", m, c);
2624                 return -1;
2625         }
2626         if (sscanf(c, "IN IP4 %256s", host) != 1) {
2627                 ast_log(LOG_WARNING, "Invalid host in c= line, '%s'\n", c);
2628                 return -1;
2629         }
2630         /* XXX This could block for a long time, and block the main thread! XXX */
2631         hp = ast_gethostbyname(host, &ahp);
2632         if (!hp) {
2633                 ast_log(LOG_WARNING, "Unable to lookup host in c= line, '%s'\n", c);
2634                 return -1;
2635         }
2636         sdpLineNum_iterator_init(&iterator);
2637         p->novideo = 1;
2638         while ((m = get_sdp_iterate(&iterator, req, "m"))[0] != '\0') {
2639                 if ((sscanf(m, "audio %d RTP/AVP %n", &x, &len) == 1)) {
2640                         portno = x;
2641                         /* Scan through the RTP payload types specified in a "m=" line: */
2642                         ast_rtp_pt_clear(p->rtp);
2643                         codecs = m + len;
2644                         while(!ast_strlen_zero(codecs)) {
2645                                 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2646                                         ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2647                                         return -1;
2648                                 }
2649                                 if (debug)
2650                                         ast_verbose("Found RTP audio format %d\n", codec);
2651                                 ast_rtp_set_m_type(p->rtp, codec);
2652                                 codecs += len;
2653                                 /* Skip over any whitespace */
2654                                 while(*codecs && (*codecs < 33)) codecs++;
2655                         }
2656                 }
2657                 if (p->vrtp)
2658                         ast_rtp_pt_clear(p->vrtp);  /* Must be cleared in case no m=video line exists */
2659
2660                 if (p->vrtp && (sscanf(m, "video %d RTP/AVP %n", &x, &len) == 1)) {
2661                         p->novideo = 0;
2662                         vportno = x;
2663                         /* Scan through the RTP payload types specified in a "m=" line: */
2664                         codecs = m + len;
2665                         while(!ast_strlen_zero(codecs)) {
2666                                 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2667                                         ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2668                                         return -1;
2669                                 }
2670                                 if (debug)
2671                                         ast_verbose("Found video format %s\n", ast_getformatname(codec));
2672                                 ast_rtp_set_m_type(p->vrtp, codec);
2673                                 codecs += len;
2674                                 /* Skip over any whitespace */
2675                                 while(*codecs && (*codecs < 33)) codecs++;
2676                         }
2677                 }
2678         }
2679
2680         /* RTP addresses and ports for audio and video */
2681         sin.sin_family = AF_INET;
2682         memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
2683
2684         /* Setup audio port number */
2685         sin.sin_port = htons(portno);
2686         if (p->rtp && sin.sin_port) {
2687                 ast_rtp_set_peer(p->rtp, &sin);
2688                 if (debug) {
2689                         ast_verbose("Peer audio RTP is at port %s:%d\n", ast_inet_ntoa(iabuf,sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2690                         ast_log(LOG_DEBUG,"Peer audio RTP is at port %s:%d\n",ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2691                 }
2692         }
2693         /* Setup video port number */
2694         sin.sin_port = htons(vportno);
2695         if (p->vrtp && sin.sin_port) {
2696                 ast_rtp_set_peer(p->vrtp, &sin);
2697                 if (debug) {
2698                         ast_verbose("Peer video RTP is at port %s:%d\n", ast_inet_ntoa(iabuf,sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2699                         ast_log(LOG_DEBUG,"Peer video RTP is at port %s:%d\n",ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2700                 }
2701         }
2702
2703         /* Next, scan through each "a=rtpmap:" line, noting each
2704          * specified RTP payload type (with corresponding MIME subtype):
2705          */
2706         sdpLineNum_iterator_init(&iterator);
2707         while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
2708       char* mimeSubtype = ast_strdupa(a); /* ensures we have enough space */
2709           if (!strcasecmp(a, "sendonly")) {
2710                 sendonly=1;
2711                 continue;
2712           }
2713           if (!strcasecmp(a, "sendrecv")) {
2714                 sendonly=0;
2715           }
2716           if (sscanf(a, "rtpmap: %u %[^/]/", &codec, mimeSubtype) != 2) continue;
2717           if (debug)
2718                 ast_verbose("Found description format %s\n", mimeSubtype);
2719           /* Note: should really look at the 'freq' and '#chans' params too */
2720           ast_rtp_set_rtpmap_type(p->rtp, codec, "audio", mimeSubtype);
2721           if (p->vrtp)
2722                   ast_rtp_set_rtpmap_type(p->vrtp, codec, "video", mimeSubtype);
2723         }
2724
2725         /* Now gather all of the codecs that were asked for: */
2726         ast_rtp_get_current_formats(p->rtp,
2727                                 &peercapability, &peernoncodeccapability);
2728         if (p->vrtp)
2729                 ast_rtp_get_current_formats(p->vrtp,
2730                                 &vpeercapability, &vpeernoncodeccapability);
2731         p->jointcapability = p->capability & (peercapability | vpeercapability);
2732         p->peercapability = (peercapability | vpeercapability);
2733         p->noncodeccapability = noncodeccapability & peernoncodeccapability;
2734         
2735         if (debug) {
2736                 const unsigned slen=80;
2737                 char s1[slen], s2[slen], s3[slen], s4[slen];
2738
2739                 ast_verbose("Capabilities: us - %s, peer - audio=%s/video=%s, combined - %s\n",
2740                         ast_getformatname_multiple(s1, slen, p->capability),
2741                         ast_getformatname_multiple(s2, slen, peercapability),
2742                         ast_getformatname_multiple(s3, slen, vpeercapability),
2743                         ast_getformatname_multiple(s4, slen, p->jointcapability));
2744
2745                 ast_verbose("Non-codec capabilities: us - %s, peer - %s, combined - %s\n",
2746                         ast_getformatname_multiple(s1, slen, noncodeccapability),
2747                         ast_getformatname_multiple(s2, slen, peernoncodeccapability),
2748                         ast_getformatname_multiple(s3, slen, p->noncodeccapability));
2749         }
2750         if (!p->jointcapability) {
2751                 ast_log(LOG_WARNING, "No compatible codecs!\n");
2752                 return -1;
2753         }
2754         if (p->owner) {
2755                 if (!(p->owner->nativeformats & p->jointcapability)) {
2756                         const unsigned slen=80;
2757                         char s1[slen], s2[slen];
2758                         ast_log(LOG_DEBUG, "Oooh, we need to change our formats since our peer supports only %s and not %s\n", 
2759                                         ast_getformatname_multiple(s1, slen, p->jointcapability),
2760                                         ast_getformatname_multiple(s2, slen, p->owner->nativeformats));
2761                         p->owner->nativeformats = sip_codec_choose(p->jointcapability);
2762                         ast_set_read_format(p->owner, p->owner->readformat);
2763                         ast_set_write_format(p->owner, p->owner->writeformat);
2764                 }
2765                 if (p->owner->bridge) {
2766                         /* Turn on/off music on hold if we are holding/unholding */
2767                         if (sin.sin_addr.s_addr && !sendonly) {
2768                                 ast_moh_stop(p->owner->bridge);
2769                         } else {
2770                                 ast_moh_start(p->owner->bridge, NULL);
2771                         }
2772                 }
2773         }
2774         return 0;
2775         
2776 }
2777
2778 /*--- add_header: Add header to SIP message */
2779 static int add_header(struct sip_request *req, char *var, char *value)
2780 {
2781         if (req->len >= sizeof(req->data) - 4) {
2782                 ast_log(LOG_WARNING, "Out of space, can't add anymore (%s:%s)\n", var, value);
2783                 return -1;
2784         }
2785         if (req->lines) {
2786                 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
2787                 return -1;
2788         }
2789         req->header[req->headers] = req->data + req->len;
2790         snprintf(req->header[req->headers], sizeof(req->data) - req->len - 4, "%s: %s\r\n", var, value);
2791         req->len += strlen(req->header[req->headers]);
2792         if (req->headers < SIP_MAX_HEADERS)
2793                 req->headers++;
2794         else {
2795                 ast_log(LOG_WARNING, "Out of header space\n");
2796                 return -1;
2797         }
2798         return 0;       
2799 }
2800
2801 /*--- add_blank_header: Add blank header to SIP message */
2802 static int add_blank_header(struct sip_request *req)
2803 {
2804         if (req->len >= sizeof(req->data) - 4) {
2805                 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
2806                 return -1;
2807         }
2808         if (req->lines) {
2809                 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
2810                 return -1;
2811         }
2812         req->header[req->headers] = req->data + req->len;
2813         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "\r\n");
2814         req->len += strlen(req->header[req->headers]);
2815         if (req->headers < SIP_MAX_HEADERS)
2816                 req->headers++;
2817         else {
2818                 ast_log(LOG_WARNING, "Out of header space\n");
2819                 return -1;
2820         }
2821         return 0;       
2822 }
2823
2824 /*--- add_line: Add content (not header) to SIP message */
2825 static int add_line(struct sip_request *req, char *line)
2826 {
2827         if (req->len >= sizeof(req->data) - 4) {
2828                 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
2829                 return -1;
2830         }
2831         if (!req->lines) {
2832                 /* Add extra empty return */
2833                 snprintf(req->data + req->len, sizeof(req->data) - req->len, "\r\n");
2834                 req->len += strlen(req->data + req->len);
2835         }
2836         req->line[req->lines] = req->data + req->len;
2837         snprintf(req->line[req->lines], sizeof(req->data) - req->len, "%s", line);
2838         req->len += strlen(req->line[req->lines]);
2839         if (req->lines < SIP_MAX_LINES)
2840                 req->lines++;
2841         else {
2842                 ast_log(LOG_WARNING, "Out of line space\n");
2843                 return -1;
2844         }
2845         return 0;       
2846 }
2847
2848 /*--- copy_header: Copy one header field from one request to another */
2849 static int copy_header(struct sip_request *req, struct sip_request *orig, char *field)
2850 {
2851         char *tmp;
2852         tmp = get_header(orig, field);
2853         if (!ast_strlen_zero(tmp)) {
2854                 /* Add what we're responding to */
2855                 return add_header(req, field, tmp);
2856         }
2857         ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
2858         return -1;
2859 }
2860
2861 /*--- copy_all_header: Copy all headers from one request to another ---*/
2862 static int copy_all_header(struct sip_request *req, struct sip_request *orig, char *field)
2863 {
2864         char *tmp;
2865         int start = 0;
2866         int copied = 0;
2867         for (;;) {
2868                 tmp = __get_header(orig, field, &start);
2869                 if (!ast_strlen_zero(tmp)) {
2870                         /* Add what we're responding to */
2871                         add_header(req, field, tmp);
2872                         copied++;
2873                 } else
2874                         break;
2875         }
2876         return copied ? 0 : -1;
2877 }
2878
2879 /*--- copy_via_headers: Copy SIP VIA Headers from one request to another ---*/
2880 static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, struct sip_request *orig, char *field)
2881 {
2882         char tmp[256]="", *oh, *end;
2883         int start = 0;
2884         int copied = 0;
2885         char new[256];
2886         char iabuf[INET_ADDRSTRLEN];
2887         for (;;) {
2888                 oh = __get_header(orig, field, &start);
2889                 if (!ast_strlen_zero(oh)) {
2890                         /* Strip ;rport */
2891                         strncpy(tmp, oh, sizeof(tmp) - 1);
2892                         oh = strstr(tmp, ";rport");
2893                         if (oh) {
2894                                 end = strchr(oh + 1, ';');
2895                                 if (end)
2896                                         memmove(oh, end, strlen(end) + 1);
2897                                 else
2898                                         *oh = '\0';
2899                         }
2900                         if (!copied && (p->nat == SIP_NAT_ALWAYS)) {
2901                                 /* Whoo hoo!  Now we can indicate port address translation too!  Just
2902                                    another RFC (RFC3581). I'll leave the original comments in for
2903                                    posterity.  */
2904                                 snprintf(new, sizeof(new), "%s;received=%s;rport=%d", tmp, ast_inet_ntoa(iabuf, sizeof(iabuf), p->recv.sin_addr), ntohs(p->recv.sin_port));
2905                                 add_header(req, field, new);
2906                         } else {
2907                                 /* Add what we're responding to */
2908                                 add_header(req, field, tmp);
2909                         }
2910                         copied++;
2911                 } else
2912                         break;
2913         }
2914         if (!copied) {
2915                 ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
2916                 return -1;
2917         }
2918         return 0;
2919 }
2920
2921 /*--- add_route: Add route header into request per learned route ---*/
2922 static void add_route(struct sip_request *req, struct sip_route *route)
2923 {
2924         char r[256], *p;
2925         int n, rem = 255; /* sizeof(r)-1: Room for terminating 0 */
2926
2927         if (!route) return;
2928
2929         p = r;
2930         while (route) {
2931                 n = strlen(route->hop);
2932                 if ((n+3)>rem) break;
2933                 if (p != r) {
2934                         *p++ = ',';
2935                         --rem;
2936                 }
2937                 *p++ = '<';
2938                 strncpy(p, route->hop, rem);  p += n;
2939                 *p++ = '>';
2940                 rem -= (n+2);
2941                 route = route->next;
2942         }
2943         *p = '\0';
2944         add_header(req, "Route", r);
2945 }
2946
2947 /*--- set_destination: Set destination from SIP URI ---*/
2948 static void set_destination(struct sip_pvt *p, char *uri)
2949 {
2950         char *h, *maddr, hostname[256] = "";
2951         char iabuf[INET_ADDRSTRLEN];
2952         int port, hn;
2953         struct hostent *hp;
2954         struct ast_hostent ahp;
2955         int debug=sip_debug_test_pvt(p);
2956
2957         /* Parse uri to h (host) and port - uri is already just the part inside the <> */
2958         /* general form we are expecting is sip[s]:username[:password]@host[:port][;...] */
2959
2960         if (debug)
2961                 ast_verbose("set_destination: Parsing <%s> for address/port to send to\n", uri);
2962
2963         /* Find and parse hostname */
2964         h = strchr(uri, '@');
2965         if (h)
2966                 ++h;
2967         else {
2968                 h = uri;
2969                 if (strncmp(h, "sip:", 4) == 0)
2970                         h += 4;
2971                 else if (strncmp(h, "sips:", 5) == 0)
2972                         h += 5;
2973         }
2974         hn = strcspn(h, ":;>");
2975         if (hn > (sizeof(hostname) - 1)) hn = sizeof(hostname) - 1;
2976         strncpy(hostname, h, hn);  hostname[hn] = '\0'; /* safe */
2977         h+=hn;
2978
2979         /* Is "port" present? if not default to 5060 */
2980         if (*h == ':') {
2981                 /* Parse port */
2982                 ++h;
2983                 port = strtol(h, &h, 10);
2984         }
2985         else
2986                 port = 5060;
2987
2988         /* Got the hostname:port - but maybe there's a "maddr=" to override address? */
2989         maddr = strstr(h, "maddr=");
2990         if (maddr) {
2991                 maddr += 6;
2992                 hn = strspn(maddr, "0123456789.");
2993                 if (hn > (sizeof(hostname) - 1)) hn = sizeof(hostname) - 1;
2994                 strncpy(hostname, maddr, hn);  hostname[hn] = '\0'; /* safe */
2995         }
2996         
2997         hp = ast_gethostbyname(hostname, &ahp);
2998         if (hp == NULL)  {
2999                 ast_log(LOG_WARNING, "Can't find address for host '%s'\n", hostname);
3000                 return;
3001         }
3002         p->sa.sin_family = AF_INET;
3003         memcpy(&p->sa.sin_addr, hp->h_addr, sizeof(p->sa.sin_addr));
3004         p->sa.sin_port = htons(port);
3005         if (debug)
3006                 ast_verbose("set_destination: set destination to %s, port %d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), p->sa.sin_addr), port);
3007 }
3008
3009 /*--- init_resp: Initialize SIP response, based on SIP request ---*/
3010 static int init_resp(struct sip_request *req, char *resp, struct sip_request *orig)
3011 {
3012         /* Initialize a response */
3013         if (req->headers || req->len) {
3014                 ast_log(LOG_WARNING, "Request already initialized?!?\n");
3015                 return -1;
3016         }
3017         req->header[req->headers] = req->data + req->len;
3018         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "SIP/2.0 %s\r\n", resp);
3019         req->len += strlen(req->header[req->headers]);
3020         if (req->headers < SIP_MAX_HEADERS)
3021                 req->headers++;
3022         else
3023                 ast_log(LOG_WARNING, "Out of header space\n");
3024         return 0;
3025 }
3026
3027 /*--- init_req: Initialize SIP request ---*/
3028 static int init_req(struct sip_request *req, char *resp, char *recip)
3029 {
3030         /* Initialize a response */
3031         if (req->headers || req->len) {
3032                 ast_log(LOG_WARNING, "Request already initialized?!?\n");
3033                 return -1;
3034         }
3035         req->header[req->headers] = req->data + req->len;
3036         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "%s %s SIP/2.0\r\n", resp, recip);
3037         req->len += strlen(req->header[req->headers]);
3038         if (req->headers < SIP_MAX_HEADERS)
3039                 req->headers++;
3040         else
3041      &n