If we get 200 OK back on INVITE after we send CANCEL, send ACK *and* send BYE
[asterisk/asterisk.git] / channels / chan_sip.c
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * Implementation of Session Initiation Protocol
5  * 
6  * Copyright (C) 1999, Mark Spencer
7  *
8  * Mark Spencer <markster@linux-support.net>
9  *
10  * This program is free software, distributed under the terms of
11  * the GNU General Public License
12  */
13
14
15 #include <stdio.h>
16 #include <ctype.h>
17 #include <string.h>
18 #include <asterisk/lock.h>
19 #include <asterisk/channel.h>
20 #include <asterisk/channel_pvt.h>
21 #include <asterisk/config.h>
22 #include <asterisk/logger.h>
23 #include <asterisk/module.h>
24 #include <asterisk/pbx.h>
25 #include <asterisk/options.h>
26 #include <asterisk/lock.h>
27 #include <asterisk/sched.h>
28 #include <asterisk/io.h>
29 #include <asterisk/rtp.h>
30 #include <asterisk/acl.h>
31 #include <asterisk/callerid.h>
32 #include <asterisk/cli.h>
33 #include <asterisk/md5.h>
34 #include <asterisk/app.h>
35 #include <asterisk/musiconhold.h>
36 #include <asterisk/dsp.h>
37 #include <asterisk/parking.h>
38 #include <asterisk/acl.h>
39 #include <asterisk/srv.h>
40 #include <asterisk/astdb.h>
41 #include <asterisk/causes.h>
42 #include <asterisk/utils.h>
43 #ifdef OSP_SUPPORT
44 #include <asterisk/astosp.h>
45 #endif
46 #include <sys/socket.h>
47 #include <sys/ioctl.h>
48 #include <net/if.h>
49 #include <errno.h>
50 #include <unistd.h>
51 #include <stdlib.h>
52 #include <fcntl.h>
53 #include <netdb.h>
54 #include <arpa/inet.h>
55 #include <signal.h>
56 #include <sys/signal.h>
57 #include <netinet/in_systm.h>
58 #include <netinet/ip.h>
59
60 #ifdef SIP_MYSQL_FRIENDS
61 #define MYSQL_FRIENDS
62 #include <mysql/mysql.h>
63 #endif
64
65 #ifndef DEFAULT_USERAGENT
66 #define DEFAULT_USERAGENT "Asterisk PBX"
67 #endif
68  
69 #define VIDEO_CODEC_MASK        0x1fc0000 /* Video codecs from H.261 thru AST_FORMAT_MAX_VIDEO */
70 #ifndef IPTOS_MINCOST
71 #define IPTOS_MINCOST 0x02
72 #endif
73
74 /* #define VOCAL_DATA_HACK */
75
76 #define SIPDUMPER
77 #define DEFAULT_DEFAULT_EXPIRY  120
78 #define DEFAULT_MAX_EXPIRY      3600
79
80 /* guard limit must be larger than guard secs */
81 /* guard min must be < 1000, and should be >= 250 */
82 #define EXPIRY_GUARD_SECS       15      /* How long before expiry do we reregister */
83 #define EXPIRY_GUARD_LIMIT      30      /* Below here, we use EXPIRY_GUARD_PCT instead of EXPIRY_GUARD_SECS */
84 #define EXPIRY_GUARD_MIN        500     /* This is the minimum guard time applied. If GUARD_PCT turns out
85                                         to be lower than this, it will use this time instead. This is in
86                                         milliseconds. */
87 #define EXPIRY_GUARD_PCT        0.20    /* Percentage of expires timeout to use when below EXPIRY_GUARD_LIMIT */
88
89 #ifndef MAX
90 #define MAX(a,b) ((a) > (b) ? (a) : (b))
91 #endif
92
93 #define CALLERID_UNKNOWN        "Unknown"
94
95 /* --- Choices for DTMF support in SIP channel */
96 #define SIP_DTMF_RFC2833        (1 << 0)
97 #define SIP_DTMF_INBAND         (1 << 1)
98 #define SIP_DTMF_INFO           (1 << 2)
99
100 static int max_expiry = DEFAULT_MAX_EXPIRY;
101 static int default_expiry = DEFAULT_DEFAULT_EXPIRY;
102
103 #define DEFAULT_MAXMS           2000            /* Must be faster than 2 seconds by default */
104 #define DEFAULT_FREQ_OK         60 * 1000               /* How often to check for the host to be up */
105 #define DEFAULT_FREQ_NOTOK      10 * 1000               /* How often to check, if the host is down... */
106
107 #define DEFAULT_RETRANS         1000                    /* How frequently to retransmit */
108 #define MAX_RETRANS             5                       /* Try only 5 times for retransmissions */
109
110 /* MYSQL_FRIENDS: Check if peer exists in database and read some configuration
111    from databse (not all options supported though) */
112 #ifdef MYSQL_FRIENDS
113 AST_MUTEX_DEFINE_STATIC(mysqllock);
114 static MYSQL *mysql;
115 static char mydbuser[80];
116 static char mydbpass[80];
117 static char mydbhost[80];
118 static char mydbname[80];
119 #endif
120
121                                                         /* SIP Debug            */
122 #define DEBUG_READ      0                               /* Recieved data        */
123 #define DEBUG_SEND      1                               /* Transmit data        */
124
125 static char *desc = "Session Initiation Protocol (SIP)";
126 static char *type = "SIP";
127 static char *tdesc = "Session Initiation Protocol (SIP)";
128 static char *config = "sip.conf";
129
130 #define DEFAULT_SIP_PORT        5060    /* From RFC 2543 */
131 #define SIP_MAX_PACKET  1500            /* Also from RFC 2543, should sub headers tho */
132
133 #define ALLOWED_METHODS "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER"
134
135 static char default_useragent[AST_MAX_EXTENSION] = DEFAULT_USERAGENT;
136
137 static char default_context[AST_MAX_EXTENSION] = "default";
138
139 static char default_language[MAX_LANGUAGE] = "";
140
141 static char default_callerid[AST_MAX_EXTENSION] = "asterisk";
142
143 static char default_fromdomain[AST_MAX_EXTENSION] = "";
144
145 static char notifymime[AST_MAX_EXTENSION] = "application/simple-message-summary";
146
147 static int srvlookup = 0;
148
149 static int pedanticsipchecking = 0;
150
151 static int autocreatepeer = 0;          
152
153 static int relaxdtmf = 0;
154
155 static int global_rtptimeout = 0;
156
157 static int global_rtpholdtimeout = 0;
158
159 static int global_trustrpid = 0;
160
161 static int global_progressinband = 0;
162
163 #ifdef OSP_SUPPORT
164 static int global_ospauth = 0;
165 #endif
166
167 static int usecnt =0;
168 AST_MUTEX_DEFINE_STATIC(usecnt_lock);
169
170 /* Protect the interface list (of sip_pvt's) */
171 AST_MUTEX_DEFINE_STATIC(iflock);
172
173 /* Protect the monitoring thread, so only one process can kill or start it, and not
174    when it's doing something critical. */
175 AST_MUTEX_DEFINE_STATIC(netlock);
176
177 AST_MUTEX_DEFINE_STATIC(monlock);
178
179 /* This is the thread for the monitor which checks for input on the channels
180    which are not currently in use.  */
181 static pthread_t monitor_thread = AST_PTHREADT_NULL;
182
183 static int restart_monitor(void);
184
185 /* Codecs that we support by default: */
186 static int global_capability = AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_GSM | AST_FORMAT_H263;
187 static int noncodeccapability = AST_RTP_DTMF;
188
189 static char ourhost[256];
190 static struct in_addr __ourip;
191 static int ourport;
192
193 static int sipdebug = 0;
194 static struct sockaddr_in debugaddr;
195
196 static int tos = 0;
197
198 static int videosupport = 0;
199
200 static int global_dtmfmode = SIP_DTMF_RFC2833;          /* DTMF mode default */
201 static int recordhistory = 0;
202 static int global_promiscredir;
203
204 static char global_musicclass[MAX_LANGUAGE] = "";       /* Global music on hold class */
205 static char global_realm[AST_MAX_EXTENSION] = "asterisk";       /* Default realm */
206
207 /* Expire slowly */
208 static int expiry = 900;
209
210 static struct sched_context *sched;
211 static struct io_context *io;
212 /* The private structures of the  sip channels are linked for
213    selecting outgoing channels */
214    
215 #define SIP_MAX_HEADERS         64
216 #define SIP_MAX_LINES           64
217
218 #define DEC_IN_USE      0
219 #define INC_IN_USE      1
220 #define DEC_OUT_USE     2
221 #define INC_OUT_USE     3
222
223 static struct sip_codec_pref {
224         int codec;
225         struct sip_codec_pref *next;
226 } *prefs;
227
228 /* sip_request: The data grabbed from the UDP socket */
229 struct sip_request {
230   char *rlPart1; /* SIP Method Name or "SIP/2.0" protocol version */
231   char *rlPart2; /* The Request URI or Response Status */
232         int len;
233         int headers;                                    /* SIP Headers */
234         char *header[SIP_MAX_HEADERS];
235         int lines;                                              /* SDP Content */
236         char *line[SIP_MAX_LINES];
237         char data[SIP_MAX_PACKET];
238 };
239
240 struct sip_pkt;
241
242 struct sip_route {
243         struct sip_route *next;
244         char hop[0];
245 };
246
247 struct sip_history {
248         char event[80];
249         struct sip_history *next;
250 };
251
252 /* sip_pvt: PVT structures are used for each SIP conversation, ie. a call  */
253 static struct sip_pvt {
254         ast_mutex_t lock;                       /* Channel private lock */
255         char callid[80];                        /* Global CallID */
256         char randdata[80];                      /* Random data */
257         unsigned int ocseq;                     /* Current outgoing seqno */
258         unsigned int icseq;                     /* Current incoming seqno */
259         unsigned int callgroup;                 /* Call group */
260         unsigned int pickupgroup;               /* Pickup group */
261         int lastinvite;                         /* Last Cseq of invite */
262         int alreadygone;                        /* Whether or not we've already been destroyed by or peer */
263         int needdestroy;                        /* if we need to be destroyed */
264         int capability;                         /* Special capability (codec) */
265         int jointcapability;                    /* Supported capability at both ends (codecs ) */
266         int prefcodec;                          /* Preferred codec (outbound only) */
267         int noncodeccapability;
268         int outgoing;                           /* Outgoing or incoming call? */
269         int authtries;                          /* Times we've tried to authenticate */
270         int insecure;                           /* Don't check source port/ip */
271         int expiry;                             /* How long we take to expire */
272         int branch;                             /* One random number */
273         int canreinvite;                        /* Do we support reinvite */
274         int ringing;                            /* Have sent 180 ringing */
275         int progress;                           /* Have sent 183 message progress */
276         int tag;                                /* Another random number */
277         int nat;                                /* Whether to try to support NAT */
278         int sessionid;                          /* SDP Session ID */
279         int sessionversion;                     /* SDP Session Version */
280         struct sockaddr_in sa;                  /* Our peer */
281         struct sockaddr_in redirip;             /* Where our RTP should be going if not to us */
282         struct sockaddr_in vredirip;            /* Where our Video RTP should be going if not to us */
283         int redircodecs;                                /* Redirect codecs */
284         struct sockaddr_in recv;                /* Received as */
285         struct in_addr ourip;                   /* Our IP */
286         struct ast_channel *owner;              /* Who owns us */
287         char exten[AST_MAX_EXTENSION];          /* Extension where to start */
288         char refer_to[AST_MAX_EXTENSION];       /* Place to store REFER-TO extension */
289         char referred_by[AST_MAX_EXTENSION];    /* Place to store REFERRED-BY extension */
290         char refer_contact[AST_MAX_EXTENSION];  /* Place to store Contact info from a REFER extension */
291         struct sip_pvt *refer_call;             /* Call we are referring */
292         struct sip_route *route;                /* Head of linked list of routing steps (fm Record-Route) */
293         int route_persistant;                   /* Is this the "real" route? */
294         char from[256];                         /* The From: header */
295         char useragent[256];                    /* User agent in SIP request */
296         char context[AST_MAX_EXTENSION];        /* Context for this call */
297         char fromdomain[AST_MAX_EXTENSION];     /* Domain to show in the from field */
298         char fromuser[AST_MAX_EXTENSION];       /* Domain to show in the user field */
299         char tohost[AST_MAX_EXTENSION];         /* Host we should put in the "to" field */
300         char language[MAX_LANGUAGE];            /* Default language for this call */
301         char musicclass[MAX_LANGUAGE];          /* Music on Hold class */
302         char rdnis[256];                        /* Referring DNIS */
303         char theirtag[256];                     /* Their tag */
304         char username[256];
305         char peername[256];
306         char authname[256];                     /* Who we use for authentication */
307         char uri[256];                          /* Original requested URI */
308         char peersecret[256];
309         char peermd5secret[256];
310         char callerid[256];                     /* Caller*ID */
311         int restrictcid;                        /* hide presentation from remote user */
312         char via[256];
313         char accountcode[20];                   /* Account code */
314         char our_contact[256];                  /* Our contact header */
315         char realm[256];                        /* Authorization realm */
316         char nonce[256];                        /* Authorization nonce */
317         char opaque[256];                       /* Opaque nonsense */
318         char qop[80];                           /* Quality of Protection, since SIP wasn't complicated enough yet. */
319         char domain[256];                       /* Authorization nonce */
320         char lastmsg[256];                      /* Last Message sent/received */
321         int amaflags;                           /* AMA Flags */
322         int pendinginvite;                      /* Any pending invite */
323         int needreinvite;                       /* Do we need to send another reinvite? */
324         int pendingbye;                         /* Need to send bye after we ack? */
325         int gotrefer;                           /* Got a refer? */
326 #ifdef OSP_SUPPORT
327         int ospauth;                            /* Allow OSP Authentication */
328         int osphandle;                          /* OSP Handle for call */
329         time_t ospstart;                        /* OSP Start time */
330 #endif
331         struct sip_request initreq;             /* Initial request */
332         
333         int maxtime;                            /* Max time for first response */
334         int initid;                             /* Auto-congest ID if appropriate */
335         int autokillid;                         /* Auto-kill ID */
336         time_t lastrtprx;                       /* Last RTP received */
337         int rtptimeout;                         /* RTP timeout time */
338         int rtpholdtimeout;                     /* RTP timeout when on hold */
339
340         int subscribed;
341         int stateid;
342         int dialogver;
343         int promiscredir;                       /* Promiscuous redirection */
344         
345         int trustrpid;
346         int progressinband;
347         
348         int dtmfmode;
349         struct ast_dsp *vad;
350         
351         struct sip_peer *peerpoke;              /* If this calls is to poke a peer, which one */
352         struct sip_registry *registry;          /* If this is a REGISTER call, to which registry */
353         struct ast_rtp *rtp;                    /* RTP Session */
354         struct ast_rtp *vrtp;                   /* Video RTP session */
355         struct sip_pkt *packets;                /* Packets scheduled for re-transmission */
356         struct sip_history *history;    /* History of this SIP dialog */
357         struct sip_pvt *next;                   /* Next call in chain */
358 } *iflist = NULL;
359
360 #define FLAG_RESPONSE (1 << 0)
361 #define FLAG_FATAL (1 << 1)
362
363 /* sip packet - read in sipsock_read, transmitted in send_request */
364 struct sip_pkt {
365         struct sip_pkt *next;                           /* Next packet */
366         int retrans;                                            /* Retransmission number */
367         int seqno;                                                      /* Sequence number */
368         int flags;                                                      /* non-zero if this is a response packet (e.g. 200 OK) */
369         struct sip_pvt *owner;                          /* Owner call */
370         int retransid;                                          /* Retransmission ID */
371         int packetlen;                                          /* Length of packet */
372         char data[0];
373 };      
374
375 /* Structure for SIP user data. User's place calls to us */
376 struct sip_user {
377         /* Users who can access various contexts */
378         char name[80];
379         char secret[80];
380         char md5secret[80];
381         char context[80];
382         char callerid[80];
383         char accountcode[20];
384         char language[MAX_LANGUAGE];
385         char musicclass[MAX_LANGUAGE];  /* Music on Hold class */
386         char useragent[256];            /* User agent in SIP request */
387         unsigned int callgroup;
388         unsigned int pickupgroup;
389         int nat;
390         int hascallerid;
391         int amaflags;
392         int insecure;
393         int canreinvite;
394         int capability;
395 #ifdef OSP_SUPPORT
396         int ospauth;                            /* Allow OSP Authentication */
397 #endif
398         int dtmfmode;
399         int inUse;
400         int incominglimit;
401         int outUse;
402         int outgoinglimit;
403         int promiscredir;
404         int restrictcid;
405         int trustrpid;
406         int progressinband;
407         struct ast_ha *ha;
408 #ifdef MYSQL_USERS
409         int temponly;
410 #endif /* MYSQL_FRIENDS */
411         struct sip_user *next;
412 };
413
414 /* Structure for SIP peer data, we place calls to peers if registred  or fixed IP address (host) */
415 struct sip_peer {
416         char name[80];
417         char secret[80];
418         char md5secret[80];
419         char context[80];               /* JK02: peers need context too to allow parking etc */
420         char username[80];
421         char tohost[80];
422         char fromuser[80];
423         char fromdomain[80];
424         char mailbox[AST_MAX_EXTENSION];
425         char language[MAX_LANGUAGE];
426         char musicclass[MAX_LANGUAGE];  /* Music on Hold class */
427         char useragent[256];            /* User agent in SIP request */
428         int lastmsgssent;
429         time_t  lastmsgcheck;
430         int dynamic;
431         int expire;
432         int expiry;
433         int capability;
434         int rtptimeout;
435         int rtpholdtimeout;
436         int insecure;
437 #ifdef OSP_SUPPORT
438         int ospauth;                            /* Allow OSP Authentication */
439 #endif  
440         int nat;
441         int canreinvite;
442         unsigned int callgroup;
443         unsigned int pickupgroup;
444         int promiscredir;
445         int dtmfmode;
446         int trustrpid;
447         int progressinband;
448         struct sockaddr_in addr;
449         struct in_addr mask;
450
451         /* Qualification */
452         struct sip_pvt *call;           /* Call pointer */
453         int pokeexpire;                         /* When to expire poke */
454         int lastms;                                     /* How long last response took (in ms), or -1 for no response */
455         int maxms;                                      /* Max ms we will accept for the host to be up, 0 to not monitor */
456         struct timeval ps;                      /* Ping send time */
457         
458         struct sockaddr_in defaddr;
459         struct ast_ha *ha;
460         int delme;
461         int selfdestruct;
462         int lastmsg;
463         int temponly;
464         struct sip_peer *next;
465 };
466
467 AST_MUTEX_DEFINE_STATIC(sip_reload_lock);
468 static int sip_reloading = 0;
469
470 #define REG_STATE_UNREGISTERED 0
471 #define REG_STATE_REGSENT          1
472 #define REG_STATE_AUTHSENT         2
473 #define REG_STATE_REGISTERED   3
474 #define REG_STATE_REJECTED         4
475 #define REG_STATE_TIMEOUT          5
476 #define REG_STATE_NOAUTH           6
477
478 #define SIP_NAT_NEVER           0
479 #define SIP_NAT_RFC3581         1
480 #define SIP_NAT_ALWAYS          2
481
482 /* sip_registry: Registrations with other SIP proxies */
483 struct sip_registry {
484         int portno;                             /* Optional port override */
485         char username[80];              /* Who we are registering as */
486         char authuser[80];              /* Who we *authenticate* as */
487         char hostname[80];
488         char secret[80];                /* Password or key name in []'s */      
489         char md5secret[80];
490         char contact[80];               /* Contact extension */
491         char random[80];
492         int expire;                     /* Sched ID of expiration */
493         int timeout;                    /* sched id of sip_reg_timeout */
494         int refresh;                    /* How often to refresh */
495         struct sip_pvt *call;           /* create a sip_pvt structure for each outbound "registration call" in progress */
496         int regstate;
497         int callid_valid;               /* 0 means we haven't chosen callid for this registry yet. */
498         char callid[80];                /* Global CallID for this registry */
499         unsigned int ocseq;             /* Sequence number we got to for REGISTERs for this registry */
500         struct sockaddr_in us;          /* Who the server thinks we are */
501         struct sip_registry *next;
502 };
503
504 /*--- The user list: Users and friends ---*/
505 static struct ast_user_list {
506         struct sip_user *users;
507         ast_mutex_t lock;
508 } userl;
509
510 /*--- The peer list: Peers and Friends ---*/
511 static struct ast_peer_list {
512         struct sip_peer *peers;
513         ast_mutex_t lock;
514 } peerl;
515
516 /*--- The register list: Other SIP proxys we register with and call ---*/
517 static struct ast_register_list {
518         struct sip_registry *registrations;
519         ast_mutex_t lock;
520         int recheck;
521 } regl;
522
523
524 #define REINVITE_INVITE         1
525 #define REINVITE_UPDATE         2
526
527 static int __sip_do_register(struct sip_registry *r);
528
529 static int sipsock  = -1;
530 static int global_nat = SIP_NAT_RFC3581;
531 static int global_canreinvite = REINVITE_INVITE;
532
533
534 static struct sockaddr_in bindaddr;
535 static struct sockaddr_in externip;
536 static struct ast_ha *localaddr;
537
538 static struct ast_frame  *sip_read(struct ast_channel *ast);
539 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req);
540 static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans);
541 static int transmit_response_with_auth(struct sip_pvt *p, char *msg, struct sip_request *req, char *rand, int reliable, char *header);
542 static int transmit_request(struct sip_pvt *p, char *msg, int inc, int reliable, int newbranch);
543 static int transmit_request_with_auth(struct sip_pvt *p, char *msg, int inc, int reliable, int newbranch);
544 static int transmit_invite(struct sip_pvt *p, char *msg, int sendsdp, char *auth, char *authheader, char *vxml_url,char *distinctive_ring, char *osptoken,int init);
545 static int transmit_reinvite_with_sdp(struct sip_pvt *p);
546 static int transmit_info_with_digit(struct sip_pvt *p, char digit);
547 static int transmit_message_with_text(struct sip_pvt *p, char *text);
548 static int transmit_refer(struct sip_pvt *p, char *dest);
549 static struct sip_peer *temp_peer(char *name);
550 static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader, char *msg, int init);
551 static void free_old_route(struct sip_route *route);
552 static int build_reply_digest(struct sip_pvt *p, char *orig_header, char *digest, int digest_len);
553 static int update_user_counter(struct sip_pvt *fup, int event);
554 static void prune_peers(void);
555 static int sip_do_reload(void);
556
557
558 /*--- sip_debug_test_addr: See if we pass debug IP filter */
559 static inline int sip_debug_test_addr(struct sockaddr_in *addr) 
560 {
561         if (sipdebug == 0)
562                 return 0;
563         if (debugaddr.sin_addr.s_addr) {
564                 if (((ntohs(debugaddr.sin_port) != 0)
565                         && (debugaddr.sin_port != addr->sin_port))
566                         || (debugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
567                         return 0;
568         }
569         return 1;
570 }
571
572 static inline int sip_debug_test_pvt(struct sip_pvt *p) 
573 {
574         if (sipdebug == 0)
575                 return 0;
576         return sip_debug_test_addr(((p->nat == SIP_NAT_ALWAYS) ? &p->recv : &p->sa));
577 }
578
579
580 /*--- __sip_xmit: Transmit SIP message ---*/
581 static int __sip_xmit(struct sip_pvt *p, char *data, int len)
582 {
583         int res;
584         char iabuf[INET_ADDRSTRLEN];
585         if (p->nat == SIP_NAT_ALWAYS)
586             res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->recv, sizeof(struct sockaddr_in));
587         else
588             res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->sa, sizeof(struct sockaddr_in));
589         if (res != len) {
590                 ast_log(LOG_WARNING, "sip_xmit of %p (len %d) to %s returned %d: %s\n", data, len, ast_inet_ntoa(iabuf, sizeof(iabuf), p->sa.sin_addr), res, strerror(errno));
591         }
592         return res;
593 }
594
595 static void sip_destroy(struct sip_pvt *p);
596
597 /*--- ast_sip_ouraddrfor: NAT fix - decide which IP address to use for ASterisk server? ---*/
598 /* Only used for outbound registrations */
599 static int ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us)
600 {
601         /*
602          * Using the localaddr structure built up with localnet statements
603          * apply it to their address to see if we need to substitute our
604          * externip or can get away with our internal bindaddr
605          */
606         struct sockaddr_in theirs;
607         theirs.sin_addr = *them;
608         if (localaddr && externip.sin_addr.s_addr &&
609            ast_apply_ha(localaddr, &theirs)) {
610                 char iabuf[INET_ADDRSTRLEN];
611                 memcpy(us, &externip.sin_addr, sizeof(struct in_addr));
612                 ast_inet_ntoa(iabuf, sizeof(iabuf), *(struct in_addr *)&them->s_addr);
613                 ast_log(LOG_DEBUG, "Target address %s is not local, substituting externip\n", iabuf);
614         }
615         else if (bindaddr.sin_addr.s_addr)
616                 memcpy(us, &bindaddr.sin_addr, sizeof(struct in_addr));
617         else
618                 return ast_ouraddrfor(them, us);
619         return 0;
620 }
621
622 static int append_history(struct sip_pvt *p, char *event, char *data)
623 {
624         struct sip_history *hist, *prev;
625         char *c;
626         if (!recordhistory)
627                 return 0;
628         hist = malloc(sizeof(struct sip_history));
629         if (hist) {
630                 memset(hist, 0, sizeof(struct sip_history));
631                 snprintf(hist->event, sizeof(hist->event), "%-15s %s", event, data);
632                 /* Trim up nicely */
633                 c = hist->event;
634                 while(*c) {
635                         if ((*c == '\r') || (*c == '\n')) {
636                                 *c = '\0';
637                                 break;
638                         }
639                         c++;
640                 }
641                 /* Enqueue into history */
642                 prev = p->history;
643                 if (prev) {
644                         while(prev->next)
645                                 prev = prev->next;
646                         prev->next = hist;
647                 } else {
648                         p->history = hist;
649                 }
650         }
651         return 0;
652 }
653
654 /*--- retrans_pkt: Retransmit SIP message if no answer ---*/
655 static int retrans_pkt(void *data)
656 {
657         struct sip_pkt *pkt=data, *prev, *cur;
658         int res = 0;
659         char iabuf[INET_ADDRSTRLEN];
660         ast_mutex_lock(&pkt->owner->lock);
661         if (pkt->retrans < MAX_RETRANS) {
662                 pkt->retrans++;
663                 if (sip_debug_test_pvt(pkt->owner)) {
664                         if (pkt->owner->nat == SIP_NAT_ALWAYS)
665                                 ast_verbose("Retransmitting #%d (NAT):\n%s\n to %s:%d\n", pkt->retrans, pkt->data, ast_inet_ntoa(iabuf, sizeof(iabuf), pkt->owner->recv.sin_addr), ntohs(pkt->owner->recv.sin_port));
666                         else
667                                 ast_verbose("Retransmitting #%d (no NAT):\n%s\n to %s:%d\n", pkt->retrans, pkt->data, ast_inet_ntoa(iabuf, sizeof(iabuf), pkt->owner->sa.sin_addr), ntohs(pkt->owner->sa.sin_port));
668                 }
669                 append_history(pkt->owner, "ReTx", pkt->data);
670                 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
671                 res = 1;
672         } else {
673                 ast_log(LOG_WARNING, "Maximum retries exceeded on call %s for seqno %d (%s %s)\n", pkt->owner->callid, pkt->seqno, (pkt->flags & FLAG_FATAL) ? "Critical" : "Non-critical", (pkt->flags & FLAG_RESPONSE) ? "Response" : "Request");
674                 append_history(pkt->owner, "MaxRetries", pkt->flags & FLAG_FATAL ? "(Critical)" : "(Non-critical)");
675                 pkt->retransid = -1;
676                 if (pkt->flags & FLAG_FATAL) {
677                         while(pkt->owner->owner && ast_mutex_trylock(&pkt->owner->owner->lock)) {
678                                 ast_mutex_unlock(&pkt->owner->lock);
679                                 usleep(1);
680                                 ast_mutex_lock(&pkt->owner->lock);
681                         }
682                         if (pkt->owner->owner) {
683                                 ast_queue_hangup(pkt->owner->owner);
684                                 ast_mutex_unlock(&pkt->owner->owner->lock);
685                         } else {
686                                 /* If no owner, destroy now */
687                                 pkt->owner->needdestroy = 1;
688                         }
689                 }
690                 /* In any case, go ahead and remove the packet */
691                 prev = NULL;
692                 cur = pkt->owner->packets;
693                 while(cur) {
694                         if (cur == pkt)
695                                 break;
696                         prev = cur;
697                         cur = cur->next;
698                 }
699                 if (cur) {
700                         if (prev)
701                                 prev->next = cur->next;
702                         else
703                                 pkt->owner->packets = cur->next;
704                         ast_mutex_unlock(&pkt->owner->lock);
705                         free(cur);
706                         pkt = NULL;
707                 } else
708                         ast_log(LOG_WARNING, "Weird, couldn't find packet owner!\n");
709         }
710         if (pkt)
711                 ast_mutex_unlock(&pkt->owner->lock);
712         return res;
713 }
714
715 /*--- __sip_reliable_xmit: transmit packet with retransmits ---*/
716 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal)
717 {
718         struct sip_pkt *pkt;
719         pkt = malloc(sizeof(struct sip_pkt) + len);
720         if (!pkt)
721                 return -1;
722         memset(pkt, 0, sizeof(struct sip_pkt));
723         memcpy(pkt->data, data, len);
724         pkt->packetlen = len;
725         pkt->next = p->packets;
726         pkt->owner = p;
727         pkt->seqno = seqno;
728         pkt->flags = resp;
729         if (fatal)
730                 pkt->flags |= FLAG_FATAL;
731         /* Schedule retransmission */
732         pkt->retransid = ast_sched_add(sched, DEFAULT_RETRANS, retrans_pkt, pkt);
733         pkt->next = p->packets;
734         p->packets = pkt;
735         __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
736         if (!strncasecmp(pkt->data, "INVITE", 6)) {
737                 /* Note this is a pending invite */
738                 p->pendinginvite = seqno;
739         }
740         return 0;
741 }
742
743 /*--- __sip_autodestruct: Kill a call (called by scheduler) ---*/
744 static int __sip_autodestruct(void *data)
745 {
746         struct sip_pvt *p = data;
747         p->autokillid = -1;
748         ast_log(LOG_DEBUG, "Auto destroying call '%s'\n", p->callid);
749         append_history(p, "AutoDestroy", "");
750         if (p->owner) {
751                 ast_log(LOG_WARNING, "Autodestruct on call '%s' with owner in place\n", p->callid);
752                 ast_queue_hangup(p->owner);
753         } else {
754                 sip_destroy(p);
755         }
756         return 0;
757 }
758
759 /*--- sip_scheddestroy: Schedule destruction of SIP call ---*/
760 static int sip_scheddestroy(struct sip_pvt *p, int ms)
761 {
762         char tmp[80];
763         if (sip_debug_test_pvt(p))
764                 ast_verbose("Scheduling destruction of call '%s' in %d ms\n", p->callid, ms);
765         if (recordhistory) {
766                 snprintf(tmp, sizeof(tmp), "%d ms", ms);
767                 append_history(p, "SchedDestroy", tmp);
768         }
769         if (p->autokillid > -1)
770                 ast_sched_del(sched, p->autokillid);
771         p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, p);
772         return 0;
773 }
774
775 /*--- sip_cancel_destroy: Cancel destruction of SIP call ---*/
776 static int sip_cancel_destroy(struct sip_pvt *p)
777 {
778         if (p->autokillid > -1)
779                 ast_sched_del(sched, p->autokillid);
780         append_history(p, "CancelDestroy", "");
781         p->autokillid = -1;
782         return 0;
783 }
784
785 /*--- __sip_ack: Acknowledges receipt of a packet and stops retransmission ---*/
786 static int __sip_ack(struct sip_pvt *p, int seqno, int resp)
787 {
788         struct sip_pkt *cur, *prev = NULL;
789         int res = -1;
790         int resetinvite = 0;
791         cur = p->packets;
792         while(cur) {
793                 if ((cur->seqno == seqno) && ((cur->flags & FLAG_RESPONSE) == resp)) {
794                         if (!resp && (seqno == p->pendinginvite)) {
795                                 ast_log(LOG_DEBUG, "Acked pending invite %d\n", p->pendinginvite);
796                                 p->pendinginvite = 0;
797                                 resetinvite = 1;
798                         }
799                         /* this is our baby */
800                         if (prev)
801                                 prev->next = cur->next;
802                         else
803                                 p->packets = cur->next;
804                         if (cur->retransid > -1)
805                                 ast_sched_del(sched, cur->retransid);
806                         free(cur);
807                         res = 0;
808                         break;
809                 }
810                 prev = cur;
811                 cur = cur->next;
812         }
813         ast_log(LOG_DEBUG, "Stopping retransmission on '%s' of %s %d: %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
814         return res;
815 }
816
817 /*--- __sip_semi_ack: Acks receipt of packet, keep it around (used for provisional responses) ---*/
818 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp)
819 {
820         struct sip_pkt *cur;
821         int res = -1;
822         cur = p->packets;
823         while(cur) {
824                 if ((cur->seqno == seqno) && ((cur->flags & FLAG_RESPONSE) == resp)) {
825                         /* this is our baby */
826                         if (cur->retransid > -1)
827                                 ast_sched_del(sched, cur->retransid);
828                         cur->retransid = -1;
829                         res = 0;
830                         break;
831                 }
832                 cur = cur->next;
833         }
834         ast_log(LOG_DEBUG, "(Provisional) Stopping retransmission (but retaining packet) on '%s' %s %d: %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
835         return res;
836 }
837
838 /*--- 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         if (!value)
2375                 return -1;
2376         strncpy(copy, value, sizeof(copy)-1);
2377         stringp=copy;
2378         username = stringp;
2379         hostname = strrchr(stringp, '@');
2380         if (hostname) {
2381                 *hostname = '\0';
2382                 hostname++;
2383         }
2384         if (!username || ast_strlen_zero(username) || !hostname || ast_strlen_zero(hostname)) {
2385                 ast_log(LOG_WARNING, "Format for registration is user[:secret[:authuser]]@host[:port][/contact] at line %d", lineno);
2386                 return -1;
2387         }
2388         stringp=username;
2389         username = strsep(&stringp, ":");
2390         if (username) {
2391                 secret = strsep(&stringp, ":");
2392                 if (secret) 
2393                         authuser = strsep(&stringp, ":");
2394         }
2395         stringp = hostname;
2396         hostname = strsep(&stringp, "/");
2397         if (hostname) 
2398                 contact = strsep(&stringp, "/");
2399         if (!contact || ast_strlen_zero(contact))
2400                 contact = "s";
2401         stringp=hostname;
2402         hostname = strsep(&stringp, ":");
2403         porta = strsep(&stringp, ":");
2404         
2405         if (porta && !atoi(porta)) {
2406                 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
2407                 return -1;
2408         }
2409         reg = malloc(sizeof(struct sip_registry));
2410         if (reg) {
2411                 memset(reg, 0, sizeof(struct sip_registry));
2412                 strncpy(reg->contact, contact, sizeof(reg->contact) - 1);
2413                 if (username)
2414                         strncpy(reg->username, username, sizeof(reg->username)-1);
2415                 if (hostname)
2416                         strncpy(reg->hostname, hostname, sizeof(reg->hostname)-1);
2417                 if (authuser)
2418                         strncpy(reg->authuser, authuser, sizeof(reg->authuser)-1);
2419                 if (secret)
2420                         strncpy(reg->secret, secret, sizeof(reg->secret)-1);
2421                 reg->expire = -1;
2422                 reg->timeout =  -1;
2423                 reg->refresh = default_expiry;
2424                 reg->portno = porta ? htons(atoi(porta)) : 0;
2425                 reg->callid_valid = 0;
2426                 reg->ocseq = 101;
2427                 ast_mutex_lock(&regl.lock);
2428                 reg->next = regl.registrations;
2429                 regl.registrations = reg;
2430                 ast_mutex_unlock(&regl.lock);
2431         } else {
2432                 ast_log(LOG_ERROR, "Out of memory\n");
2433                 return -1;
2434         }
2435         return 0;
2436 }
2437
2438 /*--- lws2sws: Parse multiline SIP headers into one header */
2439 /* This is enabled if pedanticsipchecking is enabled */
2440 static int lws2sws(char *msgbuf, int len) 
2441
2442         int h = 0, t = 0; 
2443         int lws = 0; 
2444
2445         for (; h < len;) { 
2446                 /* Eliminate all CRs */ 
2447                 if (msgbuf[h] == '\r') { 
2448                         h++; 
2449                         continue; 
2450                 } 
2451                 /* Check for end-of-line */ 
2452                 if (msgbuf[h] == '\n') { 
2453                 /* Check for end-of-message */ 
2454                         if (h + 1 == len) 
2455                         break; 
2456                 /* Check for a continuation line */ 
2457                 if (msgbuf[h + 1] == ' ') { 
2458                 /* Merge continuation line */ 
2459                         h++; 
2460                         continue; 
2461                 } 
2462                 /* Propagate LF and start new line */ 
2463                 msgbuf[t++] = msgbuf[h++]; 
2464                 lws = 0;
2465                 continue; 
2466         } 
2467
2468         if (msgbuf[h] == ' ' || msgbuf[h] == '\t') { 
2469                 if (lws) { 
2470                         h++; 
2471                         continue; 
2472                 } 
2473                 msgbuf[t++] = msgbuf[h++]; 
2474                 lws = 1; 
2475                 continue; 
2476         } 
2477         msgbuf[t++] = msgbuf[h++]; 
2478         if (lws) 
2479                 lws = 0; 
2480         } 
2481         msgbuf[t] = '\0'; 
2482         return t; 
2483 }
2484
2485 /*--- parse: Parse a SIP message ----*/
2486 static void parse(struct sip_request *req)
2487 {
2488         /* Divide fields by NULL's */
2489         char *c;
2490         int f = 0;
2491         c = req->data;
2492
2493         /* First header starts immediately */
2494         req->header[f] = c;
2495         while(*c) {
2496                 if (*c == '\n') {
2497                         /* We've got a new header */
2498                         *c = 0;
2499
2500 #if 0
2501                         printf("Header: %s (%d)\n", req->header[f], strlen(req->header[f]));
2502 #endif                  
2503                         if (ast_strlen_zero(req->header[f])) {
2504                                 /* Line by itself means we're now in content */
2505                                 c++;
2506                                 break;
2507                         }
2508                         if (f >= SIP_MAX_HEADERS - 1) {
2509                                 ast_log(LOG_WARNING, "Too many SIP headers...\n");
2510                         } else
2511                                 f++;
2512                         req->header[f] = c + 1;
2513                 } else if (*c == '\r') {
2514                         /* Ignore but eliminate \r's */
2515                         *c = 0;
2516                 }
2517                 c++;
2518         }
2519         /* Check for last header */
2520         if (!ast_strlen_zero(req->header[f])) 
2521                 f++;
2522         req->headers = f;
2523         /* Now we process any mime content */
2524         f = 0;
2525         req->line[f] = c;
2526         while(*c) {
2527                 if (*c == '\n') {
2528                         /* We've got a new line */
2529                         *c = 0;
2530 #if 0
2531                         printf("Line: %s (%d)\n", req->line[f], strlen(req->line[f]));
2532 #endif                  
2533                         if (f >= SIP_MAX_LINES - 1) {
2534                                 ast_log(LOG_WARNING, "Too many SDP lines...\n");
2535                         } else
2536                                 f++;
2537                         req->line[f] = c + 1;
2538                 } else if (*c == '\r') {
2539                         /* Ignore and eliminate \r's */
2540                         *c = 0;
2541                 }
2542                 c++;
2543         }
2544         /* Check for last line */
2545         if (!ast_strlen_zero(req->line[f])) 
2546                 f++;
2547         req->lines = f;
2548         if (*c) 
2549                 ast_log(LOG_WARNING, "Odd content, extra stuff left over ('%s')\n", c);
2550 }
2551
2552 /*--- process_sdp: Process SIP SDP ---*/
2553 static int process_sdp(struct sip_pvt *p, struct sip_request *req)
2554 {
2555         char *m;
2556         char *c;
2557         char *a;
2558         char host[258];
2559         char iabuf[INET_ADDRSTRLEN];
2560         int len = -1;
2561         int portno=0;
2562         int vportno=0;
2563         int peercapability, peernoncodeccapability;
2564         int vpeercapability=0, vpeernoncodeccapability=0;
2565         struct sockaddr_in sin;
2566         char *codecs;
2567         struct hostent *hp;
2568         struct ast_hostent ahp;
2569         int codec;
2570         int iterator;
2571         int sendonly = 0;
2572         int x;
2573         int debug=sip_debug_test_pvt(p);
2574
2575         /* Update our last rtprx when we receive an SDP, too */
2576         time(&p->lastrtprx);
2577
2578         /* Get codec and RTP info from SDP */
2579         if (strcasecmp(get_header(req, "Content-Type"), "application/sdp")) {
2580                 ast_log(LOG_NOTICE, "Content is '%s', not 'application/sdp'\n", get_header(req, "Content-Type"));
2581                 return -1;
2582         }
2583         m = get_sdp(req, "m");
2584         c = get_sdp(req, "c");
2585         if (ast_strlen_zero(m) || ast_strlen_zero(c)) {
2586                 ast_log(LOG_WARNING, "Insufficient information for SDP (m = '%s', c = '%s')\n", m, c);
2587                 return -1;
2588         }
2589         if (sscanf(c, "IN IP4 %256s", host) != 1) {
2590                 ast_log(LOG_WARNING, "Invalid host in c= line, '%s'\n", c);
2591                 return -1;
2592         }
2593         /* XXX This could block for a long time, and block the main thread! XXX */
2594         hp = ast_gethostbyname(host, &ahp);
2595         if (!hp) {
2596                 ast_log(LOG_WARNING, "Unable to lookup host in c= line, '%s'\n", c);
2597                 return -1;
2598         }
2599         sdpLineNum_iterator_init(&iterator);
2600         while ((m = get_sdp_iterate(&iterator, req, "m"))[0] != '\0') {
2601                 if ((sscanf(m, "audio %d RTP/AVP %n", &x, &len) == 1)) {
2602                         portno = x;
2603                         /* Scan through the RTP payload types specified in a "m=" line: */
2604                         ast_rtp_pt_clear(p->rtp);
2605                         codecs = m + len;
2606                         while(!ast_strlen_zero(codecs)) {
2607                                 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2608                                         ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2609                                         return -1;
2610                                 }
2611                                 if (debug)
2612                                         ast_verbose("Found RTP audio format %d\n", codec);
2613                                 ast_rtp_set_m_type(p->rtp, codec);
2614                                 codecs += len;
2615                                 /* Skip over any whitespace */
2616                                 while(*codecs && (*codecs < 33)) codecs++;
2617                         }
2618                 }
2619                 if (p->vrtp)
2620                         ast_rtp_pt_clear(p->vrtp);  /* Must be cleared in case no m=video line exists */
2621
2622                 if (p->vrtp && (sscanf(m, "video %d RTP/AVP %n", &x, &len) == 1)) {
2623                         vportno = x;
2624                         /* Scan through the RTP payload types specified in a "m=" line: */
2625                         codecs = m + len;
2626                         while(!ast_strlen_zero(codecs)) {
2627                                 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2628                                         ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2629                                         return -1;
2630                                 }
2631                                 if (debug)
2632                                         ast_verbose("Found video format %s\n", ast_getformatname(codec));
2633                                 ast_rtp_set_m_type(p->vrtp, codec);
2634                                 codecs += len;
2635                                 /* Skip over any whitespace */
2636                                 while(*codecs && (*codecs < 33)) codecs++;
2637                         }
2638                 }
2639         }
2640
2641         /* RTP addresses and ports for audio and video */
2642         sin.sin_family = AF_INET;
2643         memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
2644         /* Setup audio port number */
2645         sin.sin_port = htons(portno);
2646         if (p->rtp && sin.sin_port)
2647                 ast_rtp_set_peer(p->rtp, &sin);
2648         /* Setup video port number */
2649         sin.sin_port = htons(vportno);
2650         if (p->vrtp && sin.sin_port)
2651                 ast_rtp_set_peer(p->vrtp, &sin);
2652
2653         if (sipdebug)
2654                 ast_verbose("Peer RTP is at port %s:%d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2655
2656         /* Next, scan through each "a=rtpmap:" line, noting each
2657          * specified RTP payload type (with corresponding MIME subtype):
2658          */
2659         sdpLineNum_iterator_init(&iterator);
2660         while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
2661       char* mimeSubtype = ast_strdupa(a); /* ensures we have enough space */
2662           if (!strcasecmp(a, "sendonly")) {
2663                 sendonly=1;
2664                 continue;
2665           }
2666           if (!strcasecmp(a, "sendrecv")) {
2667                 sendonly=0;
2668           }
2669           if (sscanf(a, "rtpmap: %u %[^/]/", &codec, mimeSubtype) != 2) continue;
2670           if (debug)
2671                 ast_verbose("Found description format %s\n", mimeSubtype);
2672           /* Note: should really look at the 'freq' and '#chans' params too */
2673           ast_rtp_set_rtpmap_type(p->rtp, codec, "audio", mimeSubtype);
2674           if (p->vrtp)
2675                   ast_rtp_set_rtpmap_type(p->vrtp, codec, "video", mimeSubtype);
2676         }
2677
2678         /* Now gather all of the codecs that were asked for: */
2679         ast_rtp_get_current_formats(p->rtp,
2680                                 &peercapability, &peernoncodeccapability);
2681         if (p->vrtp)
2682                 ast_rtp_get_current_formats(p->vrtp,
2683                                 &vpeercapability, &vpeernoncodeccapability);
2684         p->jointcapability = p->capability & (peercapability | vpeercapability);
2685         p->noncodeccapability = noncodeccapability & (peernoncodeccapability | vpeernoncodeccapability);
2686         
2687         if (debug) {
2688                 const unsigned slen=80;
2689                 char s1[slen], s2[slen], s3[slen], s4[slen];
2690
2691                 ast_verbose("Capabilities: us - %s, peer - audio=%s/video=%s, combined - %s\n",
2692                         ast_getformatname_multiple(s1, slen, p->capability),
2693                         ast_getformatname_multiple(s2, slen, peercapability),
2694                         ast_getformatname_multiple(s3, slen, vpeercapability),
2695                         ast_getformatname_multiple(s4, slen, p->jointcapability));
2696
2697                 ast_verbose("Non-codec capabilities: us - %s, peer - %s, combined - %s\n",
2698                         ast_getformatname_multiple(s1, slen, noncodeccapability),
2699                         ast_getformatname_multiple(s2, slen, peernoncodeccapability),
2700                         ast_getformatname_multiple(s3, slen, p->noncodeccapability));
2701         }
2702         if (!p->jointcapability) {
2703                 ast_log(LOG_WARNING, "No compatible codecs!\n");
2704                 return -1;
2705         }
2706         if (p->owner) {
2707                 if (!(p->owner->nativeformats & p->jointcapability)) {
2708                         const unsigned slen=80;
2709                         char s1[slen], s2[slen];
2710                         ast_log(LOG_DEBUG, "Oooh, we need to change our formats since our peer supports only %s and not %s\n", 
2711                                         ast_getformatname_multiple(s1, slen, p->jointcapability),
2712                                         ast_getformatname_multiple(s2, slen, p->owner->nativeformats));
2713                         p->owner->nativeformats = sip_codec_choose(p->jointcapability);
2714                         ast_set_read_format(p->owner, p->owner->readformat);
2715                         ast_set_write_format(p->owner, p->owner->writeformat);
2716                 }
2717                 if (p->owner->bridge) {
2718                         /* Turn on/off music on hold if we are holding/unholding */
2719                         if (sin.sin_addr.s_addr && !sendonly) {
2720                                 ast_moh_stop(p->owner->bridge);
2721                         } else {
2722                                 ast_moh_start(p->owner->bridge, NULL);
2723                         }
2724                 }
2725         }
2726         return 0;
2727         
2728 }
2729
2730 /*--- add_header: Add header to SIP message */
2731 static int add_header(struct sip_request *req, char *var, char *value)
2732 {
2733         if (req->len >= sizeof(req->data) - 4) {
2734                 ast_log(LOG_WARNING, "Out of space, can't add anymore (%s:%s)\n", var, value);
2735                 return -1;
2736         }
2737         if (req->lines) {
2738                 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
2739                 return -1;
2740         }
2741         req->header[req->headers] = req->data + req->len;
2742         snprintf(req->header[req->headers], sizeof(req->data) - req->len - 4, "%s: %s\r\n", var, value);
2743         req->len += strlen(req->header[req->headers]);
2744         if (req->headers < SIP_MAX_HEADERS)
2745                 req->headers++;
2746         else {
2747                 ast_log(LOG_WARNING, "Out of header space\n");
2748                 return -1;
2749         }
2750         return 0;       
2751 }
2752
2753 /*--- add_blank_header: Add blank header to SIP message */
2754 static int add_blank_header(struct sip_request *req)
2755 {
2756         if (req->len >= sizeof(req->data) - 4) {
2757                 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
2758                 return -1;
2759         }
2760         if (req->lines) {
2761                 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
2762                 return -1;
2763         }
2764         req->header[req->headers] = req->data + req->len;
2765         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "\r\n");
2766         req->len += strlen(req->header[req->headers]);
2767         if (req->headers < SIP_MAX_HEADERS)
2768                 req->headers++;
2769         else {
2770                 ast_log(LOG_WARNING, "Out of header space\n");
2771                 return -1;
2772         }
2773         return 0;       
2774 }
2775
2776 /*--- add_line: Add content (not header) to SIP message */
2777 static int add_line(struct sip_request *req, char *line)
2778 {
2779         if (req->len >= sizeof(req->data) - 4) {
2780                 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
2781                 return -1;
2782         }
2783         if (!req->lines) {
2784                 /* Add extra empty return */
2785                 snprintf(req->data + req->len, sizeof(req->data) - req->len, "\r\n");
2786                 req->len += strlen(req->data + req->len);
2787         }
2788         req->line[req->lines] = req->data + req->len;
2789         snprintf(req->line[req->lines], sizeof(req->data) - req->len, "%s", line);
2790         req->len += strlen(req->line[req->lines]);
2791         if (req->lines < SIP_MAX_LINES)
2792                 req->lines++;
2793         else {
2794                 ast_log(LOG_WARNING, "Out of line space\n");
2795                 return -1;
2796         }
2797         return 0;       
2798 }
2799
2800 /*--- copy_header: Copy one header field from one request to another */
2801 static int copy_header(struct sip_request *req, struct sip_request *orig, char *field)
2802 {
2803         char *tmp;
2804         tmp = get_header(orig, field);
2805         if (!ast_strlen_zero(tmp)) {
2806                 /* Add what we're responding to */
2807                 return add_header(req, field, tmp);
2808         }
2809         ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
2810         return -1;
2811 }
2812
2813 /*--- copy_all_header: Copy all headers from one request to another ---*/
2814 static int copy_all_header(struct sip_request *req, struct sip_request *orig, char *field)
2815 {
2816         char *tmp;
2817         int start = 0;
2818         int copied = 0;
2819         for (;;) {
2820                 tmp = __get_header(orig, field, &start);
2821                 if (!ast_strlen_zero(tmp)) {
2822                         /* Add what we're responding to */
2823                         add_header(req, field, tmp);
2824                         copied++;
2825                 } else
2826                         break;
2827         }
2828         return copied ? 0 : -1;
2829 }
2830
2831 /*--- copy_via_headers: Copy SIP VIA Headers from one request to another ---*/
2832 static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, struct sip_request *orig, char *field)
2833 {
2834         char tmp[256]="", *oh, *end;
2835         int start = 0;
2836         int copied = 0;
2837         char new[256];
2838         char iabuf[INET_ADDRSTRLEN];
2839         for (;;) {
2840                 oh = __get_header(orig, field, &start);
2841                 if (!ast_strlen_zero(oh)) {
2842                         /* Strip ;rport */
2843                         strncpy(tmp, oh, sizeof(tmp) - 1);
2844                         oh = strstr(tmp, ";rport");
2845                         if (oh) {
2846                                 end = strchr(oh + 1, ';');
2847                                 if (end)
2848                                         memmove(oh, end, strlen(end) + 1);
2849                                 else
2850                                         *oh = '\0';
2851                         }
2852                         if (!copied && (p->nat == SIP_NAT_ALWAYS)) {
2853                                 /* Whoo hoo!  Now we can indicate port address translation too!  Just
2854                                    another RFC (RFC3581). I'll leave the original comments in for
2855                                    posterity.  */
2856                                 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));
2857                                 add_header(req, field, new);
2858                         } else {
2859                                 /* Add what we're responding to */
2860                                 add_header(req, field, tmp);
2861                         }
2862                         copied++;
2863                 } else
2864                         break;
2865         }
2866         if (!copied) {
2867                 ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
2868                 return -1;
2869         }
2870         return 0;
2871 }
2872
2873 /*--- add_route: Add route header into request per learned route ---*/
2874 static void add_route(struct sip_request *req, struct sip_route *route)
2875 {
2876         char r[256], *p;
2877         int n, rem = 255; /* sizeof(r)-1: Room for terminating 0 */
2878
2879         if (!route) return;
2880
2881         p = r;
2882         while (route) {
2883                 n = strlen(route->hop);
2884                 if ((n+3)>rem) break;
2885                 if (p != r) {
2886                         *p++ = ',';
2887                         --rem;
2888                 }
2889                 *p++ = '<';
2890                 strncpy(p, route->hop, rem);  p += n;
2891                 *p++ = '>';
2892                 rem -= (n+2);
2893                 route = route->next;
2894         }
2895         *p = '\0';
2896         add_header(req, "Route", r);
2897 }
2898
2899 /*--- set_destination: Set destination from SIP URI ---*/
2900 static void set_destination(struct sip_pvt *p, char *uri)
2901 {
2902         char *h, *maddr, hostname[256];
2903         char iabuf[INET_ADDRSTRLEN];
2904         int port, hn;
2905         struct hostent *hp;
2906         struct ast_hostent ahp;
2907         int debug=sip_debug_test_pvt(p);
2908
2909         /* Parse uri to h (host) and port - uri is already just the part inside the <> */
2910         /* general form we are expecting is sip[s]:username[:password]@host[:port][;...] */
2911
2912         if (debug)
2913                 ast_verbose("set_destination: Parsing <%s> for address/port to send to\n", uri);
2914
2915         /* Find and parse hostname */
2916         h = strchr(uri, '@');
2917         if (h)
2918                 ++h;
2919         else {
2920                 h = uri;
2921                 if (strncmp(h, "sip:", 4) == 0)
2922                         h += 4;
2923                 else if (strncmp(h, "sips:", 5) == 0)
2924                         h += 5;
2925         }
2926         hn = strcspn(h, ":;>");
2927         if (hn>255) hn=255;
2928         strncpy(hostname, h, hn);  hostname[hn] = '\0';
2929         h+=hn;
2930
2931         /* Is "port" present? if not default to 5060 */
2932         if (*h == ':') {
2933                 /* Parse port */
2934                 ++h;
2935                 port = strtol(h, &h, 10);
2936         }
2937         else
2938                 port = 5060;
2939
2940         /* Got the hostname:port - but maybe there's a "maddr=" to override address? */
2941         maddr = strstr(h, "maddr=");
2942         if (maddr) {
2943                 maddr += 6;
2944                 hn = strspn(maddr, "0123456789.");
2945                 if (hn>255) hn=255;
2946                 strncpy(hostname, maddr, hn);  hostname[hn] = '\0';
2947         }
2948         
2949         hp = ast_gethostbyname(hostname, &ahp);
2950         if (hp == NULL)  {
2951                 ast_log(LOG_WARNING, "Can't find address for host '%s'\n", hostname);
2952                 return;
2953         }
2954         p->sa.sin_family = AF_INET;
2955         memcpy(&p->sa.sin_addr, hp->h_addr, sizeof(p->sa.sin_addr));
2956         p->sa.sin_port = htons(port);
2957         if (debug)
2958                 ast_verbose("set_destination: set destination to %s, port %d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), p->sa.sin_addr), port);
2959 }
2960
2961 /*--- init_resp: Initialize SIP response, based on SIP request ---*/
2962 static int init_resp(struct sip_request *req, char *resp, struct sip_request *orig)
2963 {
2964         /* Initialize a response */
2965         if (req->headers || req->len) {
2966                 ast_log(LOG_WARNING, "Request already initialized?!?\n");
2967                 return -1;
2968         }
2969         req->header[req->headers] = req->data + req->len;
2970         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "SIP/2.0 %s\r\n", resp);
2971         req->len += strlen(req->header[req->headers]);
2972         if (req->headers < SIP_MAX_HEADERS)
2973                 req->headers++;
2974         else
2975                 ast_log(LOG_WARNING, "Out of header space\n");
2976         return 0;
2977 }
2978
2979 /*--- init_req: Initialize SIP request ---*/
2980 static int init_req(struct sip_request *req, char *resp, char *recip)
2981 {
2982         /* Initialize a response */
2983         if (req->headers || req->len) {
2984                 ast_log(LOG_WARNING, "Request already initialized?!?\n");
2985                 return -1;
2986         }
2987         req->header[req->headers] = req->data + req->len;
2988         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "%s %s SIP/2.0\r\n", resp, recip);
2989         req->len += strlen(req->header[req->headers]);
2990         if (req->headers < SIP_MAX_HEADERS)
2991                 req->headers++;
2992         else
2993                 ast_log(LOG_WARNING, "Out of header space\n");
2994         return 0;
2995 }
2996
2997
2998 static int respprep(struct sip_request *resp, struct sip_pvt *p, char *msg, struct sip_request *req)
2999 {
3000         char newto[256] = "", *ot;
3001
3002         memset(resp, 0, sizeof(*resp));
3003         init_resp(resp, msg, req);
3004         copy_via_headers(p, resp, req, "Via");
3005         if (msg[0] == '2') copy_all_header(resp, req, "Record-Route");
3006         copy_header(resp, req, "From");
3007         ot = get_header(req, "To");
3008         if (!strstr(ot, "tag=")) {
3009                 /* Add the proper tag if we don't have it already.  If they have specified
3010                    their tag, use it.  Otherwise, use our own tag */
3011                 if (!ast_strlen_zero(p->theirtag) && p->outgoing)
3012                         snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
3013                 else if (p->tag && !p->outgoing)
3014                         snprintf(newto, sizeof(newto), "%s;tag=as%08x", ot, p->tag);
3015                 else {
3016                         strncpy(newto, ot, sizeof(newto) - 1);
3017                         newto[sizeof(newto) - 1] = '\0';
3018                 }
3019                 ot = newto;
3020         }
3021         add_header(resp, "To", ot);
3022         copy_header(resp, req, "Call-ID");
3023         copy_header(resp, req, "CSeq");
3024         add_header(resp, "User-Agent", default_useragent);
3025         add_header(resp, "Allow", ALLOWED_METHODS);
3026         if (p->expiry) {
3027                 /* For registration responses, we also need expiry and
3028                    contact info */
3029                 char contact[256];
3030                 char tmp[256];
3031                 snprintf(contact, sizeof(contact), "%s;expires=%d", p->our_contact, p->expiry);
3032                 snprintf(tmp, sizeof(tmp), "%d", p->expiry);
3033                 add_header(resp, "Expires", tmp);
3034                 add_header(resp, "Contact", contact);
3035         } else {
3036                 add_header(resp, "Contact", p->our_contact);
3037         }
3038         return 0;
3039 }
3040
3041 static int reqprep(struct sip_request *req, struct sip_pvt *p, char *msg, int seqno, int newbranch)
3042 {
3043         struct sip_request *orig = &p->initreq;
3044         char stripped[80] ="";
3045         char tmp[80];
3046         char newto[256];
3047         char iabuf[INET_ADDRSTRLEN];
3048         char *c, *n;
3049         char *ot, *of;
3050
3051         memset(req, 0, sizeof(struct sip_request));
3052         
3053         snprintf(p->lastmsg, sizeof(p->lastmsg), "Tx: %s", msg);
3054         
3055         if (!seqno) {
3056                 p->ocseq++;
3057                 seqno = p->ocseq;
3058         }
3059         
3060         if (newbranch) {
3061                 p->branch ^= rand();
3062                 if (p->nat != SIP_NAT_NEVER)
3063                         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);
3064                 else /* Some implementations (e.g. Uniden UIP200) can't handle rport being in the message!! */
3065                         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);
3066         }
3067
3068         if (!ast_strlen_zero(p->uri)) {
3069                 c = p->uri;
3070         } else {
3071                 if (p->outgoing)
3072                         strncpy(stripped, get_header(orig, "To"), sizeof(stripped) - 1);
3073                 else
3074                         strncpy(stripped, get_header(orig, "From"), sizeof(stripped) - 1);
3075                 
3076                 c = strchr(stripped, '<');
3077                 if (c) 
3078                         c++;
3079                 else
3080                         c = stripped;
3081                 n = strchr(c, '>');
3082                 if (n)
3083                         *n = '\0';
3084                 n = strchr(c, ';');
3085                 if (n)
3086                         *n = '\0';
3087         }       
3088         init_req(req, msg, c);
3089
3090         snprintf(tmp, sizeof(tmp), "%d %s", seqno, msg);
3091
3092         add_header(req, "Via", p->via);
3093         if (p->route) {
3094                 set_destination(p, p->route->hop);
3095                 add_route(req, p->route->next);
3096         }
3097
3098         ot = get_header(orig, "To");
3099         of = get_header(orig, "From");
3100
3101         /* Add tag *unless* this is a CANCEL, in which case we need to send it exactly
3102            as our original request, including tag (or presumably lack thereof) */
3103         if (!strstr(ot, "tag=") && strcasecmp(msg, "CANCEL")) {
3104                 /* Add the proper tag if we don't have it already.  If they have specified
3105                    their tag, use it.  Otherwise, use our own tag */
3106                 if (p->outgoing && !ast_strlen_zero(p->theirtag))
3107                         snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
3108                 else if (!p->outgoing)
3109                         snprintf(newto, sizeof(newto), "%s;tag=as%08x", ot, p->tag);
3110                 else
3111                         snprintf(newto, sizeof(newto), "%s", ot);
3112                 ot = newto;
3113         }
3114
3115         if (p->outgoing) {
3116                 add_header(req, "From", of);
3117                 add_header(req, "To", ot);
3118         } else {
3119                 add_header(req, "From", ot);
3120                 add_header(req, "To", of);
3121         }
3122         add_header(req, "Contact", p->our_contact);
3123         copy_header(req, orig, "Call-ID");
3124         add_header(req, "CSeq", tmp);
3125
3126         add_header(req, "User-Agent", default_useragent);
3127         return 0;
3128 }
3129
3130 static int __transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req, int reliable)
3131 {
3132         struct sip_request resp;
3133         int seqno = 0;
3134         if (reliable && (sscanf(get_header(req, "CSeq"), "%i ", &seqno) != 1)) {
3135                 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
3136                 return -1;
3137         }
3138         respprep(&resp, p, msg, req);
3139         add_header(&resp, "Content-Length", "0");
3140         add_blank_header(&resp);
3141         return send_response(p, &resp, reliable, seqno);
3142 }
3143
3144 /*--- transmit_response: Transmit response, no retransmits */
3145 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req) 
3146 {
3147         return __transmit_response(p, msg, req, 0);
3148 }
3149
3150 /*--- transmit_response: Transmit response, Make sure you get a reply */
3151 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal)
3152 {
3153         return __transmit_response(p, msg, req, fatal ? 2 : 1);
3154 }
3155
3156 /*--- append_date: Append date to SIP message ---*/
3157 static void append_date(struct sip_request *req)
3158 {
3159         char tmpdat[256];
3160         struct tm tm;
3161         time_t t;
3162         time(&t);
3163         gmtime_r(&t, &tm);
3164         strftime(tmpdat, sizeof(tmpdat), "%a, %d %b %Y %T GMT", &tm);
3165         add_header(req, "Date", tmpdat);
3166 }
3167
3168 /*--- transmit_response_with_date: Append date and content length before transmitting response ---*/
3169 static int transmit_response_with_date(struct sip_pvt *p, char *msg, struct sip_request *req)
3170 {
3171         struct sip_request resp;
3172         respprep(&resp, p, msg, req);
3173         append_date(&resp);
3174         add_header(&resp, "Content-Length", "0");
3175         add_blank_header(&resp);
3176         return send_response(p, &resp, 0, 0);
3177 }
3178
3179 /*--- transmit_response_with_allow: Append Accept header, content length before transmitting response ---*/
3180 static int transmit_response_with_allow(struct sip_pvt *p, char *msg, struct sip_request *req, int reliable)
3181 {
3182         struct sip_request resp;
3183         respprep(&resp, p, msg, req);
3184         add_header(&resp, "Accept", "application/sdp");
3185         add_header(&resp, "Content-Length", "0");
3186         add_blank_header(&resp);
3187         return send_response(p, &resp, reliable, 0);
3188 }
3189
3190 /* transmit_response_with_auth: Respond with authorization request */
3191 static int transmit_response_with_auth(struct sip_pvt *p, char *msg, struct sip_request *req, char *randdata, int reliable, char *header)
3192 {
3193         struct sip_request resp;
3194         char tmp[256];
3195         int seqno = 0;
3196         if (reliable && (sscanf(get_header(req, "CSeq"), "%i ", &seqno) != 1)) {
3197                 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
3198                 return -1;
3199         }
3200         snprintf(tmp, sizeof(tmp), "Digest realm=\"%s\", nonce=\"%s\"", global_realm, randdata);
3201         respprep(&resp, p, msg, req);
3202         add_header(&resp, header, tmp);
3203         add_header(&resp, "Content-Length", "0");
3204         add_blank_header(&resp);
3205         return send_response(p, &resp, reliable, seqno);
3206 }
3207
3208 /*--- add_text: Add text body to SIP message ---*/
3209 static int add_text(struct sip_request *req, char *text)
3210 {
3211         /* XXX Convert \n's to \r\n's XXX */
3212         int len = strlen(text);
3213         char clen[256];
3214         snprintf(clen, sizeof(clen), "%d", len);
3215         add_header(req, "Content-Type", "text/plain");
3216         add_header(req, "Content-Length", clen);
3217         add_line(req, text);
3218         return 0;
3219 }
3220
3221 /*--- add_digit: add DTMF INFO tone to sip message ---*/
3222 /* Always adds default duration 250 ms, regardless of what came in over the line */
3223 static int add_digit(struct sip_request *req, char digit)
3224 {
3225         char tmp[256];
3226         int len;
3227         char clen[256];
3228         snprintf(tmp, sizeof(tmp), "Signal=%c\r\nDuration=250\r\n", digit);
3229         len = strlen(tmp);
3230         snprintf(clen, sizeof(clen), "%d", len);
3231         add_header(req, "Content-Type", "application/dtmf-relay");
3232         add_header(req, "Content-Length", clen);
3233         add_line(req, tmp);
3234         return 0;
3235 }
3236
3237 /*--- add_sdp: Add Session Description Protocol message ---*/
3238 static int add_sdp(struct sip_request *resp, struct sip_pvt *p)
3239 {
3240         int len;
3241         int codec;
3242         int alreadysent = 0;
3243         char costr[80];
3244         struct sockaddr_in sin;
3245         struct sockaddr_in vsin;
3246         struct sip_codec_pref *cur;
3247         char v[256] = "";
3248         char s[256] = "";
3249         char o[256] = "";
3250         char c[256] = "";
3251         char t[256] = "";
3252         char m[256] = "";
3253         char m2[256] = "";
3254         char a[1024] = "";
3255         char a2[1024] = "";
3256         char iabuf[INET_ADDRSTRLEN];
3257         int x;
3258         int capability;
3259         struct sockaddr_in dest;
3260         struct sockaddr_in vdest = { 0, };
3261         int debug=sip_debug_test_pvt(p);
3262
3263         /* XXX We break with the "recommendation" and send our IP, in order that our
3264                peer doesn't have to ast_gethostbyname() us XXX */
3265         len = 0;
3266         if (!p->rtp) {
3267                 ast_log(LOG_WARNING, "No way to add SDP without an RTP structure\n");
3268                 return -1;
3269         }
3270         capability = p->jointcapability;
3271                 
3272         if (!p->sessionid) {
3273                 p->sessionid = getpid();
3274                 p->sessionversion = p->sessionid;
3275         } else
3276                 p->sessionversion++;
3277         ast_rtp_get_us(p->rtp, &sin);
3278         if (p->vrtp)
3279                 ast_rtp_get_us(p->vrtp, &vsin);
3280
3281         if (p->redirip.sin_addr.s_addr) {
3282                 dest.sin_port = p->redirip.sin_port;
3283                 dest.sin_addr = p->redirip.sin_addr;
3284                 if (p->redircodecs)
3285                         capability = p->redircodecs;
3286         } else {
3287                 dest.sin_addr = p->ourip;
3288                 dest.sin_port = sin.sin_port;
3289         }
3290
3291         /* Determine video destination */
3292         if (p->vrtp) {
3293                 if (p->vredirip.sin_addr.s_addr) {
3294                         vdest.sin_port = p->vredirip.sin_port;
3295                         vdest.sin_addr = p->vredirip.sin_addr;
3296                 } else {
3297                         vdest.sin_addr = p->ourip;
3298                         vdest.sin_port = vsin.sin_port;
3299                 }
3300         }
3301         if (debug){
3302                 ast_verbose("We're at %s port %d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ntohs(sin.sin_port));       
3303                 if (p->vrtp)
3304                         ast_verbose("Video is at %s port %d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ntohs(vsin.sin_port));   
3305         }
3306         snprintf(v, sizeof(v), "v=0\r\n");
3307         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));
3308         snprintf(s, sizeof(s), "s=session\r\n");
3309         snprintf(c, sizeof(c), "c=IN IP4 %s\r\n", ast_inet_ntoa(iabuf, sizeof(iabuf), dest.sin_addr));
3310         snprintf(t, sizeof(t), "t=0 0\r\n");
3311         snprintf(m, sizeof(m), "m=audio %d RTP/AVP", ntohs(dest.sin_port));
3312         snprintf(m2, sizeof(m2), "m=video %d RTP/AVP", ntohs(vdest.sin_port));
3313         if (capability & p->prefcodec) {
3314                 if (debug)
3315                         ast_verbose("Answering/Requesting with root capability %d\n", p->prefcodec);
3316                 codec = ast_rtp_lookup_code(p->rtp, 1, p->prefcodec);
3317                 if (codec > -1) {
3318                         snprintf(costr, sizeof(costr), " %d", codec);
3319                         if (p->prefcodec <= AST_FORMAT_MAX_AUDIO) {
3320                                 strncat(m, costr, sizeof(m) - strlen(m) - 1);
3321                                 snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(1, p->prefcodec));
3322                                 strncpy(a, costr, sizeof(a) - 1);
3323                         } else {
3324                                 strncat(m2, costr, sizeof(m2) - strlen(m2) - 1);
3325                                 snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/90000\r\n", codec, ast_rtp_lookup_mime_subtype(1, p->prefcodec));
3326                                 strncpy(a2, costr, sizeof(a2) - 1);
3327                         }
3328                 }
3329                 alreadysent |= p->prefcodec;
3330         }
3331         /* Start by sending our preferred codecs */
3332         cur = prefs;
3333         while(cur) {
3334                 if ((capability & cur->codec) && !(alreadysent & cur->codec)) {
3335                         if (debug)
3336                                 ast_verbose("Answering with preferred capability 0x%x(%s)\n", cur->codec, ast_getformatname(cur->codec));
3337                         codec = ast_rtp_lookup_code(p->rtp, 1, cur->codec);
3338                         if (codec > -1) {
3339                                 snprintf(costr, sizeof(costr), " %d", codec);
3340                                 if (cur->codec <= AST_FORMAT_MAX_AUDIO) {
3341                                         strncat(m, costr, sizeof(m) - strlen(m) - 1);
3342                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(1, cur->codec));
3343                                         strncat(a, costr, sizeof(a) - strlen(a) - 1);
3344                                 } else {
3345                                         strncat(m2, costr, sizeof(m2) - strlen(m2) - 1);
3346                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/90000\r\n", codec, ast_rtp_lookup_mime_subtype(1, cur->codec));
3347                                         strncat(a2, costr, sizeof(a2) - strlen(a) - 1);
3348                                 }
3349                         }
3350                 }
3351                 alreadysent |= cur->codec;
3352                 cur = cur->next;
3353         }
3354         /* Now send any other common codecs, and non-codec formats: */
3355         for (x = 1; x <= (videosupport ? AST_FORMAT_MAX_VIDEO : AST_FORMAT_MAX_AUDIO); x <<= 1) {
3356                 if ((capability & x) && !(alreadysent & x)) {
3357                         if (debug)
3358                                 ast_verbose("Answering with capability 0x%x(%s)\n", x, ast_getformatname(x));
3359                         codec = ast_rtp_lookup_code(p->rtp, 1, x);
3360                         if (codec > -1) {
3361                                 snprintf(costr, sizeof(costr), " %d", codec);
3362                                 if (x <= AST_FORMAT_MAX_AUDIO) {
3363                                         strncat(m, costr, sizeof(m) - strlen(m) - 1);
3364                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(1, x));
3365                                         strncat(a, costr, sizeof(a) - strlen(a) - 1);
3366                                 } else {
3367                                         strncat(m2, costr, sizeof(m2) - strlen(m2));
3368                                         snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/90000\r\n", codec, ast_rtp_lookup_mime_subtype(1, x));
3369                                         strncat(a2, costr, sizeof(a2) - strlen(a2) - 1);
3370                                 }
3371                         }
3372                 }
3373         }
3374         for (x = 1; x <= AST_RTP_MAX; x <<= 1) {
3375                 if (p->noncodeccapability & x) {
3376                         if (debug)
3377                                 ast_verbose("Answering with non-codec capability 0x%x(%s)\n", x, ast_getformatname(x));
3378                         codec = ast_rtp_lookup_code(p->rtp, 0, x);
3379                         if (codec > -1) {
3380                                 snprintf(costr, sizeof(costr), " %d", codec);
3381                                 strncat(m, costr, sizeof(m) - strlen(m) - 1);
3382                                 snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(0, x));
3383                                 strncat(a, costr, sizeof(a) - strlen(a) - 1);
3384                                 if (x == AST_RTP_DTMF) {
3385                                   /* Indicate we support DTMF...  Not sure about 16, but MSN supports it so dang it, we will too... */
3386                                   snprintf(costr, sizeof costr, "a=fmtp:%d 0-16\r\n",
3387                                            codec);
3388                                   strncat(a, costr, sizeof(a) - strlen(a) - 1);
3389                                 }
3390                         }
3391                 }
3392         }
3393         strncat(a, "a=silenceSupp:off - - - -\r\n", sizeof(a) - strlen(a) - 1);
3394         if (strlen(m) < sizeof(m) - 2)
3395                 strcat(m, "\r\n");
3396         if (strlen(m2) < sizeof(m2) - 2)
3397                 strcat(m2, "\r\n");
3398         if ((sizeof(m) <= strlen(m) - 2) || (sizeof(m2) <= strlen(m2) - 2) || (sizeof(a) == strlen(a)) || (sizeof(a2) == strlen(a2)))
3399                 ast_log(LOG_WARNING, "SIP SDP may be truncated due to undersized buffer!!\n");
3400         len = strlen(v) + strlen(s) + strlen(o) + strlen(c) + strlen(t) + strlen(m) + strlen(a);
3401         if ((p->vrtp) && (capability & VIDEO_CODEC_MASK)) /* only if video response is appropriate */
3402                 len += strlen(m2) + strlen(a2);
3403         snprintf(costr, sizeof(costr), "%d", len);
3404         add_header(resp, "Content-Type", "application/sdp");
3405         add_header(resp, "Content-Length", costr);
3406         add_line(resp, v);
3407         add_line(resp, o);
3408         add_line(resp, s);
3409         add_line(resp, c);
3410         add_line(resp, t);
3411         add_line(resp, m);
3412         add_line(resp, a);
3413         if ((p->vrtp) && (capability & VIDEO_CODEC_MASK)) { /* only if video response is appropriate */
3414                 add_line(resp, m2);
3415                 add_line(resp, a2);
3416         }
3417         /* Update lastrtprx when we send our SDP */
3418         time(&p->lastrtprx);
3419         return 0;
3420 }
3421
3422 /*--- copy_request: copy SIP request (mostly used to save request for responses) ---*/
3423 static void copy_request(struct sip_request *dst,struct sip_request *src)
3424 {
3425         long offset;
3426         int x;
3427         offset = ((void *)dst) - ((void *)src);
3428         /* First copy stuff */
3429         memcpy(dst, src, sizeof(*dst));
3430         /* Now fix pointer arithmetic */
3431         for (x=0;x<src->headers;x++)
3432                 dst->header[x] += offset;
3433         for (x=0;x<src->lines;x++)
3434                 dst->line[x] += offset;
3435 }
3436
3437 /*--- transmit_response_with_sdp: Used for 200 OK ---*/
3438 static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans)
3439 {
3440         struct sip_request resp;
3441         int seqno;
3442         if (sscanf(get_header(req, "CSeq"), "%i ", &seqno) != 1) {
3443                 ast_log(LOG_WARNING, "Unable to get seqno from '%s'\n", get_header(req, "CSeq"));
3444                 return -1;
3445         }
3446         respprep(&resp, p, msg, req);
3447         add_sdp(&resp, p);
3448         return send_response(p, &resp, retrans, seqno);
3449 }
3450
3451 /*--- determine_firstline_parts: parse first line of incoming SIP request */
3452 static int determine_firstline_parts( struct sip_request *req ) {
3453
3454   char *e, *cmd;
3455   int len;
3456   
3457   cmd= req->header[0];
3458   while(*cmd && (*cmd < 33)) {
3459     cmd++;
3460   }
3461   if (!*cmd) {
3462     return -1;
3463   }
3464   e= cmd;
3465   while(*e && (*e > 32)) {
3466     e++;
3467   }
3468   /* Get the command */
3469   if (*e) {
3470     *e = '\0';
3471     e++;
3472   }
3473   req->rlPart1= cmd;
3474   while( *e && ( *e < 33 ) ) {
3475     e++; 
3476   }
3477   if( !*e ) {
3478     return -1;
3479   }
3480