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