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