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