5ea41e6a11d249720098e5a9703486abebe35cb7
[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 useragent[AST_MAX_EXTENSION] = DEFAULT_USERAGENT;
136
137 static char context[AST_MAX_EXTENSION] = "default";
138
139 static char language[MAX_LANGUAGE] = "";
140
141 static char callerid[AST_MAX_EXTENSION] = "asterisk";
142
143 static char 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 globalrtptimeout = 0;
156
157 static int globalrtpholdtimeout = 0;
158
159 static int globaltrustrpid = 0;
160
161 static int globalprogressinband = 0;
162
163 #ifdef OSP_SUPPORT
164 static int globalospauth = 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 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 globaldtmfmode = SIP_DTMF_RFC2833;           /* DTMF mode default */
201 static int recordhistory = 0;
202 static int globalpromiscredir;
203
204 static char globalmusicclass[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 /* sip_registry: Registrations with other SIP proxies */
479 struct sip_registry {
480         struct sockaddr_in addr;        /* Who we connect to for registration purposes */
481         char username[80];              /* Who we are registering as */
482         char authuser[80];              /* Who we *authenticate* as */
483         char hostname[80];
484         char secret[80];                /* Password or key name in []'s */      
485         char md5secret[80];
486         char contact[80];               /* Contact extension */
487         char random[80];
488         int expire;                     /* Sched ID of expiration */
489         int timeout;                    /* sched id of sip_reg_timeout */
490         int refresh;                    /* How often to refresh */
491         struct sip_pvt *call;           /* create a sip_pvt structure for each outbound "registration call" in progress */
492         int regstate;
493         int callid_valid;               /* 0 means we haven't chosen callid for this registry yet. */
494         char callid[80];                /* Global CallID for this registry */
495         unsigned int ocseq;             /* Sequence number we got to for REGISTERs for this registry */
496         struct sockaddr_in us;          /* Who the server thinks we are */
497         struct sip_registry *next;
498 };
499
500 /*--- The user list: Users and friends ---*/
501 static struct ast_user_list {
502         struct sip_user *users;
503         ast_mutex_t lock;
504 } userl;
505
506 /*--- The peer list: Peers and Friends ---*/
507 static struct ast_peer_list {
508         struct sip_peer *peers;
509         ast_mutex_t lock;
510 } peerl;
511
512 /*--- The register list: Other SIP proxys we register with and call ---*/
513 static struct ast_register_list {
514         struct sip_registry *registrations;
515         ast_mutex_t lock;
516         int recheck;
517 } regl;
518
519
520 #define REINVITE_INVITE         1
521 #define REINVITE_UPDATE         2
522
523 static int __sip_do_register(struct sip_registry *r);
524
525 static int sipsock  = -1;
526 static int globalnat = 0;
527 static int globalcanreinvite = REINVITE_INVITE;
528
529
530 static struct sockaddr_in bindaddr;
531 static struct sockaddr_in externip;
532 static struct ast_ha *localaddr;
533
534 static struct ast_frame  *sip_read(struct ast_channel *ast);
535 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req);
536 static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans);
537 static int transmit_response_with_auth(struct sip_pvt *p, char *msg, struct sip_request *req, char *rand, int reliable, char *header);
538 static int transmit_request(struct sip_pvt *p, char *msg, int inc, int reliable, int newbranch);
539 static int transmit_request_with_auth(struct sip_pvt *p, char *msg, int inc, int reliable, int newbranch);
540 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);
541 static int transmit_reinvite_with_sdp(struct sip_pvt *p);
542 static int transmit_info_with_digit(struct sip_pvt *p, char digit);
543 static int transmit_message_with_text(struct sip_pvt *p, char *text);
544 static int transmit_refer(struct sip_pvt *p, char *dest);
545 static struct sip_peer *temp_peer(char *name);
546 static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader, char *msg, int init);
547 static void free_old_route(struct sip_route *route);
548 static int build_reply_digest(struct sip_pvt *p, char *orig_header, char *digest, int digest_len);
549 static int update_user_counter(struct sip_pvt *fup, int event);
550 static void prune_peers(void);
551 static int sip_do_reload(void);
552
553
554 /*--- sip_debug_test_addr: See if we pass debug IP filter */
555 static inline int sip_debug_test_addr(struct sockaddr_in *addr) 
556 {
557         if (sipdebug == 0)
558                 return 0;
559         if (debugaddr.sin_addr.s_addr) {
560                 if (((ntohs(debugaddr.sin_port) != 0)
561                         && (debugaddr.sin_port != addr->sin_port))
562                         || (debugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
563                         return 0;
564         }
565         return 1;
566 }
567
568 static inline int sip_debug_test_pvt(struct sip_pvt *p) 
569 {
570         if (sipdebug == 0)
571                 return 0;
572         return sip_debug_test_addr((p->nat ? &p->recv : &p->sa));
573 }
574
575
576 /*--- __sip_xmit: Transmit SIP message ---*/
577 static int __sip_xmit(struct sip_pvt *p, char *data, int len)
578 {
579         int res;
580         if (p->nat)
581             res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->recv, sizeof(struct sockaddr_in));
582         else
583             res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->sa, sizeof(struct sockaddr_in));
584         if (res != len) {
585                 ast_log(LOG_WARNING, "sip_xmit of %p (len %d) to %s returned %d: %s\n", data, len, inet_ntoa(p->sa.sin_addr), res, strerror(errno));
586         }
587         return res;
588 }
589
590 static void sip_destroy(struct sip_pvt *p);
591
592 /*--- ast_sip_ouraddrfor: NAT fix - decide which IP address to use for ASterisk server? ---*/
593 /* Only used for outbound registrations */
594 static int ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us)
595 {
596         /*
597          * Using the localaddr structure built up with localnet statements
598          * apply it to their address to see if we need to substitute our
599          * externip or can get away with our internal bindaddr
600          */
601         struct sockaddr_in theirs;
602         theirs.sin_addr = *them;
603         if (localaddr && externip.sin_addr.s_addr &&
604            ast_apply_ha(localaddr, &theirs)) {
605                 char t[256];
606                 memcpy(us, &externip.sin_addr, sizeof(struct in_addr));
607                 strcpy(t, inet_ntoa(*(struct in_addr *)&them->s_addr));
608                 ast_log(LOG_DEBUG, "Target address %s is not local, substituting externip\n", t);
609         }
610         else if (bindaddr.sin_addr.s_addr)
611                 memcpy(us, &bindaddr.sin_addr, sizeof(struct in_addr));
612         else
613                 return ast_ouraddrfor(them, us);
614         return 0;
615 }
616
617 static int append_history(struct sip_pvt *p, char *event, char *data)
618 {
619         struct sip_history *hist, *prev;
620         char *c;
621         if (!recordhistory)
622                 return 0;
623         hist = malloc(sizeof(struct sip_history));
624         if (hist) {
625                 memset(hist, 0, sizeof(struct sip_history));
626                 snprintf(hist->event, sizeof(hist->event), "%-15s %s", event, data);
627                 /* Trim up nicely */
628                 c = hist->event;
629                 while(*c) {
630                         if ((*c == '\r') || (*c == '\n')) {
631                                 *c = '\0';
632                                 break;
633                         }
634                         c++;
635                 }
636                 /* Enqueue into history */
637                 prev = p->history;
638                 if (prev) {
639                         while(prev->next)
640                                 prev = prev->next;
641                         prev->next = hist;
642                 } else {
643                         p->history = hist;
644                 }
645         }
646         return 0;
647 }
648
649 /*--- retrans_pkt: Retransmit SIP message if no answer ---*/
650 static int retrans_pkt(void *data)
651 {
652         struct sip_pkt *pkt=data, *prev, *cur;
653         int res = 0;
654         ast_mutex_lock(&pkt->owner->lock);
655         if (pkt->retrans < MAX_RETRANS) {
656                 pkt->retrans++;
657                 if (sip_debug_test_pvt(pkt->owner)) {
658                         if (pkt->owner->nat)
659                                 ast_verbose("Retransmitting #%d (NAT):\n%s\n to %s:%d\n", pkt->retrans, pkt->data, inet_ntoa(pkt->owner->recv.sin_addr), ntohs(pkt->owner->recv.sin_port));
660                         else
661                                 ast_verbose("Retransmitting #%d (no NAT):\n%s\n to %s:%d\n", pkt->retrans, pkt->data, inet_ntoa(pkt->owner->sa.sin_addr), ntohs(pkt->owner->sa.sin_port));
662                 }
663                 append_history(pkt->owner, "ReTx", pkt->data);
664                 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
665                 res = 1;
666         } else {
667                 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");
668                 append_history(pkt->owner, "MaxRetries", pkt->flags & FLAG_FATAL ? "(Critical)" : "(Non-critical)");
669                 pkt->retransid = -1;
670                 if (pkt->flags & FLAG_FATAL) {
671                         while(pkt->owner->owner && ast_mutex_trylock(&pkt->owner->owner->lock)) {
672                                 ast_mutex_unlock(&pkt->owner->lock);
673                                 usleep(1);
674                                 ast_mutex_lock(&pkt->owner->lock);
675                         }
676                         if (pkt->owner->owner) {
677                                 ast_queue_hangup(pkt->owner->owner);
678                                 ast_mutex_unlock(&pkt->owner->owner->lock);
679                         } else {
680                                 /* If no owner, destroy now */
681                                 pkt->owner->needdestroy = 1;
682                         }
683                 }
684                 /* In any case, go ahead and remove the packet */
685                 prev = NULL;
686                 cur = pkt->owner->packets;
687                 while(cur) {
688                         if (cur == pkt)
689                                 break;
690                         prev = cur;
691                         cur = cur->next;
692                 }
693                 if (cur) {
694                         if (prev)
695                                 prev->next = cur->next;
696                         else
697                                 pkt->owner->packets = cur->next;
698                         ast_mutex_unlock(&pkt->owner->lock);
699                         free(cur);
700                         pkt = NULL;
701                 } else
702                         ast_log(LOG_WARNING, "Weird, couldn't find packet owner!\n");
703         }
704         if (pkt)
705                 ast_mutex_unlock(&pkt->owner->lock);
706         return res;
707 }
708
709 /*--- __sip_reliable_xmit: transmit packet with retransmits ---*/
710 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal)
711 {
712         struct sip_pkt *pkt;
713         pkt = malloc(sizeof(struct sip_pkt) + len);
714         if (!pkt)
715                 return -1;
716         memset(pkt, 0, sizeof(struct sip_pkt));
717         memcpy(pkt->data, data, len);
718         pkt->packetlen = len;
719         pkt->next = p->packets;
720         pkt->owner = p;
721         pkt->seqno = seqno;
722         pkt->flags = resp;
723         if (fatal)
724                 pkt->flags |= FLAG_FATAL;
725         /* Schedule retransmission */
726         pkt->retransid = ast_sched_add(sched, DEFAULT_RETRANS, retrans_pkt, pkt);
727         pkt->next = p->packets;
728         p->packets = pkt;
729         __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
730         if (!strncasecmp(pkt->data, "INVITE", 6)) {
731                 /* Note this is a pending invite */
732                 p->pendinginvite = seqno;
733         }
734         return 0;
735 }
736
737 /*--- __sip_autodestruct: Kill a call (called by scheduler) ---*/
738 static int __sip_autodestruct(void *data)
739 {
740         struct sip_pvt *p = data;
741         p->autokillid = -1;
742         ast_log(LOG_DEBUG, "Auto destroying call '%s'\n", p->callid);
743         append_history(p, "AutoDestroy", "");
744         if (p->owner) {
745                 ast_log(LOG_WARNING, "Autodestruct on call '%s' with owner in place\n", p->callid);
746                 ast_queue_hangup(p->owner);
747         } else {
748                 sip_destroy(p);
749         }
750         return 0;
751 }
752
753 /*--- sip_scheddestroy: Schedule destruction of SIP call ---*/
754 static int sip_scheddestroy(struct sip_pvt *p, int ms)
755 {
756         char tmp[80];
757         if (sip_debug_test_pvt(p))
758                 ast_verbose("Scheduling destruction of call '%s' in %d ms\n", p->callid, ms);
759         if (recordhistory) {
760                 snprintf(tmp, sizeof(tmp), "%d ms", ms);
761                 append_history(p, "SchedDestroy", tmp);
762         }
763         if (p->autokillid > -1)
764                 ast_sched_del(sched, p->autokillid);
765         p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, p);
766         return 0;
767 }
768
769 /*--- sip_cancel_destroy: Cancel destruction of SIP call ---*/
770 static int sip_cancel_destroy(struct sip_pvt *p)
771 {
772         if (p->autokillid > -1)
773                 ast_sched_del(sched, p->autokillid);
774         append_history(p, "CancelDestroy", "");
775         p->autokillid = -1;
776         return 0;
777 }
778
779 /*--- __sip_ack: Acknowledges receipt of a packet and stops retransmission ---*/
780 static int __sip_ack(struct sip_pvt *p, int seqno, int resp)
781 {
782         struct sip_pkt *cur, *prev = NULL;
783         int res = -1;
784         int resetinvite = 0;
785         cur = p->packets;
786         while(cur) {
787                 if ((cur->seqno == seqno) && ((cur->flags & FLAG_RESPONSE) == resp)) {
788                         if (!resp && (seqno == p->pendinginvite)) {
789                                 ast_log(LOG_DEBUG, "Acked pending invite %d\n", p->pendinginvite);
790                                 p->pendinginvite = 0;
791                                 resetinvite = 1;
792                         }
793                         /* this is our baby */
794                         if (prev)
795                                 prev->next = cur->next;
796                         else
797                                 p->packets = cur->next;
798                         if (cur->retransid > -1)
799                                 ast_sched_del(sched, cur->retransid);
800                         free(cur);
801                         res = 0;
802                         break;
803                 }
804                 prev = cur;
805                 cur = cur->next;
806         }
807         ast_log(LOG_DEBUG, "Stopping retransmission on '%s' of %s %d: %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
808         return res;
809 }
810
811 /*--- __sip_semi_ack: Acks receipt of packet, keep it around (used for provisional responses) ---*/
812 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp)
813 {
814         struct sip_pkt *cur;
815         int res = -1;
816         cur = p->packets;
817         while(cur) {
818                 if ((cur->seqno == seqno) && ((cur->flags & FLAG_RESPONSE) == resp)) {
819                         /* this is our baby */
820                         if (cur->retransid > -1)
821                                 ast_sched_del(sched, cur->retransid);
822                         cur->retransid = -1;
823                         res = 0;
824                         break;
825                 }
826                 cur = cur->next;
827         }
828         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");
829         return res;
830 }
831
832 /*--- send_response: Transmit response on SIP request---*/
833 static int send_response(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
834 {
835         int res;
836         if (sip_debug_test_pvt(p)) {
837                 if (p->nat)
838                         ast_verbose("%sTransmitting (NAT):\n%s\n to %s:%d\n", reliable ? "Reliably " : "", req->data, inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));
839                 else
840                         ast_verbose("%sTransmitting (no NAT):\n%s\n to %s:%d\n", reliable ? "Reliably " : "", req->data, inet_ntoa(p->sa.sin_addr), ntohs(p->sa.sin_port));
841         }
842         if (reliable) {
843                 append_history(p, "TxRespRel", req->data);
844                 res = __sip_reliable_xmit(p, seqno, 1, req->data, req->len, (reliable > 1));
845         } else {
846                 append_history(p, "TxResp", req->data);
847                 res = __sip_xmit(p, req->data, req->len);
848         }
849         if (res > 0)
850                 res = 0;
851         return res;
852 }
853
854 /*--- send_request: Send SIP Request to the other part of the dialogue ---*/
855 static int send_request(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
856 {
857         int res;
858         if (sip_debug_test_pvt(p)) {
859                 if (p->nat)
860                         ast_verbose("%sTransmitting:\n%s (NAT) to %s:%d\n", reliable ? "Reliably " : "", req->data, inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));
861                 else
862                         ast_verbose("%sTransmitting:\n%s (no NAT) to %s:%d\n", reliable ? "Reliably " : "", req->data, inet_ntoa(p->sa.sin_addr), ntohs(p->sa.sin_port));
863         }
864         if (reliable) {
865                 append_history(p, "TxReqRel", req->data);
866                 res = __sip_reliable_xmit(p, seqno, 0, req->data, req->len, (reliable > 1));
867         } else {
868                 append_history(p, "TxReq", req->data);
869                 res = __sip_xmit(p, req->data, req->len);
870         }
871         return res;
872 }
873
874 static void url_decode(char *s) 
875 {
876         char *o = s;
877         unsigned int tmp;
878         while(*s) {
879                 switch(*s) {
880                 case '%':
881                         if (strlen(s) > 2) {
882                                 if (sscanf(s + 1, "%2x", &tmp) == 1) {
883                                         *o = tmp;
884                                         s += 2; /* Will be incremented once more when we break out */
885                                         break;
886                                 }
887                         }
888                         /* Fall through if something wasn't right with the formatting */
889                 default:
890                         *o = *s;
891                 }
892                 s++;
893                 o++;
894         }
895         *o = '\0';
896 }
897
898 /*--- ditch_braces: Pick out text in braces from character string  ---*/
899 static char *ditch_braces(char *tmp)
900 {
901         char *c = tmp;
902         char *n;
903         if ((n = strchr(tmp, '<')) ) {
904                 c = n + 1;
905                 while(*c && *c != '>') c++;
906                 if (*c != '>') {
907                         ast_log(LOG_WARNING, "No closing brace in '%s'\n", tmp);
908                 } else {
909                         *c = '\0';
910                 }
911                 return n+1;
912         }
913         return c;
914 }
915
916 /*--- sip_sendtext: Send SIP MESSAGE text within a call ---*/
917 /*      Called from PBX core text message functions */
918 static int sip_sendtext(struct ast_channel *ast, char *text)
919 {
920         struct sip_pvt *p = ast->pvt->pvt;
921         int debug=sip_debug_test_pvt(p);
922
923         if (debug)
924                 ast_verbose("Sending text %s on %s\n", text, ast->name);
925         if (!p)
926                 return -1;
927         if (!text || ast_strlen_zero(text))
928                 return 0;
929         if (debug)
930                 ast_verbose("Really sending text %s on %s\n", text, ast->name);
931         transmit_message_with_text(p, text);
932         return 0;       
933 }
934
935 #ifdef MYSQL_USERS
936
937 /* Ehud Gavron 08-Jun-2004:                                            */
938 /*    The Mysql stuff works great for peers but not for users.         */
939 /* Unfortunately multi-line phones (e.g. cisco 7960) and many          */
940 /* SIP users behind the same NAT gateway need users.  So....           */
941 /*                                                                     */
942 /* mysql_update_user is not needed */
943 /*--- mysql_host: Get user from database ---*/
944 static struct sip_user *mysql_user(char *user)
945 {
946         struct sip_user *u;
947         int success = 0;
948         u = malloc(sizeof(struct sip_user));
949         memset(u, 0, sizeof(struct sip_user));
950         if (mysql && (!user || (strlen(user) < 128))) {
951                 char query[512];
952                 char *name = NULL;
953                 int numfields, x;
954                 time_t regseconds, nowtime;
955                 MYSQL_RES *result;
956                 MYSQL_FIELD *fields;
957                 MYSQL_ROW rowval;
958                 if (user) {
959                         name = alloca(strlen(user) * 2 + 1);
960                         mysql_real_escape_string(mysql, name, user, strlen(user));
961                 }
962
963                 snprintf(query, sizeof(query), "SELECT name, secret, context, username, ipaddr, port, regseconds, callerid, restrictcid FROM sipfriends WHERE name=\"%s\"", name);
964
965
966                 ast_mutex_lock(&mysqllock);
967                 mysql_query(mysql, query);
968                 if ((result = mysql_store_result(mysql))) {
969
970                         if ((rowval = mysql_fetch_row(result))) {
971                                 numfields = mysql_num_fields(result);
972                                 fields = mysql_fetch_fields(result);
973                                 success = 1;
974                                 for (x=0;x<numfields;x++) {
975                                         if (rowval[x]) {
976                                                 if (!strcasecmp(fields[x].name, "secret")) {
977                                                         strncpy(u->secret, rowval[x], sizeof(u->secret));
978                                                 } else if (!strcasecmp(fields[x].name, "name")) {
979                                                         strncpy(u->name, rowval[x], sizeof(u->name) - 1);
980                                                 } else if (!strcasecmp(fields[x].name, "context")) {
981                                                         strncpy(u->context, rowval[x], sizeof(u->context) - 1);
982                                                 } else if (!strcasecmp(fields[x].name, "username")) {
983                                                         strncpy(u->name, rowval[x], sizeof(u->name) - 1);
984                                                 } else if (!strcasecmp(fields[x].name, "regseconds")) {
985                                                         if (sscanf(rowval[x], "%li", &regseconds) != 1)
986                                                                 regseconds = 0;
987                                                 } else if (!strcasecmp(fields[x].name, "restrictcid")) {
988                                                         u->restrictcid = 1;
989                                                 } else if (!strcasecmp(fields[x].name, "callerid")) {
990                                                         strncpy(u->callerid, rowval[x], sizeof(u->callerid) - 1);
991                                                         u->hascallerid=1;
992                                                 }
993                                         }
994                                 }
995                                 time(&nowtime);
996                         }
997                         mysql_free_result(result);
998                         result = NULL;
999                 }
1000                 ast_mutex_unlock(&mysqllock);
1001         }
1002         if (!success) {
1003                 free(u);
1004                 u = NULL;
1005         } else {
1006                 u->capability = capability;
1007                 u->nat = globalnat;
1008                 u->dtmfmode = globaldtmfmode;
1009                 u->insecure = 1;
1010                u->temponly = 1;
1011         }
1012         return u;
1013 }
1014 #endif /* MYSQL_USERS */
1015
1016 #ifdef MYSQL_FRIENDS
1017 /*--- mysql_update_peer: Update peer from database ---*/
1018 /* This function adds registration state to database */
1019 static void mysql_update_peer(char *peer, struct sockaddr_in *sin, char *username, int expiry)
1020 {
1021         if (mysql && (strlen(peer) < 128)) {
1022                 char query[512];
1023                 char *name;
1024                 char *uname;
1025                 time_t nowtime;
1026                 name = alloca(strlen(peer) * 2 + 1);
1027                 uname = alloca(strlen(username) * 2 + 1);
1028                 time(&nowtime);
1029                 mysql_real_escape_string(mysql, name, peer, strlen(peer));
1030                 mysql_real_escape_string(mysql, uname, username, strlen(username));
1031                 snprintf(query, sizeof(query), "UPDATE sipfriends SET ipaddr=\"%s\", port=\"%d\", regseconds=\"%ld\", username=\"%s\" WHERE name=\"%s\"", 
1032                         inet_ntoa(sin->sin_addr), ntohs(sin->sin_port), nowtime + expiry, uname, name);
1033                 ast_mutex_lock(&mysqllock);
1034                 if (mysql_real_query(mysql, query, strlen(query))) 
1035                         ast_log(LOG_WARNING, "Unable to update database\n");
1036                         
1037                 ast_mutex_unlock(&mysqllock);
1038         }
1039 }
1040
1041 /*--- mysql_peer: Get peer from database ---*/
1042 static struct sip_peer *mysql_peer(char *peer, struct sockaddr_in *sin)
1043 {
1044         struct sip_peer *p;
1045         int success = 0;
1046         
1047         p = malloc(sizeof(struct sip_peer));
1048         memset(p, 0, sizeof(struct sip_peer));
1049         if (mysql && (!peer || (strlen(peer) < 128))) {
1050                 char query[512];
1051                 char *name = NULL;
1052                 int numfields, x;
1053                 int port;
1054                 time_t regseconds, nowtime;
1055                 MYSQL_RES *result;
1056                 MYSQL_FIELD *fields;
1057                 MYSQL_ROW rowval;
1058                 if (peer) {
1059                         name = alloca(strlen(peer) * 2 + 1);
1060                         mysql_real_escape_string(mysql, name, peer, strlen(peer));
1061                 }
1062                 if (sin)
1063                         snprintf(query, sizeof(query), "SELECT name, secret, context, username, ipaddr, port, regseconds FROM sipfriends WHERE ipaddr=\"%s\" AND port=\"%d\"", inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
1064                 else
1065                         snprintf(query, sizeof(query), "SELECT name, secret, context, username, ipaddr, port, regseconds FROM sipfriends WHERE name=\"%s\"", name);
1066                 ast_mutex_lock(&mysqllock);
1067                 mysql_query(mysql, query);
1068                 if ((result = mysql_store_result(mysql))) {
1069                         if ((rowval = mysql_fetch_row(result))) {
1070                                 numfields = mysql_num_fields(result);
1071                                 fields = mysql_fetch_fields(result);
1072                                 success = 1;
1073                                 p->addr.sin_family = AF_INET;
1074                                 for (x=0;x<numfields;x++) {
1075                                         if (rowval[x]) {
1076                                                 if (!strcasecmp(fields[x].name, "secret")) {
1077                                                         strncpy(p->secret, rowval[x], sizeof(p->secret));
1078                                                 } else if (!strcasecmp(fields[x].name, "name")) {
1079                                                         strncpy(p->name, rowval[x], sizeof(p->name) - 1);
1080                                                 } else if (!strcasecmp(fields[x].name, "context")) {
1081                                                         strncpy(p->context, rowval[x], sizeof(p->context) - 1);
1082                                                 } else if (!strcasecmp(fields[x].name, "username")) {
1083                                                         strncpy(p->username, rowval[x], sizeof(p->username) - 1);
1084                                                 } else if (!strcasecmp(fields[x].name, "ipaddr")) {
1085                                                         inet_aton(rowval[x], &p->addr.sin_addr);
1086                                                 } else if (!strcasecmp(fields[x].name, "port")) {
1087                                                         if (sscanf(rowval[x], "%i", &port) != 1)
1088                                                                 port = 0;
1089                                                         p->addr.sin_port = htons(port);
1090                                                 } else if (!strcasecmp(fields[x].name, "regseconds")) {
1091                                                         if (sscanf(rowval[x], "%li", &regseconds) != 1)
1092                                                                 regseconds = 0;
1093                                                 }
1094                                         }
1095                                 }
1096                                 time(&nowtime);
1097                                 if (nowtime > regseconds) 
1098                                         memset(&p->addr, 0, sizeof(p->addr));
1099                         }
1100                         mysql_free_result(result);
1101                         result = NULL;
1102                 }
1103                 ast_mutex_unlock(&mysqllock);
1104         }
1105         if (!success) {
1106                 free(p);
1107                 p = NULL;
1108         } else {
1109                 p->dynamic = 1;
1110                 p->capability = capability;
1111                 p->nat = globalnat;
1112                 p->dtmfmode = globaldtmfmode;
1113                 p->promiscredir = globalpromiscredir;
1114                 p->insecure = 1;
1115                 p->expire = -1;
1116                 p->temponly = 1;
1117                 
1118         }
1119         return p;
1120 }
1121 #endif /* MYSQL_FRIENDS */
1122
1123 /*--- update_peer: Update peer data in database (if used) ---*/
1124 static void update_peer(struct sip_peer *p, int expiry)
1125 {
1126 #ifdef MYSQL_FRIENDS
1127         if (p->temponly)
1128                 mysql_update_peer(p->name, &p->addr, p->username, expiry);
1129 #endif
1130         return;
1131 }
1132
1133 /*--- find_peer: Locate peer by name or ip address */
1134 static struct sip_peer *find_peer(char *peer, struct sockaddr_in *sin)
1135 {
1136         struct sip_peer *p = NULL;
1137
1138         p = peerl.peers;
1139         if (peer) {
1140                 /* Find by peer name */
1141                 while(p) {
1142                         if (!strcasecmp(p->name, peer)) {
1143                                 break;
1144                         }
1145                         p = p->next;
1146                 }       
1147         }
1148         else {
1149                 /* Find by sin */
1150                 while(p) {
1151                         if (!inaddrcmp(&p->addr, sin) || 
1152                                         (p->insecure &&
1153                                         (p->addr.sin_addr.s_addr == sin->sin_addr.s_addr))) {
1154                                 break;
1155                         }
1156                         p = p->next;
1157                 }
1158         }
1159
1160 #ifdef MYSQL_FRIENDS
1161         if (!p) {
1162                 p = mysql_peer(peer, sin);
1163         }
1164 #endif
1165
1166         return(p);
1167 }
1168
1169 /*--- find_user: Locate user by name */
1170 static struct sip_user *find_user(char *name)
1171 {
1172         struct sip_user *u = NULL;
1173
1174         u = userl.users;
1175         while(u) {
1176                 if (!strcasecmp(u->name, name)) {
1177                         break;
1178                 }
1179                 u = u->next;
1180         }
1181 #ifdef MYSQL_USERS
1182         if (!u) {
1183                 u = mysql_user(name);
1184         }
1185 #endif /* MYSQL_USERS */
1186         return(u);
1187 }
1188
1189 /*--- create_addr: create address structure from peer definition ---*/
1190 /*      Or, if peer not found, find it in the global DNS */
1191 /*      returns TRUE on failure, FALSE on success */
1192 static int create_addr(struct sip_pvt *r, char *peer)
1193 {
1194         struct hostent *hp;
1195         struct ast_hostent ahp;
1196         struct sip_peer *p;
1197         int found=0;
1198         char *port;
1199         int portno;
1200         char host[256], *hostn;
1201
1202         r->sa.sin_family = AF_INET;
1203         ast_mutex_lock(&peerl.lock);
1204         p = find_peer(peer, NULL);
1205
1206         if (p) {
1207                         found++;
1208                         r->capability = p->capability;
1209                         r->nat = p->nat;
1210                         if (r->rtp) {
1211                                 ast_log(LOG_DEBUG, "Setting NAT on RTP to %d\n", r->nat);
1212                                 ast_rtp_setnat(r->rtp, r->nat);
1213                         }
1214                         if (r->vrtp) {
1215                                 ast_log(LOG_DEBUG, "Setting NAT on VRTP to %d\n", r->nat);
1216                                 ast_rtp_setnat(r->vrtp, r->nat);
1217                         }
1218                         strncpy(r->peername, p->username, sizeof(r->peername)-1);
1219                         strncpy(r->authname, p->username, sizeof(r->authname)-1);
1220                         strncpy(r->peersecret, p->secret, sizeof(r->peersecret)-1);
1221                         strncpy(r->peermd5secret, p->md5secret, sizeof(r->peermd5secret)-1);
1222                         strncpy(r->username, p->username, sizeof(r->username)-1);
1223                         strncpy(r->tohost, p->tohost, sizeof(r->tohost)-1);
1224                         if (ast_strlen_zero(r->tohost)) {
1225                                 if (p->addr.sin_addr.s_addr)
1226                                         snprintf(r->tohost, sizeof(r->tohost), inet_ntoa(p->addr.sin_addr));
1227                                 else
1228                                         snprintf(r->tohost, sizeof(r->tohost), inet_ntoa(p->defaddr.sin_addr));
1229                         }
1230                         if (!ast_strlen_zero(p->fromdomain))
1231                                 strncpy(r->fromdomain, p->fromdomain, sizeof(r->fromdomain)-1);
1232                         if (!ast_strlen_zero(p->fromuser))
1233                                 strncpy(r->fromuser, p->fromuser, sizeof(r->fromuser)-1);
1234                         r->insecure = p->insecure;
1235                         r->canreinvite = p->canreinvite;
1236                         r->maxtime = p->maxms;
1237                         r->callgroup = p->callgroup;
1238                         r->pickupgroup = p->pickupgroup;
1239                         if (p->dtmfmode) {
1240                                 r->dtmfmode = p->dtmfmode;
1241                                 if (r->dtmfmode & SIP_DTMF_RFC2833)
1242                                         r->noncodeccapability |= AST_RTP_DTMF;
1243                                 else
1244                                         r->noncodeccapability &= ~AST_RTP_DTMF;
1245                         }
1246                         r->promiscredir = p->promiscredir;
1247                         strncpy(r->context, p->context,sizeof(r->context)-1);
1248                         if ((p->addr.sin_addr.s_addr || p->defaddr.sin_addr.s_addr) &&
1249                                 (!p->maxms || ((p->lastms > 0)  && (p->lastms <= p->maxms)))) {
1250                                 if (p->addr.sin_addr.s_addr) {
1251                                         r->sa.sin_addr = p->addr.sin_addr;
1252                                         r->sa.sin_port = p->addr.sin_port;
1253                                 } else {
1254                                         r->sa.sin_addr = p->defaddr.sin_addr;
1255                                         r->sa.sin_port = p->defaddr.sin_port;
1256                                 }
1257                                 memcpy(&r->recv, &r->sa, sizeof(r->recv));
1258                         } else {
1259                                 if (p->temponly) {
1260                                         if (p->ha) {
1261                                                 ast_free_ha(p->ha);
1262                                         }
1263                                         free(p);
1264                                 }
1265                                 p = NULL;
1266                         }
1267         }
1268         ast_mutex_unlock(&peerl.lock);
1269         if (!p && !found) {
1270                 if ((port=strchr(peer, ':'))) {
1271                         *port='\0';
1272                         port++;
1273                 }
1274                 hostn = peer;
1275                 if (port)
1276                         portno = atoi(port);
1277                 else
1278                         portno = DEFAULT_SIP_PORT;
1279                 if (srvlookup) {
1280                         char service[256];
1281                         int tportno;
1282                         int ret;
1283                         snprintf(service, sizeof(service), "_sip._udp.%s", peer);
1284                         ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service);
1285                         if (ret > 0) {
1286                                 hostn = host;
1287                                 portno = tportno;
1288                         }
1289                 }
1290                 hp = ast_gethostbyname(hostn, &ahp);
1291                 if (hp) {
1292                         strncpy(r->tohost, peer, sizeof(r->tohost) - 1);
1293                         memcpy(&r->sa.sin_addr, hp->h_addr, sizeof(r->sa.sin_addr));
1294                         r->sa.sin_port = htons(portno);
1295                         memcpy(&r->recv, &r->sa, sizeof(r->recv));
1296                         return 0;
1297                 } else {
1298                         ast_log(LOG_WARNING, "No such host: %s\n", peer);
1299                         return -1;
1300                 }
1301         } else if (!p)
1302                 return -1;
1303         else {
1304                 if (p->temponly) {
1305                         if (p->ha) {
1306                                 ast_free_ha(p->ha);
1307                         }
1308                         free(p);
1309                 }
1310                 return 0;
1311         }
1312 }
1313
1314 /*--- auto_congest: Scheduled congestion on a call ---*/
1315 static int auto_congest(void *nothing)
1316 {
1317         struct sip_pvt *p = nothing;
1318         ast_mutex_lock(&p->lock);
1319         p->initid = -1;
1320         if (p->owner) {
1321                 if (!ast_mutex_trylock(&p->owner->lock)) {
1322                         ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name);
1323                         ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
1324                         ast_mutex_unlock(&p->owner->lock);
1325                 }
1326         }
1327         ast_mutex_unlock(&p->lock);
1328         return 0;
1329 }
1330
1331 /*--- sip_prefs_free: Free codec list in preference structure ---*/
1332 static void sip_prefs_free(void)
1333 {
1334         struct sip_codec_pref *cur, *next;
1335         cur = prefs;
1336         while(cur) {
1337                 next = cur->next;
1338                 free(cur);
1339                 cur = next;
1340         }
1341         prefs = NULL;
1342 }
1343
1344 /*--- sip_pref_remove: Remove codec from pref list ---*/
1345 static void sip_pref_remove(int format)
1346 {
1347         struct sip_codec_pref *cur, *prev=NULL;
1348         cur = prefs;
1349         while(cur) {
1350                 if (cur->codec == format) {
1351                         if (prev)
1352                                 prev->next = cur->next;
1353                         else
1354                                 prefs = cur->next;
1355                         free(cur);
1356                         return;
1357                 }
1358                 prev = cur;
1359                 cur = cur->next;
1360         }
1361 }
1362
1363 /*--- sip_pref_append: Append codec to list ---*/
1364 static int sip_pref_append(int format)
1365 {
1366         struct sip_codec_pref *cur, *tmp;
1367         sip_pref_remove(format);
1368         tmp = (struct sip_codec_pref *)malloc(sizeof(struct sip_codec_pref));
1369         if (!tmp)
1370                 return -1;
1371         memset(tmp, 0, sizeof(struct sip_codec_pref));
1372         tmp->codec = format;
1373         if (prefs) {
1374                 cur = prefs;
1375                 while(cur->next)
1376                         cur = cur->next;
1377                 cur->next = tmp;
1378         } else
1379                 prefs = tmp;
1380         return 0;
1381 }
1382
1383 /*--- sip_codec_choose: Pick a codec ---*/
1384 static int sip_codec_choose(int formats)
1385 {
1386         struct sip_codec_pref *cur;
1387         formats &= ((AST_FORMAT_MAX_AUDIO << 1) - 1);
1388         cur = prefs;
1389         while(cur) {
1390                 if (formats & cur->codec)
1391                         return cur->codec;
1392                 cur = cur->next;
1393         }
1394         return ast_best_codec(formats);
1395 }
1396
1397 /*--- sip_call: Initiate SIP call from PBX ---*/
1398 /*      used from the dial() application      */
1399 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
1400 {
1401         int res;
1402         struct sip_pvt *p;
1403         char *vxml_url = NULL;
1404         char *distinctive_ring = NULL;
1405         char *osptoken = NULL;
1406 #ifdef OSP_SUPPORT
1407         char *osphandle = NULL;
1408 #endif  
1409         struct varshead *headp;
1410         struct ast_var_t *current;
1411         
1412         p = ast->pvt->pvt;
1413         if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
1414                 ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
1415                 return -1;
1416         }
1417         /* Check whether there is vxml_url, distinctive ring variables */
1418
1419         headp=&ast->varshead;
1420         AST_LIST_TRAVERSE(headp,current,entries) {
1421                 /* Check whether there is a VXML_URL variable */
1422                 if (strcasecmp(ast_var_name(current),"VXML_URL")==0)
1423                 {
1424                         vxml_url = ast_var_value(current);
1425                 } else
1426                 /* Check whether there is a ALERT_INFO variable */
1427                 if (strcasecmp(ast_var_name(current),"ALERT_INFO")==0)
1428                 {
1429                         distinctive_ring = ast_var_value(current);
1430                 }
1431 #ifdef OSP_SUPPORT
1432                 else if (!strcasecmp(ast_var_name(current), "OSPTOKEN")) {
1433                         osptoken = ast_var_value(current);
1434                 } else if (!strcasecmp(ast_var_name(current), "OSPHANDLE")) {
1435                         osphandle = ast_var_value(current);
1436                 }
1437 #endif
1438         }
1439         
1440         res = 0;
1441         p->outgoing = 1;
1442 #ifdef OSP_SUPPORT
1443         if (!osptoken || !osphandle || (sscanf(osphandle, "%i", &p->osphandle) != 1)) {
1444                 /* Force Disable OSP support */
1445                 osptoken = NULL;
1446                 osphandle = NULL;
1447                 p->osphandle = -1;
1448         }
1449 #endif
1450         ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);
1451         res = update_user_counter(p,INC_OUT_USE);
1452         if ( res != -1 ) {
1453                 p->restrictcid = ast->restrictcid;
1454                 p->jointcapability = p->capability;
1455                 transmit_invite(p, "INVITE", 1, NULL, NULL, vxml_url,distinctive_ring, osptoken, 1);
1456                 if (p->maxtime) {
1457                         /* Initialize auto-congest time */
1458                         p->initid = ast_sched_add(sched, p->maxtime * 4, auto_congest, p);
1459                 }
1460         }
1461         return res;
1462 }
1463
1464 /*---  __sip_destroy: Execute destrucion of call structure, release memory---*/
1465 static void __sip_destroy(struct sip_pvt *p, int lockowner)
1466 {
1467         struct sip_pvt *cur, *prev = NULL;
1468         struct sip_pkt *cp;
1469         struct sip_history *hist;
1470
1471         if (sip_debug_test_pvt(p))
1472                 ast_verbose("Destroying call '%s'\n", p->callid);
1473         if (p->stateid > -1)
1474                 ast_extension_state_del(p->stateid, NULL);
1475         if (p->initid > -1)
1476                 ast_sched_del(sched, p->initid);
1477         if (p->autokillid > -1)
1478                 ast_sched_del(sched, p->autokillid);
1479
1480         if (p->rtp) {
1481                 ast_rtp_destroy(p->rtp);
1482         }
1483         if (p->vrtp) {
1484                 ast_rtp_destroy(p->vrtp);
1485         }
1486         if (p->route) {
1487                 free_old_route(p->route);
1488                 p->route = NULL;
1489         }
1490         if (p->registry) {
1491                 /* Carefully unlink from registry */
1492                 struct sip_registry *reg;
1493                 ast_mutex_lock(&regl.lock);
1494                 reg = regl.registrations;
1495                 while(reg) {
1496                         if ((reg == p->registry) && (p->registry->call == p))
1497                                 p->registry->call=NULL;
1498                         reg = reg->next;
1499                 }
1500                 ast_mutex_unlock(&regl.lock);
1501         }
1502         /* Unlink us from the owner if we have one */
1503         if (p->owner) {
1504                 if (lockowner)
1505                         ast_mutex_lock(&p->owner->lock);
1506                 ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
1507                 p->owner->pvt->pvt = NULL;
1508                 if (lockowner)
1509                         ast_mutex_unlock(&p->owner->lock);
1510         }
1511         /* Clear history */
1512         while(p->history) {
1513                 hist = p->history;
1514                 p->history = p->history->next;
1515                 free(hist);
1516         }
1517         cur = iflist;
1518         while(cur) {
1519                 if (cur == p) {
1520                         if (prev)
1521                                 prev->next = cur->next;
1522                         else
1523                                 iflist = cur->next;
1524                         break;
1525                 }
1526                 prev = cur;
1527                 cur = cur->next;
1528         }
1529         if (!cur) {
1530                 ast_log(LOG_WARNING, "%p is not in list?!?! \n", cur);
1531         } else {
1532                 if (p->initid > -1)
1533                         ast_sched_del(sched, p->initid);
1534                 while((cp = p->packets)) {
1535                         p->packets = p->packets->next;
1536                         if (cp->retransid > -1)
1537                                 ast_sched_del(sched, cp->retransid);
1538                         free(cp);
1539                 }
1540                 ast_mutex_destroy(&p->lock);
1541                 free(p);
1542         }
1543 }
1544
1545 /*--- update_user_counter: Handle incominglimit and outgoinglimit for SIP users ---*/
1546 /* Note: This is going to be replaced by app_groupcount */
1547 static int update_user_counter(struct sip_pvt *fup, int event)
1548 {
1549         char name[256] = "";
1550         struct sip_user *u;
1551         strncpy(name, fup->username, sizeof(name) - 1);
1552         ast_mutex_lock(&userl.lock);
1553         u = find_user(name);
1554         if (!u) {
1555                 ast_log(LOG_DEBUG, "%s is not a local user\n", name);
1556                 ast_mutex_unlock(&userl.lock);
1557                 return 0;
1558         }
1559         switch(event) {
1560                 /* incoming and outgoing affects the inUse counter */
1561                 case DEC_OUT_USE:
1562                 case DEC_IN_USE:
1563                         if ( u->inUse > 0 ) {
1564                                 u->inUse--;
1565                         } else {
1566                                 u->inUse = 0;
1567                         }
1568                         break;
1569                 case INC_IN_USE:
1570                 case INC_OUT_USE:
1571                         if (u->incominglimit > 0 ) {
1572                                 if (u->inUse >= u->incominglimit) {
1573                                         ast_log(LOG_ERROR, "Call from user '%s' rejected due to usage limit of %d\n", u->name, u->incominglimit);
1574                                         /* inc inUse as well */
1575                                         if ( event == INC_OUT_USE ) {
1576                                                 u->inUse++;
1577                                         }
1578                                         ast_mutex_unlock(&userl.lock);
1579                                         return -1; 
1580                                 }
1581                         }
1582                         u->inUse++;
1583                         ast_log(LOG_DEBUG, "Call from user '%s' is %d out of %d\n", u->name, u->inUse, u->incominglimit);
1584                         break;
1585                 /* we don't use these anymore
1586                 case DEC_OUT_USE:
1587                         if ( u->outUse > 0 ) {
1588                                 u->outUse--;
1589                         } else {
1590                                 u->outUse = 0;
1591                         }
1592                         break;
1593                 case INC_OUT_USE:
1594                         if ( u->outgoinglimit > 0 ) {
1595                                 if ( u->outUse >= u->outgoinglimit ) {
1596                                         ast_log(LOG_ERROR, "Outgoing call from user '%s' rejected due to usage limit of %d\n", u->name, u->outgoinglimit);
1597                                         ast_mutex_unlock(&userl.lock);
1598                                         return -1;
1599                                 }
1600                         }
1601                         u->outUse++;
1602                         break;
1603                 */
1604                 default:
1605                         ast_log(LOG_ERROR, "update_user_counter(%s,%d) called with no event!\n",u->name,event);
1606         }
1607         ast_mutex_unlock(&userl.lock);
1608         return 0;
1609 }
1610
1611 /*--- sip_destroy: Destroy SIP call structure ---*/
1612 static void sip_destroy(struct sip_pvt *p)
1613 {
1614         ast_mutex_lock(&iflock);
1615         __sip_destroy(p, 1);
1616         ast_mutex_unlock(&iflock);
1617 }
1618
1619
1620 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal);
1621
1622 static int hangup_sip2cause(int cause)
1623 {
1624 /* Possible values from causes.h
1625         AST_CAUSE_NOTDEFINED    AST_CAUSE_NORMAL        AST_CAUSE_BUSY
1626         AST_CAUSE_FAILURE       AST_CAUSE_CONGESTION    AST_CAUSE_UNALLOCATED
1627 */
1628
1629         switch(cause) {
1630                 case 404:       /* Not found */
1631                         return AST_CAUSE_UNALLOCATED;
1632                 case 483:       /* Too many hops */
1633                         return AST_CAUSE_FAILURE;
1634                 case 486:
1635                         return AST_CAUSE_BUSY;
1636                 default:
1637                         return AST_CAUSE_NORMAL;
1638         }
1639         /* Never reached */
1640         return 0;
1641 }
1642
1643 static char *hangup_cause2sip(int cause)
1644 {
1645         switch(cause)
1646         {
1647                 case AST_CAUSE_FAILURE:
1648                         return "500 Server internal failure";
1649                 case AST_CAUSE_CONGESTION:
1650                         return "503 Service Unavailable";
1651                 case AST_CAUSE_BUSY:
1652                         return "486 Busy";
1653                 default:
1654                         return NULL;
1655         }
1656         /* Never reached */
1657         return 0;
1658 }
1659
1660 /*--- sip_hangup: Hangup SIP call */
1661 static int sip_hangup(struct ast_channel *ast)
1662 {
1663         struct sip_pvt *p = ast->pvt->pvt;
1664         int needcancel = 0;
1665         int needdestroy = 0;
1666         if (option_debug)
1667                 ast_log(LOG_DEBUG, "sip_hangup(%s)\n", ast->name);
1668         if (!ast->pvt->pvt) {
1669                 ast_log(LOG_DEBUG, "Asked to hangup channel not connected\n");
1670                 return 0;
1671         }
1672         ast_mutex_lock(&p->lock);
1673 #ifdef OSP_SUPPORT
1674         if ((p->osphandle > -1) && (ast->_state == AST_STATE_UP)) {
1675                 ast_osp_terminate(p->osphandle, AST_CAUSE_NORMAL, p->ospstart, time(NULL) - p->ospstart);
1676         }
1677 #endif  
1678         if ( p->outgoing ) {
1679                 ast_log(LOG_DEBUG, "update_user_counter(%s) - decrement outUse counter\n", p->username);
1680                 update_user_counter(p, DEC_OUT_USE);
1681         } else {
1682                 ast_log(LOG_DEBUG, "update_user_counter(%s) - decrement inUse counter\n", p->username);
1683                 update_user_counter(p, DEC_IN_USE);
1684         }
1685         /* Determine how to disconnect */
1686         if (p->owner != ast) {
1687                 ast_log(LOG_WARNING, "Huh?  We aren't the owner?\n");
1688                 ast_mutex_unlock(&p->lock);
1689                 return 0;
1690         }
1691         if (!ast || (ast->_state != AST_STATE_UP))
1692                 needcancel = 1;
1693         /* Disconnect */
1694         p = ast->pvt->pvt;
1695         if (p->vad) {
1696             ast_dsp_free(p->vad);
1697         }
1698         p->owner = NULL;
1699         ast->pvt->pvt = NULL;
1700
1701         ast_mutex_lock(&usecnt_lock);
1702         usecnt--;
1703         ast_mutex_unlock(&usecnt_lock);
1704         ast_update_use_count();
1705
1706         needdestroy = 1; 
1707         /* Start the process if it's not already started */
1708         if (!p->alreadygone && !ast_strlen_zero(p->initreq.data)) {
1709                 if (needcancel) {
1710                         if (p->outgoing) {
1711                                 transmit_request_with_auth(p, "CANCEL", p->ocseq, 1, 0);
1712                                 /* Actually don't destroy us yet, wait for the 487 on our original 
1713                                    INVITE, but do set an autodestruct just in case we never get it. */
1714                                 needdestroy = 0;
1715                                 sip_scheddestroy(p, 15000);
1716                                 if ( p->initid != -1 ) {
1717                                         /* channel still up - reverse dec of inUse counter
1718                                            only if the channel is not auto-congested */
1719                                         if ( p->outgoing ) {
1720                                                 update_user_counter(p, INC_OUT_USE);
1721                                         }
1722                                         else {
1723                                                 update_user_counter(p, INC_IN_USE);
1724                                         }
1725                                 }
1726                         } else {
1727                                 char *res;
1728                                 if (ast->hangupcause && ((res = hangup_cause2sip(ast->hangupcause)))) {
1729                                         transmit_response_reliable(p, res, &p->initreq, 1);
1730                                 } else 
1731                                         transmit_response_reliable(p, "403 Forbidden", &p->initreq, 1);
1732                         }
1733                 } else {
1734                         if (!p->pendinginvite) {
1735                                 /* Send a hangup */
1736                                 transmit_request_with_auth(p, "BYE", 0, 1, 1);
1737                         } else {
1738                                 /* Note we will need a BYE when this all settles out
1739                                    but we can't send one while we have "INVITE" outstanding. */
1740                                 p->pendingbye = 1;
1741                                 p->needreinvite = 0;
1742                         }
1743                 }
1744         }
1745         p->needdestroy = needdestroy;
1746         ast_mutex_unlock(&p->lock);
1747         return 0;
1748 }
1749
1750 /*--- sip_answer: Answer SIP call , send 200 OK on Invite */
1751 static int sip_answer(struct ast_channel *ast)
1752 {
1753         int res = 0,fmt;
1754         char *codec;
1755         struct sip_pvt *p = ast->pvt->pvt;
1756
1757         ast_mutex_lock(&p->lock);
1758         if (ast->_state != AST_STATE_UP) {
1759 #ifdef OSP_SUPPORT      
1760                 time(&p->ospstart);
1761 #endif
1762         
1763                 codec=pbx_builtin_getvar_helper(p->owner,"SIP_CODEC");
1764                 if (codec) {
1765                         fmt=ast_getformatbyname(codec);
1766                         if (fmt) {
1767                                 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC) variable\n",codec);
1768                                 p->jointcapability=fmt;
1769                         } else ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n",codec);
1770                 }
1771
1772                 ast_setstate(ast, AST_STATE_UP);
1773                 if (option_debug)
1774                         ast_log(LOG_DEBUG, "sip_answer(%s)\n", ast->name);
1775                 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, 1);
1776         }
1777         ast_mutex_unlock(&p->lock);
1778         return res;
1779 }
1780
1781 /*--- sip_write: Send response, support audio media ---*/
1782 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
1783 {
1784         struct sip_pvt *p = ast->pvt->pvt;
1785         int res = 0;
1786         if (frame->frametype == AST_FRAME_VOICE) {
1787                 if (!(frame->subclass & ast->nativeformats)) {
1788                         ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
1789                                 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
1790                         return -1;
1791                 }
1792                 if (p) {
1793                         ast_mutex_lock(&p->lock);
1794                         if (p->rtp) {
1795                                 if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) {
1796                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1797                                         p->progress = 1;
1798                                 }
1799                                 res =  ast_rtp_write(p->rtp, frame);
1800                         }
1801                         ast_mutex_unlock(&p->lock);
1802                 }
1803         } else if (frame->frametype == AST_FRAME_VIDEO) {
1804                 if (p) {
1805                         ast_mutex_lock(&p->lock);
1806                         if (p->vrtp) {
1807                                 if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) {
1808                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1809                                         p->progress = 1;
1810                                 }
1811                                 res =  ast_rtp_write(p->vrtp, frame);
1812                         }
1813                         ast_mutex_unlock(&p->lock);
1814                 }
1815         } else if (frame->frametype == AST_FRAME_IMAGE) {
1816                 return 0;
1817         } else {
1818                 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
1819                 return 0;
1820         }
1821
1822         return res;
1823 }
1824
1825 /*--- sip_fixup: Fix up a channel:  If a channel is consumed, this is called.
1826         Basically update any ->owner links ----*/
1827 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
1828 {
1829         struct sip_pvt *p = newchan->pvt->pvt;
1830         ast_mutex_lock(&p->lock);
1831         if (p->owner != oldchan) {
1832                 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
1833                 ast_mutex_unlock(&p->lock);
1834                 return -1;
1835         }
1836         p->owner = newchan;
1837         ast_mutex_unlock(&p->lock);
1838         return 0;
1839 }
1840
1841 /*--- sip_senddigit: Send DTMF character on SIP channel */
1842 /*    within one call, we're able to transmit in many methods simultaneously */
1843 static int sip_senddigit(struct ast_channel *ast, char digit)
1844 {
1845         struct sip_pvt *p = ast->pvt->pvt;
1846         if (p && (p->dtmfmode & SIP_DTMF_INFO)) {
1847                 transmit_info_with_digit(p, digit);
1848         }
1849         if (p && p->rtp && (p->dtmfmode & SIP_DTMF_RFC2833)) {
1850                 ast_rtp_senddigit(p->rtp, digit);
1851         }
1852         /* If in-band DTMF is desired, send that */
1853         if (p->dtmfmode & SIP_DTMF_INBAND)
1854                 return -1;
1855         return 0;
1856 }
1857
1858
1859 /*--- sip_transfer: Transfer SIP call */
1860 static int sip_transfer(struct ast_channel *ast, char *dest)
1861 {
1862         struct sip_pvt *p = ast->pvt->pvt;
1863         int res;
1864         res = transmit_refer(p, dest);
1865         return res;
1866 }
1867
1868 /*--- sip_indicate: Play indication to user */
1869 /* With SIP a lot of indications is sent as messages, letting the device play
1870    the indication - busy signal, congestion etc */
1871 static int sip_indicate(struct ast_channel *ast, int condition)
1872 {
1873         struct sip_pvt *p = ast->pvt->pvt;
1874         switch(condition) {
1875         case AST_CONTROL_RINGING:
1876                 if (ast->_state == AST_STATE_RING) {
1877                         if (!p->progress) {
1878                                 transmit_response(p, "180 Ringing", &p->initreq);
1879                                 p->ringing = 1;
1880                                 if (!p->progressinband)
1881                                         break;
1882                         } else {
1883                                 /* Oops, we've sent progress tones.  Let Asterisk do it instead */
1884                         }
1885                 }
1886                 return -1;
1887         case AST_CONTROL_BUSY:
1888                 if (ast->_state != AST_STATE_UP) {
1889                         transmit_response(p, "486 Busy Here", &p->initreq);
1890                         p->alreadygone = 1;
1891                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1892                         break;
1893                 }
1894                 return -1;
1895         case AST_CONTROL_CONGESTION:
1896                 if (ast->_state != AST_STATE_UP) {
1897                         transmit_response(p, "503 Service Unavailable", &p->initreq);
1898                         p->alreadygone = 1;
1899                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1900                         break;
1901                 }
1902                 return -1;
1903         case AST_CONTROL_PROGRESS:
1904         case AST_CONTROL_PROCEEDING:
1905                 if ((ast->_state != AST_STATE_UP) && !p->progress && !p->outgoing) {
1906                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1907                         p->progress = 1;
1908                         break;
1909                 }
1910                 return -1;
1911         case -1:
1912                 return -1;
1913         default:
1914                 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
1915                 return -1;
1916         }
1917         return 0;
1918 }
1919
1920
1921
1922 /*--- sip_new: Initiate a call in the SIP channel */
1923 /*      called from sip_request_call (calls from the pbx ) */
1924 static struct ast_channel *sip_new(struct sip_pvt *i, int state, char *title)
1925 {
1926         struct ast_channel *tmp;
1927         int fmt;
1928         ast_mutex_unlock(&i->lock);
1929         /* Don't hold a sip pvt lock while we allocate a channel */
1930         tmp = ast_channel_alloc(1);
1931         ast_mutex_lock(&i->lock);
1932         if (tmp) {
1933                 /* Select our native format based on codec preference until we receive
1934                    something from another device to the contrary. */
1935                 if (i->jointcapability)
1936                         tmp->nativeformats = sip_codec_choose(i->jointcapability);
1937                 else if (i->capability)
1938                         tmp->nativeformats = sip_codec_choose(i->capability);
1939                 else
1940                         tmp->nativeformats = sip_codec_choose(capability);
1941                 fmt = ast_best_codec(tmp->nativeformats);
1942                 if (title)
1943                         snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%04x", title, rand() & 0xffff);
1944                 else
1945                         if (strchr(i->fromdomain,':'))
1946                         {
1947                                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", strchr(i->fromdomain,':')+1, (int)(long)(i));
1948                         }
1949                         else
1950                         {
1951                                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", i->fromdomain, (int)(long)(i));
1952                         }
1953                 tmp->type = type;
1954                 if (i->dtmfmode & SIP_DTMF_INBAND) {
1955                     i->vad = ast_dsp_new();
1956                     ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
1957                     if (relaxdtmf)
1958                         ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
1959                 }
1960                 tmp->fds[0] = ast_rtp_fd(i->rtp);
1961                 tmp->fds[1] = ast_rtcp_fd(i->rtp);
1962                 if (i->vrtp) {
1963                         tmp->fds[2] = ast_rtp_fd(i->vrtp);
1964                         tmp->fds[3] = ast_rtcp_fd(i->vrtp);
1965                 }
1966                 if (state == AST_STATE_RING)
1967                         tmp->rings = 1;
1968                 tmp->adsicpe = AST_ADSI_UNAVAILABLE;
1969                 tmp->writeformat = fmt;
1970                 tmp->pvt->rawwriteformat = fmt;
1971                 tmp->readformat = fmt;
1972                 tmp->pvt->rawreadformat = fmt;
1973                 tmp->pvt->pvt = i;
1974                 tmp->pvt->send_text = sip_sendtext;
1975                 tmp->pvt->call = sip_call;
1976                 tmp->pvt->hangup = sip_hangup;
1977                 tmp->pvt->answer = sip_answer;
1978                 tmp->pvt->read = sip_read;
1979                 tmp->pvt->write = sip_write;
1980                 tmp->pvt->write_video = sip_write;
1981                 tmp->pvt->indicate = sip_indicate;
1982                 tmp->pvt->transfer = sip_transfer;
1983                 tmp->pvt->fixup = sip_fixup;
1984                 tmp->pvt->send_digit = sip_senddigit;
1985
1986                 tmp->pvt->bridge = ast_rtp_bridge;
1987
1988                 tmp->callgroup = i->callgroup;
1989                 tmp->pickupgroup = i->pickupgroup;
1990                 tmp->restrictcid = i->restrictcid;
1991                 if (!ast_strlen_zero(i->accountcode))
1992                         strncpy(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode)-1);
1993                 if (i->amaflags)
1994                         tmp->amaflags = i->amaflags;
1995                 if (!ast_strlen_zero(i->language))
1996                         strncpy(tmp->language, i->language, sizeof(tmp->language)-1);
1997                 if (!ast_strlen_zero(i->musicclass))
1998                         strncpy(tmp->musicclass, i->musicclass, sizeof(tmp->musicclass)-1);
1999                 i->owner = tmp;
2000                 ast_mutex_lock(&usecnt_lock);
2001                 usecnt++;
2002                 ast_mutex_unlock(&usecnt_lock);
2003                 strncpy(tmp->context, i->context, sizeof(tmp->context)-1);
2004                 strncpy(tmp->exten, i->exten, sizeof(tmp->exten)-1);
2005                 if (!ast_strlen_zero(i->callerid))
2006                         tmp->callerid = strdup(i->callerid);
2007                 if (!ast_strlen_zero(i->rdnis))
2008                         tmp->rdnis = strdup(i->rdnis);
2009                 if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
2010                         tmp->dnid = strdup(i->exten);
2011                 tmp->priority = 1;
2012                 if (!ast_strlen_zero(i->domain)) {
2013                         pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
2014                 }
2015                 if (!ast_strlen_zero(i->useragent)) {
2016                         pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
2017                 }
2018                 if (!ast_strlen_zero(i->callid)) {
2019                         pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
2020                 }
2021                 ast_setstate(tmp, state);
2022                 if (state != AST_STATE_DOWN) {
2023                         if (ast_pbx_start(tmp)) {
2024                                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
2025                                 ast_hangup(tmp);
2026                                 tmp = NULL;
2027                         }
2028                 }
2029         } else
2030                 ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
2031         return tmp;
2032 }
2033
2034 static struct cfalias {
2035         char *fullname;
2036         char *shortname;
2037 } aliases[] = {
2038         { "Content-Type", "c" },
2039         { "Content-Encoding", "e" },
2040         { "From", "f" },
2041         { "Call-ID", "i" },
2042         { "Contact", "m" },
2043         { "Content-Length", "l" },
2044         { "Subject", "s" },
2045         { "To", "t" },
2046         { "Supported", "k" },
2047         { "Refer-To", "r" },
2048         { "Allow-Events", "u" },
2049         { "Event", "o" },
2050         { "Via", "v" },
2051 };
2052
2053 /*--- get_sdp_by_line: Reads one line of SIP message body */
2054 static char* get_sdp_by_line(char* line, char *name, int nameLen) {
2055   if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
2056     char* r = line + nameLen + 1;
2057     while (*r && (*r < 33)) ++r;
2058     return r;
2059   }
2060
2061   return "";
2062 }
2063
2064 /*--- get_sdp: Gets all kind of SIP message bodies, including SDP,
2065    but the name wrongly applies _only_ sdp */
2066 static char *get_sdp(struct sip_request *req, char *name) {
2067   int x;
2068   int len = strlen(name);
2069   char *r;
2070
2071   for (x=0; x<req->lines; x++) {
2072     r = get_sdp_by_line(req->line[x], name, len);
2073     if (r[0] != '\0') return r;
2074   }
2075   return "";
2076 }
2077
2078
2079 static void sdpLineNum_iterator_init(int* iterator) {
2080   *iterator = 0;
2081 }
2082
2083 static char* get_sdp_iterate(int* iterator,
2084                              struct sip_request *req, char *name) {
2085   int len = strlen(name);
2086   char *r;
2087   while (*iterator < req->lines) {
2088     r = get_sdp_by_line(req->line[(*iterator)++], name, len);
2089     if (r[0] != '\0') return r;
2090   }
2091   return "";
2092 }
2093
2094 static char *__get_header(struct sip_request *req, char *name, int *start)
2095 {
2096         int x;
2097         int len = strlen(name);
2098         char *r;
2099         for (x=*start;x<req->headers;x++) {
2100                 if (!strncasecmp(req->header[x], name, len) && 
2101                                 (req->header[x][len] == ':')) {
2102                                         r = req->header[x] + len + 1;
2103                                         while(*r && (*r < 33))
2104                                                         r++;
2105                                         *start = x+1;
2106                                         return r;
2107                 }
2108         }
2109         /* Try aliases */
2110         for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++) 
2111                 if (!strcasecmp(aliases[x].fullname, name))
2112                         return __get_header(req, aliases[x].shortname, start);
2113
2114         /* Don't return NULL, so get_header is always a valid pointer */
2115         return "";
2116 }
2117
2118 /*--- get_header: Get header from SIP request ---*/
2119 static char *get_header(struct sip_request *req, char *name)
2120 {
2121         int start = 0;
2122         return __get_header(req, name, &start);
2123 }
2124
2125 /*--- sip_rtp_read: Read RTP from network ---*/
2126 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p)
2127 {
2128         /* Retrieve audio/etc from channel.  Assumes p->lock is already held. */
2129         struct ast_frame *f;
2130         static struct ast_frame null_frame = { AST_FRAME_NULL, };
2131         switch(ast->fdno) {
2132         case 0:
2133                 f = ast_rtp_read(p->rtp);       /* RTP Audio */
2134                 break;
2135         case 1:
2136                 f = ast_rtcp_read(p->rtp);      /* RTCP Control Channel */
2137                 break;
2138         case 2:
2139                 f = ast_rtp_read(p->vrtp);      /* RTP Video */
2140                 break;
2141         case 3:
2142                 f = ast_rtcp_read(p->vrtp);     /* RTCP Control Channel for video */
2143                 break;
2144         default:
2145                 f = &null_frame;
2146         }
2147         /* Don't send RFC2833 if we're not supposed to */
2148         if (f && (f->frametype == AST_FRAME_DTMF) && !(p->dtmfmode & SIP_DTMF_RFC2833))
2149                 return &null_frame;
2150         if (p->owner) {
2151                 /* We already hold the channel lock */
2152                 if (f->frametype == AST_FRAME_VOICE) {
2153                         if (f->subclass != p->owner->nativeformats) {
2154                                 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
2155                                 p->owner->nativeformats = f->subclass;
2156                                 ast_set_read_format(p->owner, p->owner->readformat);
2157                                 ast_set_write_format(p->owner, p->owner->writeformat);
2158                         }
2159             if ((p->dtmfmode & SIP_DTMF_INBAND) && p->vad) {
2160                    f = ast_dsp_process(p->owner,p->vad,f);
2161                    if (f && (f->frametype == AST_FRAME_DTMF)) 
2162                         ast_log(LOG_DEBUG, "Detected DTMF '%c'\n", f->subclass);
2163             }
2164                 }
2165         }
2166         return f;
2167 }
2168
2169 /*--- sip_read: Read SIP RTP from channel */
2170 static struct ast_frame *sip_read(struct ast_channel *ast)
2171 {
2172         struct ast_frame *fr;
2173         struct sip_pvt *p = ast->pvt->pvt;
2174         ast_mutex_lock(&p->lock);
2175         fr = sip_rtp_read(ast, p);
2176         time(&p->lastrtprx);
2177         ast_mutex_unlock(&p->lock);
2178         return fr;
2179 }
2180
2181 /*--- build_callid: Build SIP CALLID header ---*/
2182 static void build_callid(char *callid, int len, struct in_addr ourip)
2183 {
2184         int res;
2185         int val;
2186         int x;
2187         for (x=0;x<4;x++) {
2188                 val = rand();
2189                 res = snprintf(callid, len, "%08x", val);
2190                 len -= res;
2191                 callid += res;
2192         }
2193         /* It's not important that we really use our right IP here... */
2194         snprintf(callid, len, "@%s", inet_ntoa(ourip));
2195 }
2196
2197 /*--- sip_alloc: Allocate SIP_PVT structure and set defaults ---*/
2198 static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useglobalnat)
2199 {
2200         struct sip_pvt *p;
2201
2202         p = malloc(sizeof(struct sip_pvt));
2203         if (!p)
2204                 return NULL;
2205         /* Keep track of stuff */
2206         memset(p, 0, sizeof(struct sip_pvt));
2207         ast_mutex_init(&p->lock);
2208         p->initid = -1;
2209         p->autokillid = -1;
2210         p->stateid = -1;
2211 #ifdef OSP_SUPPORT
2212         p->osphandle = -1;
2213 #endif  
2214         p->rtp = ast_rtp_new(sched, io, 1, 0);
2215         if (videosupport)
2216                 p->vrtp = ast_rtp_new(sched, io, 1, 0);
2217         p->branch = rand();     
2218         p->tag = rand();
2219         
2220         /* Start with 101 instead of 1 */
2221         p->ocseq = 101;
2222         if (!p->rtp) {
2223                 ast_log(LOG_WARNING, "Unable to create RTP session: %s\n", strerror(errno));
2224                 ast_mutex_destroy(&p->lock);
2225                 free(p);
2226                 return NULL;
2227         }
2228         ast_rtp_settos(p->rtp, tos);
2229         if (p->vrtp)
2230                 ast_rtp_settos(p->vrtp, tos);
2231         if (useglobalnat && sin) {
2232                 /* Setup NAT structure according to global settings if we have an address */
2233                 p->nat = globalnat;
2234                 memcpy(&p->recv, sin, sizeof(p->recv));
2235                 ast_rtp_setnat(p->rtp, p->nat);
2236                 if (p->vrtp)
2237                         ast_rtp_setnat(p->vrtp, p->nat);
2238         }
2239
2240         if (sin) {
2241                 memcpy(&p->sa, sin, sizeof(p->sa));
2242                 if (ast_sip_ouraddrfor(&p->sa.sin_addr,&p->ourip))
2243                         memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2244         } else {
2245                 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2246         }
2247         /* z9hG4bK is a magic cookie.  See RFC 3261 section 8.1.1.7 */
2248         snprintf(p->via, sizeof(p->via), "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x", inet_ntoa(p->ourip), ourport, p->branch);
2249         if (!callid)
2250                 build_callid(p->callid, sizeof(p->callid), p->ourip);
2251         else
2252                 strncpy(p->callid, callid, sizeof(p->callid) - 1);
2253         /* Assume reinvite OK and via INVITE */
2254         p->canreinvite = globalcanreinvite;
2255         /* Assign default music on hold class */
2256         strncpy(p->musicclass, globalmusicclass, sizeof(p->musicclass));
2257         p->dtmfmode = globaldtmfmode;
2258         p->promiscredir = globalpromiscredir;
2259         p->trustrpid = globaltrustrpid;
2260         p->progressinband = globalprogressinband;
2261 #ifdef OSP_SUPPORT
2262         p->ospauth = globalospauth;
2263 #endif
2264         p->rtptimeout = globalrtptimeout;
2265         p->rtpholdtimeout = globalrtpholdtimeout;
2266         p->capability = capability;
2267         if (p->dtmfmode & SIP_DTMF_RFC2833)
2268                 p->noncodeccapability |= AST_RTP_DTMF;
2269         strncpy(p->context, context, sizeof(p->context) - 1);
2270         strncpy(p->fromdomain, fromdomain, sizeof(p->fromdomain) - 1);
2271         /* Add to list */
2272         ast_mutex_lock(&iflock);
2273         p->next = iflist;
2274         iflist = p;
2275         ast_mutex_unlock(&iflock);
2276         if (option_debug)
2277                 ast_log(LOG_DEBUG, "Allocating new SIP call for %s\n", callid);
2278         return p;
2279 }
2280
2281 /*--- find_call: Connect incoming SIP message to current call or create new call structure */
2282 /*               Called by handle_request ,sipsock_read */
2283 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin)
2284 {
2285         struct sip_pvt *p;
2286         char *callid;
2287         char tmp[256] = "";
2288         char *cmd;
2289         char *tag = "", *c;
2290         int themisfrom;
2291         callid = get_header(req, "Call-ID");
2292
2293         if (pedanticsipchecking) {
2294                 /* In principle Call-ID's uniquely identify a call, however some vendors
2295                    (i.e. Pingtel) send multiple calls with the same Call-ID and different
2296                    tags in order to simplify billing.  The RFC does state that we have to
2297                    compare tags in addition to the call-id, but this generate substantially
2298                    more overhead which is totally unnecessary for the vast majority of sane
2299                    SIP implementations, and thus Asterisk does not enable this behavior
2300                    by default. Short version: You'll need this option to support conferencing
2301                    on the pingtel */
2302                 strncpy(tmp, req->header[0], sizeof(tmp) - 1);
2303                 cmd = tmp;
2304                 c = strchr(tmp, ' ');
2305                 if (c)
2306                         *c = '\0';
2307                 if (!strcasecmp(cmd, "SIP/2.0")) {
2308                         themisfrom = 0;
2309                 } else {
2310                         themisfrom = 1;
2311                 }
2312                 if (themisfrom)
2313                         strncpy(tmp, get_header(req, "From"), sizeof(tmp) - 1);
2314                 else
2315                         strncpy(tmp, get_header(req, "To"), sizeof(tmp) - 1);
2316                 tag = strstr(tmp, "tag=");
2317                 if (tag) {
2318                         tag += 4;
2319                         c = strchr(tag, ';');
2320                         if (c)
2321                                 *c = '\0';
2322                 }
2323                         
2324         }
2325                 
2326         if (ast_strlen_zero(callid)) {
2327                 ast_log(LOG_WARNING, "Call missing call ID from '%s'\n", inet_ntoa(sin->sin_addr));
2328                 return NULL;
2329         }
2330         ast_mutex_lock(&iflock);
2331         p = iflist;
2332         while(p) {
2333                 if (!strcmp(p->callid, callid) && 
2334                         (!pedanticsipchecking || !tag || ast_strlen_zero(p->theirtag) || !strcmp(p->theirtag, tag))) {
2335                         /* Found the call */
2336                         ast_mutex_lock(&p->lock);
2337                         ast_mutex_unlock(&iflock);
2338                         return p;
2339                 }
2340                 p = p->next;
2341         }
2342         ast_mutex_unlock(&iflock);
2343         p = sip_alloc(callid, sin, 1);
2344         if (p)
2345                 ast_mutex_lock(&p->lock);
2346         return p;
2347 }
2348
2349 /*--- sip_register: Parse register=> line in sip.conf and add to registry */
2350 static int sip_register(char *value, int lineno)
2351 {
2352         struct sip_registry *reg;
2353         char copy[256] = "";
2354         char *username=NULL, *hostname=NULL, *secret=NULL, *authuser=NULL;
2355         char *porta=NULL;
2356         char *contact=NULL;
2357         char *stringp=NULL;
2358         
2359         struct hostent *hp;
2360         struct ast_hostent ahp;
2361         if (!value)
2362                 return -1;
2363         strncpy(copy, value, sizeof(copy)-1);
2364         stringp=copy;
2365         username = stringp;
2366         hostname = strrchr(stringp, '@');
2367         if (hostname) {
2368                 *hostname = '\0';
2369                 hostname++;
2370         }
2371         if (!username || ast_strlen_zero(username) || !hostname || ast_strlen_zero(hostname)) {
2372                 ast_log(LOG_WARNING, "Format for registration is user[:secret[:authuser]]@host[:port][/contact] at line %d", lineno);
2373                 return -1;
2374         }
2375         stringp=username;
2376         username = strsep(&stringp, ":");
2377         if (username) {
2378                 secret = strsep(&stringp, ":");
2379                 if (secret) 
2380                         authuser = strsep(&stringp, ":");
2381         }
2382         stringp = hostname;
2383         hostname = strsep(&stringp, "/");
2384         if (hostname) 
2385                 contact = strsep(&stringp, "/");
2386         if (!contact || ast_strlen_zero(contact))
2387                 contact = "s";
2388         stringp=hostname;
2389         hostname = strsep(&stringp, ":");
2390         porta = strsep(&stringp, ":");
2391         
2392         if (porta && !atoi(porta)) {
2393                 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
2394                 return -1;
2395         }
2396         hp = ast_gethostbyname(hostname, &ahp);
2397         if (!hp) {
2398                 ast_log(LOG_WARNING, "Host '%s' not found at line %d\n", hostname, lineno);
2399                 return -1;
2400         }
2401         reg = malloc(sizeof(struct sip_registry));
2402         if (reg) {
2403                 memset(reg, 0, sizeof(struct sip_registry));
2404                 strncpy(reg->contact, contact, sizeof(reg->contact) - 1);
2405                 if (username)
2406                         strncpy(reg->username, username, sizeof(reg->username)-1);
2407                 if (hostname)
2408                         strncpy(reg->hostname, hostname, sizeof(reg->hostname)-1);
2409                 if (authuser)
2410                         strncpy(reg->authuser, authuser, sizeof(reg->authuser)-1);
2411                 if (secret)
2412                         strncpy(reg->secret, secret, sizeof(reg->secret)-1);
2413                 reg->expire = -1;
2414                 reg->timeout =  -1;
2415                 reg->refresh = default_expiry;
2416                 reg->addr.sin_family = AF_INET;
2417                 memcpy(&reg->addr.sin_addr, hp->h_addr, sizeof(&reg->addr.sin_addr));
2418                 reg->addr.sin_port = porta ? htons(atoi(porta)) : htons(DEFAULT_SIP_PORT);
2419                 reg->callid_valid = 0;
2420                 reg->ocseq = 101;
2421                 ast_mutex_lock(&regl.lock);
2422                 reg->next = regl.registrations;
2423                 regl.registrations = reg;
2424                 ast_mutex_unlock(&regl.lock);
2425         } else {
2426                 ast_log(LOG_ERROR, "Out of memory\n");
2427                 return -1;
2428         }
2429         return 0;
2430 }
2431
2432 /*--- lws2sws: Parse multiline SIP headers into one header */
2433 /* This is enabled if pedanticsipchecking is enabled */
2434 static int lws2sws(char *msgbuf, int len) 
2435
2436         int h = 0, t = 0; 
2437         int lws = 0; 
2438
2439         for (; h < len;) { 
2440                 /* Eliminate all CRs */ 
2441                 if (msgbuf[h] == '\r') { 
2442                         h++; 
2443                         continue; 
2444                 } 
2445                 /* Check for end-of-line */ 
2446                 if (msgbuf[h] == '\n') { 
2447                 /* Check for end-of-message */ 
2448                         if (h + 1 == len) 
2449                         break; 
2450                 /* Check for a continuation line */ 
2451                 if (msgbuf[h + 1] == ' ') { 
2452                 /* Merge continuation line */ 
2453                         h++; 
2454                         continue; 
2455                 } 
2456                 /* Propagate LF and start new line */ 
2457                 msgbuf[t++] = msgbuf[h++]; 
2458                 lws = 0;
2459                 continue; 
2460         } 
2461
2462         if (msgbuf[h] == ' ' || msgbuf[h] == '\t') { 
2463                 if (lws) { 
2464                         h++; 
2465                         continue; 
2466                 } 
2467                 msgbuf[t++] = msgbuf[h++]; 
2468                 lws = 1; 
2469                 continue; 
2470         } 
2471         msgbuf[t++] = msgbuf[h++]; 
2472         if (lws) 
2473                 lws = 0; 
2474         } 
2475         msgbuf[t] = '\0'; 
2476         return t; 
2477 }
2478
2479 /*--- parse: Parse a SIP message ----*/
2480 static void parse(struct sip_request *req)
2481 {
2482         /* Divide fields by NULL's */
2483         char *c;
2484         int f = 0;
2485         c = req->data;
2486
2487         /* First header starts immediately */
2488         req->header[f] = c;
2489         while(*c) {
2490                 if (*c == '\n') {
2491                         /* We've got a new header */
2492                         *c = 0;
2493
2494 #if 0
2495                         printf("Header: %s (%d)\n", req->header[f], strlen(req->header[f]));
2496 #endif                  
2497                         if (ast_strlen_zero(req->header[f])) {
2498                                 /* Line by itself means we're now in content */
2499                                 c++;
2500                                 break;
2501                         }
2502                         if (f >= SIP_MAX_HEADERS - 1) {
2503                                 ast_log(LOG_WARNING, "Too many SIP headers...\n");
2504                         } else
2505                                 f++;
2506                         req->header[f] = c + 1;
2507                 } else if (*c == '\r') {
2508                         /* Ignore but eliminate \r's */
2509                         *c = 0;
2510                 }
2511                 c++;
2512         }
2513         /* Check for last header */
2514         if (!ast_strlen_zero(req->header[f])) 
2515                 f++;
2516         req->headers = f;
2517         /* Now we process any mime content */
2518         f = 0;
2519         req->line[f] = c;
2520         while(*c) {
2521                 if (*c == '\n') {
2522                         /* We've got a new line */
2523                         *c = 0;
2524 #if 0
2525                         printf("Line: %s (%d)\n", req->line[f], strlen(req->line[f]));
2526 #endif                  
2527                         if (f >= SIP_MAX_LINES - 1) {
2528                                 ast_log(LOG_WARNING, "Too many SDP lines...\n");
2529                         } else
2530                                 f++;
2531                         req->line[f] = c + 1;
2532                 } else if (*c == '\r') {
2533                         /* Ignore and eliminate \r's */
2534                         *c = 0;
2535                 }
2536                 c++;
2537         }
2538         /* Check for last line */
2539         if (!ast_strlen_zero(req->line[f])) 
2540                 f++;
2541         req->lines = f;
2542         if (*c) 
2543                 ast_log(LOG_WARNING, "Odd content, extra stuff left over ('%s')\n", c);
2544 }
2545
2546 /*--- process_sdp: Process SIP SDP ---*/
2547 static int process_sdp(struct sip_pvt *p, struct sip_request *req)
2548 {
2549         char *m;
2550         char *c;
2551         char *a;
2552         char host[258];
2553         int len = -1;
2554         int portno=0;
2555         int vportno=0;
2556         int peercapability, peernoncodeccapability;
2557         int vpeercapability=0, vpeernoncodeccapability=0;
2558         struct sockaddr_in sin;
2559         char *codecs;
2560         struct hostent *hp;
2561         struct ast_hostent ahp;
2562         int codec;
2563         int iterator;
2564         int sendonly = 0;
2565         int x;
2566         int debug=sip_debug_test_pvt(p);
2567
2568         /* Update our last rtprx when we receive an SDP, too */
2569         time(&p->lastrtprx);
2570
2571         /* Get codec and RTP info from SDP */
2572         if (strcasecmp(get_header(req, "Content-Type"), "application/sdp")) {
2573                 ast_log(LOG_NOTICE, "Content is '%s', not 'application/sdp'\n", get_header(req, "Content-Type"));
2574                 return -1;
2575         }
2576         m = get_sdp(req, "m");
2577         c = get_sdp(req, "c");
2578         if (ast_strlen_zero(m) || ast_strlen_zero(c)) {
2579                 ast_log(LOG_WARNING, "Insufficient information for SDP (m = '%s', c = '%s')\n", m, c);
2580                 return -1;
2581         }
2582         if (sscanf(c, "IN IP4 %256s", host) != 1) {
2583                 ast_log(LOG_WARNING, "Invalid host in c= line, '%s'\n", c);
2584                 return -1;
2585         }
2586         /* XXX This could block for a long time, and block the main thread! XXX */
2587         hp = ast_gethostbyname(host, &ahp);
2588         if (!hp) {
2589                 ast_log(LOG_WARNING, "Unable to lookup host in c= line, '%s'\n", c);
2590                 return -1;
2591         }
2592         sdpLineNum_iterator_init(&iterator);
2593         while ((m = get_sdp_iterate(&iterator, req, "m"))[0] != '\0') {
2594                 if ((sscanf(m, "audio %d RTP/AVP %n", &x, &len) == 1)) {
2595                         portno = x;
2596                         /* Scan through the RTP payload types specified in a "m=" line: */
2597                         ast_rtp_pt_clear(p->rtp);
2598                         codecs = m + len;
2599                         while(!ast_strlen_zero(codecs)) {
2600                                 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2601                                         ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2602                                         return -1;
2603                                 }
2604                                 if (debug)
2605                                         ast_verbose("Found RTP audio format %d\n", codec);
2606                                 ast_rtp_set_m_type(p->rtp, codec);
2607                                 codecs += len;
2608                                 /* Skip over any whitespace */
2609                                 while(*codecs && (*codecs < 33)) codecs++;
2610                         }
2611                 }
2612                 if (p->vrtp)
2613                         ast_rtp_pt_clear(p->vrtp);  /* Must be cleared in case no m=video line exists */
2614
2615                 if (p->vrtp && (sscanf(m, "video %d RTP/AVP %n", &x, &len) == 1)) {
2616                         vportno = x;
2617                         /* Scan through the RTP payload types specified in a "m=" line: */
2618                         codecs = m + len;
2619                         while(!ast_strlen_zero(codecs)) {
2620                                 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2621                                         ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2622                                         return -1;
2623                                 }
2624                                 if (debug)
2625                                         ast_verbose("Found video format %s\n", ast_getformatname(codec));
2626                                 ast_rtp_set_m_type(p->vrtp, codec);
2627                                 codecs += len;
2628                                 /* Skip over any whitespace */
2629                                 while(*codecs && (*codecs < 33)) codecs++;
2630                         }
2631                 }
2632         }
2633
2634         /* RTP addresses and ports for audio and video */
2635         sin.sin_family = AF_INET;
2636         memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
2637         /* Setup audio port number */
2638         sin.sin_port = htons(portno);
2639         if (p->rtp && sin.sin_port)
2640                 ast_rtp_set_peer(p->rtp, &sin);
2641         /* Setup video port number */
2642         sin.sin_port = htons(vportno);
2643         if (p->vrtp && sin.sin_port)
2644                 ast_rtp_set_peer(p->vrtp, &sin);
2645
2646         if (sipdebug)
2647                 ast_verbose("Peer RTP is at port %s:%d\n", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
2648
2649         /* Next, scan through each "a=rtpmap:" line, noting each
2650          * specified RTP payload type (with corresponding MIME subtype):
2651          */
2652         sdpLineNum_iterator_init(&iterator);
2653         while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
2654       char* mimeSubtype = ast_strdupa(a); /* ensures we have enough space */
2655           if (!strcasecmp(a, "sendonly")) {
2656                 sendonly=1;
2657                 continue;
2658           }
2659           if (!strcasecmp(a, "sendrecv")) {
2660                 sendonly=0;
2661           }
2662           if (sscanf(a, "rtpmap: %u %[^/]/", &codec, mimeSubtype) != 2) continue;
2663           if (debug)
2664                 ast_verbose("Found description format %s\n", mimeSubtype);
2665           /* Note: should really look at the 'freq' and '#chans' params too */
2666           ast_rtp_set_rtpmap_type(p->rtp, codec, "audio", mimeSubtype);
2667           if (p->vrtp)
2668                   ast_rtp_set_rtpmap_type(p->vrtp, codec, "video", mimeSubtype);
2669         }
2670
2671         /* Now gather all of the codecs that were asked for: */
2672         ast_rtp_get_current_formats(p->rtp,
2673                                 &peercapability, &peernoncodeccapability);
2674         if (p->vrtp)
2675                 ast_rtp_get_current_formats(p->vrtp,
2676                                 &vpeercapability, &vpeernoncodeccapability);
2677         p->jointcapability = p->capability & (peercapability | vpeercapability);
2678         p->noncodeccapability = noncodeccapability & (peernoncodeccapability | vpeernoncodeccapability);
2679         
2680         if (debug) {
2681                 const unsigned slen=80;
2682                 char s1[slen], s2[slen], s3[slen], s4[slen];
2683
2684                 ast_verbose("Capabilities: us - %s, peer - audio=%s/video=%s, combined - %s\n",
2685                         ast_getformatname_multiple(s1, slen, p->capability),
2686                         ast_getformatname_multiple(s2, slen, peercapability),
2687                         ast_getformatname_multiple(s3, slen, vpeercapability),
2688                         ast_getformatname_multiple(s4, slen, p->jointcapability));
2689
2690                 ast_verbose("Non-codec capabilities: us - %s, peer - %s, combined - %s\n",
2691                         ast_getformatname_multiple(s1, slen, noncodeccapability),
2692                         ast_getformatname_multiple(s2, slen, peernoncodeccapability),
2693                         ast_getformatname_multiple(s3, slen, p->noncodeccapability));
2694         }
2695         if (!p->jointcapability) {
2696                 ast_log(LOG_WARNING, "No compatible codecs!\n");
2697                 return -1;
2698         }
2699         if (p->owner) {
2700                 if (!(p->owner->nativeformats & p->jointcapability)) {
2701                         const unsigned slen=80;
2702                         char s1[slen], s2[slen];
2703                         ast_log(LOG_DEBUG, "Oooh, we need to change our formats since our peer supports only %s and not %s\n", 
2704                                         ast_getformatname_multiple(s1, slen, p->jointcapability),
2705                                         ast_getformatname_multiple(s2, slen, p->owner->nativeformats));
2706                         p->owner->nativeformats = sip_codec_choose(p->jointcapability);
2707                         ast_set_read_format(p->owner, p->owner->readformat);
2708                         ast_set_write_format(p->owner, p->owner->writeformat);
2709                 }
2710                 if (p->owner->bridge) {
2711                         /* Turn on/off music on hold if we are holding/unholding */
2712                         if (sin.sin_addr.s_addr && !sendonly) {
2713                                 ast_moh_stop(p->owner->bridge);
2714                         } else {
2715                                 ast_moh_start(p->owner->bridge, NULL);
2716                         }
2717                 }
2718         }
2719         return 0;
2720         
2721 }
2722
2723 /*--- add_header: Add header to SIP message */
2724 static int add_header(struct sip_request *req, char *var, char *value)
2725 {
2726         if (req->len >= sizeof(req->data) - 4) {
2727                 ast_log(LOG_WARNING, "Out of space, can't add anymore (%s:%s)\n", var, value);
2728                 return -1;
2729         }
2730         if (req->lines) {
2731                 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
2732                 return -1;
2733         }
2734         req->header[req->headers] = req->data + req->len;
2735         snprintf(req->header[req->headers], sizeof(req->data) - req->len - 4, "%s: %s\r\n", var, value);
2736         req->len += strlen(req->header[req->headers]);
2737         if (req->headers < SIP_MAX_HEADERS)
2738                 req->headers++;
2739         else {
2740                 ast_log(LOG_WARNING, "Out of header space\n");
2741                 return -1;
2742         }
2743         return 0;       
2744 }
2745
2746 /*--- add_blank_header: Add blank header to SIP message */
2747 static int add_blank_header(struct sip_request *req)
2748 {
2749         if (req->len >= sizeof(req->data) - 4) {
2750                 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
2751                 return -1;
2752         }
2753         if (req->lines) {
2754                 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
2755                 return -1;
2756         }
2757         req->header[req->headers] = req->data + req->len;
2758         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "\r\n");
2759         req->len += strlen(req->header[req->headers]);
2760         if (req->headers < SIP_MAX_HEADERS)
2761                 req->headers++;
2762         else {
2763                 ast_log(LOG_WARNING, "Out of header space\n");
2764                 return -1;
2765         }
2766         return 0;       
2767 }
2768
2769 /*--- add_line: Add content (not header) to SIP message */
2770 static int add_line(struct sip_request *req, char *line)
2771 {
2772         if (req->len >= sizeof(req->data) - 4) {
2773                 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
2774                 return -1;
2775         }
2776         if (!req->lines) {
2777                 /* Add extra empty return */
2778                 snprintf(req->data + req->len, sizeof(req->data) - req->len, "\r\n");
2779                 req->len += strlen(req->data + req->len);
2780         }
2781         req->line[req->lines] = req->data + req->len;
2782         snprintf(req->line[req->lines], sizeof(req->data) - req->len, "%s", line);
2783         req->len += strlen(req->line[req->lines]);
2784         if (req->lines < SIP_MAX_LINES)
2785                 req->lines++;
2786         else {
2787                 ast_log(LOG_WARNING, "Out of line space\n");
2788                 return -1;
2789         }
2790         return 0;       
2791 }
2792
2793 /*--- copy_header: Copy one header field from one request to another */
2794 static int copy_header(struct sip_request *req, struct sip_request *orig, char *field)
2795 {
2796         char *tmp;
2797         tmp = get_header(orig, field);
2798         if (!ast_strlen_zero(tmp)) {
2799                 /* Add what we're responding to */
2800                 return add_header(req, field, tmp);
2801         }
2802         ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
2803         return -1;
2804 }
2805
2806 /*--- copy_all_header: Copy all headers from one request to another ---*/
2807 static int copy_all_header(struct sip_request *req, struct sip_request *orig, char *field)
2808 {
2809         char *tmp;
2810         int start = 0;
2811         int copied = 0;
2812         for (;;) {
2813                 tmp = __get_header(orig, field, &start);
2814                 if (!ast_strlen_zero(tmp)) {
2815                         /* Add what we're responding to */
2816                         add_header(req, field, tmp);
2817                         copied++;
2818                 } else
2819                         break;
2820         }
2821         return copied ? 0 : -1;
2822 }
2823
2824 /*--- copy_via_headers: Copy SIP VIA Headers from one request to another ---*/
2825 static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, struct sip_request *orig, char *field)
2826 {
2827         char *tmp;
2828         int start = 0;
2829         int copied = 0;
2830         char new[256];
2831         for (;;) {
2832                 tmp = __get_header(orig, field, &start);
2833                 if (!ast_strlen_zero(tmp)) {
2834                         if (!copied && p->nat) {
2835                                 /* Whoo hoo!  Now we can indicate port address translation too!  Just
2836                                    another RFC (RFC3581). I'll leave the original comments in for
2837                                    posterity.  */
2838 #ifdef THE_SIP_AUTHORS_CAN_SUCK_MY_GONADS
2839                                 /* SLD: FIXME: Nice try, but the received= should not have a port */
2840                                 /* SLD: FIXME: See RFC2543 BNF in Section 6.40.5 */
2841                                 /* MAS: Yup, RFC says you can't do it.  No way to indicate PAT...
2842                                    good job fellas. */
2843                                 if (ntohs(p->recv.sin_port) != DEFAULT_SIP_PORT)
2844                                         snprintf(new, sizeof(new), "%s;received=%s:%d", tmp, inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));
2845                                 else
2846 #endif                          
2847                                 snprintf(new, sizeof(new), "%s;received=%s;rport=%d", tmp, inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));
2848                                 add_header(req, field, new);
2849                         } else {
2850                                 /* Add what we're responding to */
2851                                 add_header(req, field, tmp);
2852                         }
2853                         copied++;
2854                 } else
2855                         break;
2856         }
2857         if (!copied) {
2858                 ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
2859                 return -1;
2860         }
2861         return 0;
2862 }
2863
2864 /*--- add_route: Add route header into request per learned route ---*/
2865 static void add_route(struct sip_request *req, struct sip_route *route)
2866 {
2867         char r[256], *p;
2868         int n, rem = 255; /* sizeof(r)-1: Room for terminating 0 */
2869
2870         if (!route) return;
2871
2872         p = r;
2873         while (route) {
2874                 n = strlen(route->hop);
2875                 if ((n+3)>rem) break;
2876                 if (p != r) {
2877                         *p++ = ',';
2878                         --rem;
2879                 }
2880                 *p++ = '<';
2881                 strcpy(p, route->hop);  p += n;
2882                 *p++ = '>';
2883                 rem -= (n+2);
2884                 route = route->next;
2885         }
2886         *p = '\0';
2887         add_header(req, "Route", r);
2888 }
2889
2890 /*--- set_destination: Set destination from SIP URI ---*/
2891 static void set_destination(struct sip_pvt *p, char *uri)
2892 {
2893         char *h, *maddr, hostname[256];
2894         int port, hn;
2895         struct hostent *hp;
2896         struct ast_hostent ahp;
2897         int debug=sip_debug_test_pvt(p);
2898
2899         /* Parse uri to h (host) and port - uri is already just the part inside the <> */
2900         /* general form we are expecting is sip[s]:username[:password]@host[:port][;...] */
2901
2902         if (debug)
2903                 ast_verbose("set_destination: Parsing <%s> for address/port to send to\n", uri);
2904
2905         /* Find and parse hostname */
2906         h = strchr(uri, '@');
2907         if (h)
2908                 ++h;
2909         else {
2910                 h = uri;
2911                 if (strncmp(h, "sip:", 4) == 0)
2912                         h += 4;
2913                 else if (strncmp(h, "sips:", 5) == 0)
2914                         h += 5;
2915         }
2916         hn = strcspn(h, ":;>");
2917         if (hn>255) hn=255;
2918         strncpy(hostname, h, hn);  hostname[hn] = '\0';
2919         h+=hn;
2920
2921         /* Is "port" present? if not default to 5060 */
2922         if (*h == ':') {
2923                 /* Parse port */
2924                 ++h;
2925                 port = strtol(h, &h, 10);
2926         }
2927         else
2928                 port = 5060;
2929
2930         /* Got the hostname:port - but maybe there's a "maddr=" to override address? */
2931         maddr = strstr(h, "maddr=");
2932         if (maddr) {
2933                 maddr += 6;
2934                 hn = strspn(maddr, "0123456789.");
2935                 if (hn>255) hn=255;
2936                 strncpy(hostname, maddr, hn);  hostname[hn] = '\0';
2937         }
2938         
2939         hp = ast_gethostbyname(hostname, &ahp);
2940         if (hp == NULL)  {
2941                 ast_log(LOG_WARNING, "Can't find address for host '%s'\n", hostname);
2942                 return;
2943         }
2944         p->sa.sin_family = AF_INET;
2945         memcpy(&p->sa.sin_addr, hp->h_addr, sizeof(p->sa.sin_addr));
2946         p->sa.sin_port = htons(port);
2947         if (debug)
2948                 ast_verbose("set_destination: set destination to %s, port %d\n", inet_ntoa(p->sa.sin_addr), port);
2949 }
2950
2951 /*--- init_resp: Initialize SIP response, based on SIP request ---*/
2952 static int init_resp(struct sip_request *req, char *resp, struct sip_request *orig)
2953 {
2954         /* Initialize a response */
2955         if (req->headers || req->len) {
2956                 ast_log(LOG_WARNING, "Request already initialized?!?\n");
2957                 return -1;
2958         }
2959         req->header[req->headers] = req->data + req->len;
2960         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "SIP/2.0 %s\r\n", resp);
2961         req->len += strlen(req->header[req->headers]);
2962         if (req->headers < SIP_MAX_HEADERS)
2963                 req->headers++;
2964         else
2965                 ast_log(LOG_WARNING, "Out of header space\n");
2966         return 0;
2967 }
2968
2969 /*--- init_req: Initialize SIP request ---*/
2970 static int init_req(struct sip_request *req, char *resp, char *recip)
2971 {
2972         /* Initialize a response */
2973         if (req->headers || req->len) {
2974                 ast_log(LOG_WARNING, "Request already initialized?!?\n");
2975                 return -1;
2976         }
2977         req->header[req->headers] = req->data + req->len;
2978         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "%s %s SIP/2.0\r\n", resp, recip);
2979         req->len += strlen(req->header[req->headers]);
2980         if (req->headers < SIP_MAX_HEADERS)
2981                 req->headers++;
2982         else
2983                 ast_log(LOG_WARNING, "Out of header space\n");
2984         return 0;
2985 }
2986
2987
2988 static int respprep(struct sip_request *resp, struct sip_pvt *p, char *msg, struct sip_request *req)
2989 {
2990         char newto[256] = "", *ot;
2991         memset(resp, 0, sizeof(*resp));
2992         init_resp(resp, msg, req);
2993         copy_via_headers(p, resp, req, "Via");
2994         if (msg[0] == '2') copy_all_header(resp, req, "Record-Route");
2995         copy_header(resp, req, "From");
2996         ot = get_header(req, "To");
2997         if (!strstr(ot, "tag=")) {
2998                 /* Add the proper tag if we don't have it already.  If they have specified
2999                    their tag, use it.  Otherwise, use our own tag */
3000                 if (!ast_strlen_zero(p->theirtag) && p->outgoing)
3001                         snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
3002                 else if (p->tag && !p->outgoing)
3003                         snprintf(newto, sizeof(newto), "%s;tag=as%08x", ot, p->tag);
3004                 else
3005                         strncpy(newto, ot, sizeof(newto) - 1);
3006                 ot = newto;
3007         }
3008         add_header(resp, "To", ot);
3009         copy_header(resp, req, "Call-ID");
3010         copy_header(resp, req, "CSeq");
3011         add_header(resp, "User-Agent", useragent);
3012         add_header(resp, "Allow", ALLOWED_METHODS);
3013         if (p->expiry) {
3014                 /* For registration responses, we also need expiry and
3015                    contact info */
3016                 char contact[256];
3017                 char tmp[256];
3018                 snprintf(contact, sizeof(contact), "%s;expires=%d", p->our_contact, p->expiry);
3019                 snprintf(tmp, sizeof(tmp), "%d", p->expiry);
3020                 add_header(resp, "Expires", tmp);
3021                 add_header(resp, "Contact", contact);
3022         } else {
3023                 add_header(resp, "Contact", p->our_contact);
3024         }
3025         return 0;
3026 }
3027
3028 static int reqprep(struct sip_request *req, struct sip_pvt *p, char *msg, int seqno, int newbranch)
3029 {
3030         struct sip_request *orig = &p->initreq;
3031         char stripped[80] ="";
3032         char tmp[80];
3033         char newto[256];
3034         char *c, *n;
3035         char *ot, *of;
3036
3037         memset(req, 0, sizeof(struct sip_request));
3038         
3039         snprintf(p->lastmsg, sizeof(p->lastmsg), "Tx: %s", msg);
3040         
3041         if (!seqno) {
3042                 p->ocseq++;
3043                 seqno = p->ocseq;
3044         }
3045         
3046         if (newbranch) {
3047                 p->branch ^= rand();
3048                 snprintf(p->via, sizeof(p->via), "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x;rport", inet_ntoa(p->ourip), ourport, p->branch);
3049         }
3050
3051         if (!ast_strlen_zero(p->uri)) {
3052                 c = p->uri;
3053         } else {
3054                 if (p->outgoing)
3055                         strncpy(stripped, get_header(orig, "To"), sizeof(stripped) - 1);
3056                 else
3057                         strncpy(stripped, get_header(orig, "From"), sizeof(stripped) - 1);
3058                 
3059                 c = strchr(stripped, '<');
3060                 if (c) 
3061                         c++;
3062                 else
3063                         c = stripped;
3064                 n = strchr(c, '>');
3065                 if (n)
3066                         *n = '\0';
3067                 n = strchr(c, ';');
3068                 if (n)
3069                         *n = '\0';
3070         }       
3071         init_req(req, msg, c);
3072
3073         snprintf(tmp, sizeof(tmp), "%d %s", seqno, msg);
3074
3075         add_header(req, "Via", p->via);
3076         if (p->route) {
3077                 set_destination(p, p->route->hop);
3078                 add_route(req, p->route->next);
3079         }
3080
3081         ot = get_header(orig, "To");
3082         of = get_header(orig, "From");
3083
3084         /* Add tag *unless* this is a CANCEL, in which case we need to send it exactly
3085            as our original request, including tag (or presumably lack thereof) */
3086         if (!strstr(ot, "tag=") && strcasecmp(msg, "CANCEL")) {
3087                 /* Add the proper tag if we don't have it already.  If they have specified
3088                    their tag, use it.  Otherwise, use our own tag */
3089                 if (p->outgoing && !ast_strlen_zero(p->theirtag))
3090                         snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
3091                 else if (!p->outgoing)
3092                         snprintf(newto, sizeof(newto), "%s;tag=as%08x", ot, p->tag);
3093                 else
3094                         snprintf(newto, sizeof(newto), "%s", ot);
3095                 ot = newto;
3096         }
3097
3098         if (p->outgoing) {
3099                 add_header(req, "From", of);
3100                 add_header(req, "To", ot);
3101         } else {
3102                 add_header(req, "From", ot);
3103                 add_header(req, "To", of);
3104         }
3105         add_header(req, "Contact", p->our_contact);
3106         copy_header(req, orig, "Call-ID");
3107         add_header(req, "CSeq", tmp);
3108
3109         add_header(req, "User-Agent", useragent);
3110         return 0;
3111 }
3112
3113 static int __transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req, int reliable)
3114 {
3115         struct sip_request resp;
3116         int seqno = 0;
3117         if (reliable && (sscanf(get_header(req, "CSeq"), "%i ", &seqno) != 1)) {
3118                 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
3119                 return -1;
3120         }
3121         respprep(&resp, p, msg, req);
3122         add_header(&resp, "Content-Length", "0");
3123         add_blank_header(&resp);
3124         return send_response(p, &resp, reliable, seqno);
3125 }
3126
3127 /*--- transmit_response: Transmit response, no retransmits */
3128 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req) 
3129 {
3130         return __transmit_response(p, msg, req, 0);
3131 }
3132
3133 /*--- transmit_response: Transmit response, Make sure you get a reply */
3134 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal)
3135 {
3136         return __transmit_response(p, msg, req, fatal ? 2 : 1);
3137 }
3138
3139 /*--- append_date: Append date to SIP message ---*/
3140 static void append_date(struct sip_request *req)
3141 {
3142         char tmpdat[256];
3143         struct tm tm;
3144         time_t t;
3145         time(&t);
3146         gmtime_r(&t, &tm);
3147         strftime(tmpdat, sizeof(tmpdat), "%a, %d %b %Y %T GMT", &tm);
3148         add_header(req, "Date", tmpdat);
3149 }
3150
3151 /*--- transmit_response_with_date: Append date and content length before transmitting response ---*/
3152 static int transmit_response_with_date(struct sip_pvt *p, char *msg, struct sip_request *req)
3153 {
3154         struct sip_request resp;
3155         respprep(&resp, p, msg, req);
3156         append_date(&resp);
3157         add_header(&resp, "Content-Length", "0");
3158         add_blank_header(&resp);
3159         return send_response(p, &resp, 0, 0);
3160 }
3161
3162 /*--- transmit_response_with_allow: Append Accept header, content length before transmitting response ---*/
3163 static int transmit_response_with_allow(struct sip_pvt *p, char *msg, struct sip_request *req, int reliable)
3164 {
3165         struct sip_request resp;
3166         respprep(&resp, p, msg, req);
3167         add_header(&resp, "Accept", "application/sdp");
3168         add_header(&resp, "Content-Length", "0");
3169         add_blank_header(&resp);
3170         return send_response(p, &resp, reliable, 0);
3171 }
3172
3173 /* transmit_response_with_auth: Respond with authorization request */
3174 static int transmit_response_with_auth(struct sip_pvt *p, char *msg, struct sip_request *req, char *randdata, int reliable, char *header)
3175 {
3176         struct sip_request resp;
3177         char tmp[256];
3178         int seqno = 0;
3179         if (reliable && (sscanf(get_header(req, "CSeq"), "%i ", &seqno) != 1)) {
3180                 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
3181                 return -1;
3182         }
3183         snprintf(tmp, sizeof(tmp), "Digest realm=\"%s\", nonce=\"%s\"", global_realm, randdata);
3184         respprep(&resp, p, msg, req);
3185         add_header(&resp, header, tmp);
3186         add_header(&resp, "Content-Length", "0");
3187         add_blank_header(&resp);
3188         return send_response(p, &resp, reliable, seqno);
3189 }
3190
3191 /*--- add_text: Add text body to SIP message ---*/
3192 static int add_text(struct sip_request *req, char *text)
3193 {
3194         /* XXX Convert \n's to \r\n's XXX */
3195         int len = strlen(text);
3196         char clen[256];
3197         snprintf(clen, sizeof(clen), "%d", len);
3198         add_header(req, "Content-Type", "text/plain");
3199         add_header(req, "Content-Length", clen);
3200         add_line(req, text);
3201         return 0;
3202 }
3203
3204 /*--- add_digit: add DTMF INFO tone to sip message ---*/
3205 /* Always adds default duration 250 ms, regardless of what came in over the line */
3206 static int add_digit(struct sip_request *req, char digit)
3207 {
3208         char tmp[256];
3209         int len;
3210         char clen[256];
3211         snprintf(tmp, sizeof(tmp), "Signal=%c\r\nDuration=250\r\n", digit);
3212         len = strlen(tmp);
3213         snprintf(clen, sizeof(clen), "%d", len);
3214         add_header(req, "Content-Type", "application/dtmf-relay");
3215         add_header(req, "Content-Length", clen);
3216         add_line(req, tmp);
3217         return 0;
3218 }
3219
3220 /*--- add_sdp: Add Session Description Protocol message ---*/
3221 static int add_sdp(struct sip_request *resp, struct sip_pvt *p)
3222 {
3223         int len;
3224         int codec;
3225         int alreadysent = 0;
3226         char costr[80];
3227         struct sockaddr_in sin;
3228         struct sockaddr_in vsin;
3229         struct sip_codec_pref *cur;
3230         char v[256] = "";
3231         char s[256] = "";
3232         char o[256] = "";
3233         char c[256] = "";
3234         char t[256] = "";
3235         char m[256] = "";
3236         char m2[256] = "";
3237         char a[1024] = "";
3238         char a2[1024] = "";
3239         int x;
3240         int capability;
3241         struct sockaddr_in dest;
3242         struct sockaddr_in vdest = { 0, };
3243         int debug=sip_debug_test_pvt(p);
3244
3245         /* XXX We break with the "recommendation" and send our IP, in order that our
3246                peer doesn't have to ast_gethostbyname() us XXX */
3247         len = 0;
3248         if (!p->rtp) {
3249                 ast_log(LOG_WARNING, "No way to add SDP without an RTP structure\n");
3250                 return -1;
3251         }
3252         capability = p->jointcapability;
3253                 
3254         if (!p->sessionid) {
3255                 p->sessionid = getpid();
3256                 p->sessionversion = p->sessionid;
3257         } else
3258                 p->sessionversion++;
3259         ast_rtp_get_us(p->rtp, &sin);
3260         if (p->vrtp)
3261                 ast_rtp_get_us(p->vrtp, &vsin);
3262
3263         if (p->redirip.sin_addr.s_addr) {
3264                 dest.sin_port = p->redirip.sin_port;
3265                 dest.sin_addr = p->redirip.sin_addr;
3266                 if (p->redircodecs)
3267                         capability = p->redircodecs;
3268         } else {
3269                 dest.sin_addr = p->ourip;
3270                 dest.sin_port = sin.sin_port;
3271         }
3272
3273         /* Determine video destination */
3274         if (p->vrtp) {
3275                 if (p->vredirip.sin_addr.s_addr) {
3276                         vdest.sin_port = p->vredirip.sin_port;
3277                         vdest.sin_addr = p->vredirip.sin_addr;
3278                 } else {
3279                         vdest.sin_addr = p->ourip;
3280                         vdest.sin_port = vsin.sin_port;
3281                 }
3282         }
3283         if (debug){
3284                 ast_verbose("We're at %s port %d\n", inet_ntoa(p->ourip), ntohs(sin.sin_port)); 
3285                 if (p->vrtp)
3286                         ast_verbose("Video is at %s port %d\n", inet_ntoa(p->ourip), ntohs(vsin.sin_port));     
3287         }
3288         snprintf(v, sizeof(v), "v=0\r\n");
3289         snprintf(o, sizeof(o), "o=root %d %d IN IP4 %s\r\n", p->sessionid, p->sessionversion, inet_ntoa(dest.sin_addr));
3290         snprintf(s, sizeof(s), "s=session\r\n");
3291         snprintf(c, sizeof(c), "c=IN IP4 %s\r\n", inet_ntoa(dest.sin_addr));
3292         snprintf(t, sizeof(t), "t=0 0\r\n");
3293         snprintf(m, sizeof(m), "m=audio %d RTP/AVP", ntohs(dest.sin_port));
3294         snprintf(m2, sizeof(m2), "m=video %d RTP/AVP", ntohs(vdest.sin_port));
3295         if (capability & p->prefcodec) {
3296                 if (debug)
3297                         ast_verbose("Answering/Requesting with root capability %d\n", p->prefcodec);
3298                 codec = ast_rtp_lookup_code(p->rtp, 1, p->prefcodec);
3299                 if (codec > -1) {
3300                         snprintf(costr, sizeof(costr), " %d", codec);
3301                         if (p->prefcodec <= AST_FORMAT_MAX_AUDIO) {
3302                                 strncat(m, costr, sizeof(m) - strlen(m));
3303                                 snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(1, p->prefcodec));
3304                                 strncat(a, costr, sizeof(a));
3305                         } else {
3306                                 strncat(m2, costr, sizeof(m2) - strlen(m2));
3307                                 snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/90000\r\n", codec, ast_rtp_lookup_mime_subtype(1, p->prefcodec));
3308                                 strncat(a2, costr, sizeof(a2));
3309                         }
3310                 }
3311                 alreadysent |= p->prefcodec;
3312         }
3313         /* Start by sending our preferred codecs */
3314         cur = prefs;
3315         while(cur) {
3316                 if ((capability & cur->codec) && !(alreadysent & cur->codec)) {
3317                         if (debug)
3318                                 ast_verbose("Answering with preferred capability 0x%x(%s)\n", cur->codec, ast_getformatname(cur->codec));
3319                         codec = ast_rtp_lookup_code(p->rtp, 1, cur->codec);
3320                         if (codec > -1) {
3321                                 snprintf(costr, sizeof(costr), " %d", codec);
3322                                 if (cur->codec <= AST_FORMAT_MAX_AUDIO) {
3323                                         strncat(m, costr, sizeof(m) - strlen(m));
3324                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(1, cur->codec));
3325                                         strncat(a, costr, sizeof(a));
3326                                 } else {
3327                                         strncat(m2, costr, sizeof(m2) - strlen(m2));
3328                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/90000\r\n", codec, ast_rtp_lookup_mime_subtype(1, cur->codec));
3329                                         strncat(a2, costr, sizeof(a2));
3330                                 }
3331                         }
3332                 }
3333                 alreadysent |= cur->codec;
3334                 cur = cur->next;
3335         }
3336         /* Now send any other common codecs, and non-codec formats: */
3337         for (x = 1; x <= (videosupport ? AST_FORMAT_MAX_VIDEO : AST_FORMAT_MAX_AUDIO); x <<= 1) {
3338                 if ((capability & x) && !(alreadysent & x)) {
3339                         if (debug)
3340                                 ast_verbose("Answering with capability 0x%x(%s)\n", x, ast_getformatname(x));
3341                         codec = ast_rtp_lookup_code(p->rtp, 1, x);
3342                         if (codec > -1) {
3343                                 snprintf(costr, sizeof(costr), " %d", codec);
3344                                 if (x <= AST_FORMAT_MAX_AUDIO) {
3345                                         strncat(m, costr, sizeof(m) - strlen(m));
3346                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(1, x));
3347                                         strncat(a, costr, sizeof(a) - strlen(a));
3348                                 } else {
3349                                         strncat(m2, costr, sizeof(m2) - strlen(m2));
3350                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/90000\r\n", codec, ast_rtp_lookup_mime_subtype(1, x));
3351                                         strncat(a2, costr, sizeof(a2) - strlen(a2));
3352                                 }
3353                         }
3354                 }
3355         }
3356         for (x = 1; x <= AST_RTP_MAX; x <<= 1) {
3357                 if (p->noncodeccapability & x) {
3358                         if (debug)
3359                                 ast_verbose("Answering with non-codec capability 0x%x(%s)\n", x, ast_getformatname(x));
3360                         codec = ast_rtp_lookup_code(p->rtp, 0, x);
3361                         if (codec > -1) {
3362                                 snprintf(costr, sizeof(costr), " %d", codec);
3363                                 strncat(m, costr, sizeof(m) - strlen(m));
3364                                 snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(0, x));
3365                                 strncat(a, costr, sizeof(a) - strlen(a));
3366                                 if (x == AST_RTP_DTMF) {
3367                                   /* Indicate we support DTMF...  Not sure about 16, but MSN supports it so dang it, we will too... */
3368                                   snprintf(costr, sizeof costr, "a=fmtp:%d 0-16\r\n",
3369                                            codec);
3370                                   strncat(a, costr, sizeof(a) - strlen(a));
3371                                 }
3372                         }
3373                 }
3374         }
3375         strncat(a, "a=silenceSupp:off - - - -\r\n", sizeof(a) - strlen(a));
3376         if (strlen(m) < sizeof(m) - 2)
3377                 strcat(m, "\r\n");
3378         if (strlen(m2) < sizeof(m2) - 2)
3379                 strcat(m2, "\r\n");
3380         if ((sizeof(m) <= strlen(m) - 2) || (sizeof(m2) <= strlen(m2) - 2) || (sizeof(a) == strlen(a)) || (sizeof(a2) == strlen(a2)))
3381                 ast_log(LOG_WARNING, "SIP SDP may be truncated due to undersized buffer!!\n");
3382         len = strlen(v) + strlen(s) + strlen(o) + strlen(c) + strlen(t) + strlen(m) + strlen(a);
3383         if ((p->vrtp) && (capability & VIDEO_CODEC_MASK)) /* only if video response is appropriate */
3384                 len += strlen(m2) + strlen(a2);
3385         snprintf(costr, sizeof(costr), "%d", len);
3386         add_header(resp, "Content-Type", "application/sdp");
3387         add_header(resp, "Content-Length", costr);
3388         add_line(resp, v);
3389         add_line(resp, o);
3390         add_line(resp, s);
3391         add_line(resp, c);
3392         add_line(resp, t);
3393         add_line(resp, m);
3394         add_line(resp, a);
3395         if ((p->vrtp) && (capability & VIDEO_CODEC_MASK)) { /* only if video response is appropriate */
3396                 add_line(resp, m2);
3397                 add_line(resp, a2);
3398         }
3399         /* Update lastrtprx when we send our SDP */
3400         time(&p->lastrtprx);
3401         return 0;
3402 }
3403
3404 /*--- copy_request: copy SIP request (mostly used to save request for responses) ---*/
3405 static void copy_request(struct sip_request *dst,struct sip_request *src)
3406 {
3407         long offset;
3408         int x;
3409         offset = ((void *)dst) - ((void *)src);
3410         /* First copy stuff */
3411         memcpy(dst, src, sizeof(*dst));
3412         /* Now fix pointer arithmetic */
3413         for (x=0;x<src->headers;x++)
3414                 dst->header[x] += offset;
3415         for (x=0;x<src->lines;x++)
3416                 dst->line[x] += offset;
3417 }
3418
3419 /*--- transmit_response_with_sdp: Used for 200 OK ---*/
3420 static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans)
3421 {
3422         struct sip_request resp;
3423         int seqno;
3424         if (sscanf(get_header(req, "CSeq"), "%i ", &seqno) != 1) {
3425                 ast_log(LOG_WARNING, "Unable to get seqno from '%s'\n", get_header(req, "CSeq"));
3426                 return -1;
3427         }
3428         respprep(&resp, p, msg, req);
3429         add_sdp(&resp, p);
3430         return send_response(p, &resp, retrans, seqno);
3431 }
3432
3433 /*--- determine_firstline_parts: parse first line of incoming SIP request */
3434 static int determine_firstline_parts( struct sip_request *req ) {
3435
3436   char *e, *cmd;
3437   int len;
3438   
3439   cmd= req->header[0];
3440   while(*cmd && (*cmd < 33)) {
3441     cmd++;
3442   }
3443   if (!*cmd) {
3444     return -1;
3445   }
3446   e= cmd;
3447   while(*e && (*e > 32)) {
3448     e++;
3449   }
3450   /* Get the command */
3451   if (*e) {
3452     *e = '\0';
3453     e++;
3454   }
3455   req->rlPart1= cmd;
3456   while( *e && ( *e < 33 ) ) {
3457     e++; 
3458   }
3459   if( !*e ) {
3460     return -1;
3461   }
3462     
3463   if ( !strcasecmp(cmd, "SIP/2.0") ) {
3464     /* We have a response */
3465     req->rlPart2= e;
3466     len= strlen( req->rlPart2 );
3467     if( len < 2 ) { return -1; }
3468     e+= len - 1;
3469     while( *e && *e<33 ) {
3470       e--; 
3471     }
3472     *(++e)= '\0';
3473   } else {
3474     /* We have a request */
3475     if( *e == '<' ) { 
3476       e++;
3477       if( !*e ) { return -1; }  
3478     }
3479     req->rlPart2= e;
3480     if( ( e= strrchr( req->rlPart2, 'S' ) ) == NULL ) {
3481       return -1;
3482     }
3483     while( isspace( *(--e) ) ) {}
3484     if( *e == '>' ) {
3485       *e= '\0';
3486     } else {
3487       *(++e)= '\0';
3488     }
3489   }
3490   return 1;
3491 }
3492
3493 /* transmit_reinvite_with_sdp: Transmit reinvite with SDP :-) ---*/
3494 /*   A re-invite is basically a new INVITE with the same CALL-ID and TAG as the
3495      INVITE that opened the SIP dialogue */
3496 static int transmit_reinvite_with_sdp(struct sip_pvt *p)
3497 {
3498         struct sip_request req;
3499         if (p->canreinvite == REINVITE_UPDATE)
3500                 reqprep(&req, p, "UPDATE", 0, 1);
3501         else 
3502                 reqprep(&req, p, "INVITE", 0, 1);
3503         
3504         add_header(&req, "Allow", ALLOWED_METHODS);
3505         add_sdp(&req, p);
3506         /* Use this as the basis */
3507         copy_request(&p->initreq, &req);
3508         parse(&p->initreq);