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