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