2 * Asterisk -- A telephony toolkit for Linux.
4 * Implementation of Session Initiation Protocol
6 * Copyright (C) 2004 - 2005, Digium, Inc.
8 * Mark Spencer <markster@digium.com>
10 * This program is free software, distributed under the terms of
11 * the GNU General Public License
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/manager.h>
32 #include <asterisk/callerid.h>
33 #include <asterisk/cli.h>
34 #include <asterisk/md5.h>
35 #include <asterisk/app.h>
36 #include <asterisk/musiconhold.h>
37 #include <asterisk/dsp.h>
38 #include <asterisk/features.h>
39 #include <asterisk/acl.h>
40 #include <asterisk/srv.h>
41 #include <asterisk/astdb.h>
42 #include <asterisk/causes.h>
43 #include <asterisk/utils.h>
44 #include <asterisk/file.h>
45 #include <asterisk/astobj.h>
47 #include <asterisk/astosp.h>
49 #include <sys/socket.h>
50 #include <sys/ioctl.h>
57 #include <arpa/inet.h>
59 #include <sys/signal.h>
60 #include <netinet/in_systm.h>
61 #include <netinet/ip.h>
64 #ifndef DEFAULT_USERAGENT
65 #define DEFAULT_USERAGENT "Asterisk PBX"
68 #define VIDEO_CODEC_MASK 0x1fc0000 /* Video codecs from H.261 thru AST_FORMAT_MAX_VIDEO */
70 #define IPTOS_MINCOST 0x02
73 /* #define VOCAL_DATA_HACK */
76 #define DEFAULT_DEFAULT_EXPIRY 120
77 #define DEFAULT_MAX_EXPIRY 3600
78 #define DEFAULT_REGISTRATION_TIMEOUT 20
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
85 #define EXPIRY_GUARD_MIN 500 /* This is the minimum guard time applied. If
86 GUARD_PCT turns out to be lower than this, it
87 will use this time instead.
88 This is in milliseconds. */
89 #define EXPIRY_GUARD_PCT 0.20 /* Percentage of expires timeout to use when
90 below EXPIRY_GUARD_LIMIT */
92 static int max_expiry = DEFAULT_MAX_EXPIRY;
93 static int default_expiry = DEFAULT_DEFAULT_EXPIRY;
96 #define MAX(a,b) ((a) > (b) ? (a) : (b))
99 #define CALLERID_UNKNOWN "Unknown"
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... */
107 #define DEFAULT_RETRANS 1000 /* How frequently to retransmit */
108 #define MAX_RETRANS 5 /* Try only 5 times for retransmissions */
111 #define DEBUG_READ 0 /* Recieved data */
112 #define DEBUG_SEND 1 /* Transmit data */
114 static char *desc = "Session Initiation Protocol (SIP)";
115 static char *channeltype = "SIP";
116 static char *tdesc = "Session Initiation Protocol (SIP)";
117 static char *config = "sip.conf";
118 static char *notify_config = "sip_notify.conf";
120 #define DEFAULT_SIP_PORT 5060 /* From RFC 2543 */
121 #define SIP_MAX_PACKET 4096 /* Also from RFC 2543, should sub headers tho */
123 #define ALLOWED_METHODS "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER"
125 static char default_useragent[AST_MAX_EXTENSION] = DEFAULT_USERAGENT;
127 #define DEFAULT_CONTEXT "default"
128 static char default_context[AST_MAX_EXTENSION] = DEFAULT_CONTEXT;
130 static char default_language[MAX_LANGUAGE] = "";
132 #define DEFAULT_CALLERID "asterisk"
133 static char default_callerid[AST_MAX_EXTENSION] = DEFAULT_CALLERID;
135 static char default_fromdomain[AST_MAX_EXTENSION] = "";
137 #define DEFAULT_NOTIFYMIME "application/simple-message-summary"
138 static char default_notifymime[AST_MAX_EXTENSION] = DEFAULT_NOTIFYMIME;
140 static struct ast_flags global_flags = {0}; /* global SIP_ flags */
141 static struct ast_flags global_flags_page2 = {0}; /* more global SIP_ flags */
143 static int srvlookup = 0; /* SRV Lookup on or off. Default is off, RFC behavior is on */
145 static int pedanticsipchecking = 0; /* Extra checking ? Default off */
147 static int autocreatepeer = 0; /* Auto creation of peers at registration? Default off. */
149 static int relaxdtmf = 0;
151 static int global_rtptimeout = 0;
153 static int global_rtpholdtimeout = 0;
155 static int global_rtpkeepalive = 0;
157 static int global_reg_timeout = DEFAULT_REGISTRATION_TIMEOUT;
159 /* Object counters */
160 static int suserobjs = 0;
161 static int ruserobjs = 0;
162 static int speerobjs = 0;
163 static int rpeerobjs = 0;
164 static int apeerobjs = 0;
165 static int regobjs = 0;
167 static int global_allowguest = 0; /* allow unauthenticated users/peers to connect? */
169 #define DEFAULT_MWITIME 10
170 static int global_mwitime = DEFAULT_MWITIME; /* Time between MWI checks for peers */
172 static int usecnt =0;
173 AST_MUTEX_DEFINE_STATIC(usecnt_lock);
176 /* Protect the interface list (of sip_pvt's) */
177 AST_MUTEX_DEFINE_STATIC(iflock);
179 /* Protect the monitoring thread, so only one process can kill or start it, and not
180 when it's doing something critical. */
181 AST_MUTEX_DEFINE_STATIC(netlock);
183 AST_MUTEX_DEFINE_STATIC(monlock);
185 /* This is the thread for the monitor which checks for input on the channels
186 which are not currently in use. */
187 static pthread_t monitor_thread = AST_PTHREADT_NULL;
189 static int restart_monitor(void);
191 /* Codecs that we support by default: */
192 static int global_capability = AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_GSM | AST_FORMAT_H263;
193 static int noncodeccapability = AST_RTP_DTMF;
195 static struct in_addr __ourip;
196 static struct sockaddr_in outboundproxyip;
199 static int sipdebug = 0;
200 static struct sockaddr_in debugaddr;
204 static int videosupport = 0;
206 static int compactheaders = 0; /* send compact sip headers */
208 static int recordhistory = 0; /* Record SIP history. Off by default */
210 static char global_musicclass[MAX_LANGUAGE] = ""; /* Global music on hold class */
211 #define DEFAULT_REALM "asterisk"
212 static char global_realm[AST_MAX_EXTENSION] = DEFAULT_REALM; /* Default realm */
213 static char regcontext[AST_MAX_EXTENSION] = ""; /* Context for auto-extensions */
216 #define DEFAULT_EXPIRY 900
217 static int expiry = DEFAULT_EXPIRY;
219 static struct sched_context *sched;
220 static struct io_context *io;
221 /* The private structures of the sip channels are linked for
222 selecting outgoing channels */
224 #define SIP_MAX_HEADERS 64
225 #define SIP_MAX_LINES 64
229 #define DEC_OUT_USE 2
230 #define INC_OUT_USE 3
232 static struct ast_codec_pref prefs;
235 /* sip_request: The data grabbed from the UDP socket */
237 char *rlPart1; /* SIP Method Name or "SIP/2.0" protocol version */
238 char *rlPart2; /* The Request URI or Response Status */
239 int len; /* Length */
240 int headers; /* # of SIP Headers */
241 char *header[SIP_MAX_HEADERS];
242 int lines; /* SDP Content */
243 char *line[SIP_MAX_LINES];
244 char data[SIP_MAX_PACKET];
250 struct sip_route *next;
256 struct sip_history *next;
259 #define SIP_ALREADYGONE (1 << 0) /* Whether or not we've already been destroyed by our peer */
260 #define SIP_NEEDDESTROY (1 << 1) /* if we need to be destroyed */
261 #define SIP_NOVIDEO (1 << 2) /* Didn't get video in invite, don't offer */
262 #define SIP_RINGING (1 << 3) /* Have sent 180 ringing */
263 #define SIP_PROGRESS_SENT (1 << 4) /* Have sent 183 message progress */
264 #define SIP_NEEDREINVITE (1 << 5) /* Do we need to send another reinvite? */
265 #define SIP_PENDINGBYE (1 << 6) /* Need to send bye after we ack? */
266 #define SIP_GOTREFER (1 << 7) /* Got a refer? */
267 #define SIP_PROMISCREDIR (1 << 8) /* Promiscuous redirection */
268 #define SIP_TRUSTRPID (1 << 9) /* Trust RPID headers? */
269 #define SIP_USEREQPHONE (1 << 10) /* Add user=phone to numeric URI. Default off */
270 #define SIP_REALTIME (1 << 11) /* Flag for realtime users */
271 #define SIP_USECLIENTCODE (1 << 12) /* Trust X-ClientCode info message */
272 #define SIP_OUTGOING (1 << 13) /* Is this an outgoing call? */
273 #define SIP_SELFDESTRUCT (1 << 14)
274 #define SIP_DYNAMIC (1 << 15) /* Is this a dynamic peer? */
275 /* --- Choices for DTMF support in SIP channel */
276 #define SIP_DTMF (3 << 16) /* three settings, uses two bits */
277 #define SIP_DTMF_RFC2833 (0 << 16) /* RTP DTMF */
278 #define SIP_DTMF_INBAND (1 << 16) /* Inband audio, only for ULAW/ALAW */
279 #define SIP_DTMF_INFO (2 << 16) /* SIP Info messages */
281 #define SIP_NAT (3 << 18) /* four settings, uses two bits */
282 #define SIP_NAT_NEVER (0 << 18) /* No nat support */
283 #define SIP_NAT_RFC3581 (1 << 18)
284 #define SIP_NAT_ROUTE (2 << 18)
285 #define SIP_NAT_ALWAYS (3 << 18)
286 /* re-INVITE related settings */
287 #define SIP_REINVITE (3 << 20) /* two bits used */
288 #define SIP_CAN_REINVITE (1 << 20) /* allow peers to be reinvited to send media directly p2p */
289 #define SIP_REINVITE_UPDATE (2 << 20) /* use UPDATE (RFC3311) when reinviting this peer */
290 /* "insecure" settings */
291 #define SIP_INSECURE (3 << 22) /* three settings, uses two bits */
292 #define SIP_SECURE (0 << 22)
293 #define SIP_INSECURE_NORMAL (1 << 22)
294 #define SIP_INSECURE_VERY (2 << 22)
295 /* Sending PROGRESS in-band settings */
296 #define SIP_PROG_INBAND (3 << 24) /* three settings, uses two bits */
297 #define SIP_PROG_INBAND_NEVER (0 << 24)
298 #define SIP_PROG_INBAND_NO (1 << 24)
299 #define SIP_PROG_INBAND_YES (2 << 24)
300 /* Open Settlement Protocol authentication */
301 #define SIP_OSPAUTH (3 << 26) /* three settings, uses two bits */
302 #define SIP_OSPAUTH_NO (0 << 26)
303 #define SIP_OSPAUTH_YES (1 << 26)
304 #define SIP_OSPAUTH_EXCLUSIVE (2 << 26)
306 /* a new page of flags */
307 #define SIP_PAGE2_RTCACHEFRIENDS (1 << 0)
308 #define SIP_PAGE2_RTNOUPDATE (1 << 1)
309 #define SIP_PAGE2_RTAUTOCLEAR (1 << 2)
311 static int global_rtautoclear = 120;
313 /* sip_pvt: PVT structures are used for each SIP conversation, ie. a call */
314 static struct sip_pvt {
315 ast_mutex_t lock; /* Channel private lock */
316 char callid[80]; /* Global CallID */
317 char randdata[80]; /* Random data */
318 struct ast_codec_pref prefs; /* codec prefs */
319 unsigned int ocseq; /* Current outgoing seqno */
320 unsigned int icseq; /* Current incoming seqno */
321 ast_group_t callgroup; /* Call group */
322 ast_group_t pickupgroup; /* Pickup group */
323 int lastinvite; /* Last Cseq of invite */
324 unsigned int flags; /* SIP_ flags */
325 int capability; /* Special capability (codec) */
326 int jointcapability; /* Supported capability at both ends (codecs ) */
327 int peercapability; /* Supported peer capability */
328 int prefcodec; /* Preferred codec (outbound only) */
329 int noncodeccapability;
330 int callingpres; /* Calling presentation */
331 int authtries; /* Times we've tried to authenticate */
332 int expiry; /* How long we take to expire */
333 int branch; /* One random number */
334 int tag; /* Another random number */
335 int sessionid; /* SDP Session ID */
336 int sessionversion; /* SDP Session Version */
337 struct sockaddr_in sa; /* Our peer */
338 struct sockaddr_in redirip; /* Where our RTP should be going if not to us */
339 struct sockaddr_in vredirip; /* Where our Video RTP should be going if not to us */
340 int redircodecs; /* Redirect codecs */
341 struct sockaddr_in recv; /* Received as */
342 struct in_addr ourip; /* Our IP */
343 struct ast_channel *owner; /* Who owns us */
344 char exten[AST_MAX_EXTENSION]; /* Extension where to start */
345 char refer_to[AST_MAX_EXTENSION]; /* Place to store REFER-TO extension */
346 char referred_by[AST_MAX_EXTENSION]; /* Place to store REFERRED-BY extension */
347 char refer_contact[AST_MAX_EXTENSION]; /* Place to store Contact info from a REFER extension */
348 struct sip_pvt *refer_call; /* Call we are referring */
349 struct sip_route *route; /* Head of linked list of routing steps (fm Record-Route) */
350 int route_persistant; /* Is this the "real" route? */
351 char from[256]; /* The From: header */
352 char useragent[256]; /* User agent in SIP request */
353 char context[AST_MAX_EXTENSION]; /* Context for this call */
354 char fromdomain[AST_MAX_EXTENSION]; /* Domain to show in the from field */
355 char fromuser[AST_MAX_EXTENSION]; /* User to show in the user field */
356 char fromname[AST_MAX_EXTENSION]; /* Name to show in the user field */
357 char tohost[AST_MAX_EXTENSION]; /* Host we should put in the "to" field */
358 char language[MAX_LANGUAGE]; /* Default language for this call */
359 char musicclass[MAX_LANGUAGE]; /* Music on Hold class */
360 char rdnis[256]; /* Referring DNIS */
361 char theirtag[256]; /* Their tag */
364 char authname[256]; /* Who we use for authentication */
365 char uri[256]; /* Original requested URI */
366 char okcontacturi[256]; /* URI from the 200 OK on INVITE */
367 char peersecret[256]; /* Password */
368 char peermd5secret[256];
369 char cid_num[256]; /* Caller*ID */
370 char cid_name[256]; /* Caller*ID */
371 char via[256]; /* Via: header */
372 char fullcontact[128]; /* The Contact: that the UA registers with us */
373 char accountcode[20]; /* Account code */
374 char our_contact[256]; /* Our contact header */
375 char realm[256]; /* Authorization realm */
376 char nonce[256]; /* Authorization nonce */
377 char opaque[256]; /* Opaque nonsense */
378 char qop[80]; /* Quality of Protection, since SIP wasn't complicated enough yet. */
379 char domain[256]; /* Authorization domain */
380 char lastmsg[256]; /* Last Message sent/received */
381 int amaflags; /* AMA Flags */
382 int pendinginvite; /* Any pending invite */
384 int osphandle; /* OSP Handle for call */
385 time_t ospstart; /* OSP Start time */
387 struct sip_request initreq; /* Initial request */
389 int maxtime; /* Max time for first response */
390 int initid; /* Auto-congest ID if appropriate */
391 int autokillid; /* Auto-kill ID */
392 time_t lastrtprx; /* Last RTP received */
393 time_t lastrtptx; /* Last RTP sent */
394 int rtptimeout; /* RTP timeout time */
395 int rtpholdtimeout; /* RTP timeout when on hold */
396 int rtpkeepalive; /* Send RTP packets for keepalive */
398 int subscribed; /* Is this call a subscription? */
404 struct sip_peer *peerpoke; /* If this calls is to poke a peer, which one */
405 struct sip_registry *registry; /* If this is a REGISTER call, to which registry */
406 struct ast_rtp *rtp; /* RTP Session */
407 struct ast_rtp *vrtp; /* Video RTP session */
408 struct sip_pkt *packets; /* Packets scheduled for re-transmission */
409 struct sip_history *history; /* History of this SIP dialog */
410 struct ast_variable *vars;
411 struct sip_pvt *next; /* Next call in chain */
412 int onhold; /* call on hold */
415 #define FLAG_RESPONSE (1 << 0)
416 #define FLAG_FATAL (1 << 1)
418 /* sip packet - read in sipsock_read, transmitted in send_request */
420 struct sip_pkt *next; /* Next packet */
421 int retrans; /* Retransmission number */
422 int seqno; /* Sequence number */
423 unsigned int flags; /* non-zero if this is a response packet (e.g. 200 OK) */
424 struct sip_pvt *owner; /* Owner call */
425 int retransid; /* Retransmission ID */
426 int packetlen; /* Length of packet */
430 /* Structure for SIP user data. User's place calls to us */
432 /* Users who can access various contexts */
433 ASTOBJ_COMPONENTS(struct sip_user);
434 char secret[80]; /* Password */
435 char md5secret[80]; /* Password in md5 */
436 char context[80]; /* Default context for incoming calls */
437 char cid_num[80]; /* Caller ID num */
438 char cid_name[80]; /* Caller ID name */
439 char accountcode[20]; /* Account code */
440 char language[MAX_LANGUAGE]; /* Default language for this user */
441 char musicclass[MAX_LANGUAGE]; /* Music on Hold class */
442 char useragent[256]; /* User agent in SIP request */
443 struct ast_codec_pref prefs; /* codec prefs */
444 ast_group_t callgroup; /* Call group */
445 ast_group_t pickupgroup; /* Pickup Group */
446 unsigned int flags; /* SIP_ flags */
447 int amaflags; /* AMA flags for billing */
448 int callingpres; /* Calling id presentation */
449 int capability; /* Codec capability */
454 struct ast_ha *ha; /* ACL setting */
455 struct ast_variable *vars;
458 /* Structure for SIP peer data, we place calls to peers if registred or fixed IP address (host) */
460 ASTOBJ_COMPONENTS(struct sip_peer);
461 char secret[80]; /* Password */
462 char md5secret[80]; /* Password in MD5 */
463 char context[80]; /* Default context for incoming calls */
464 char username[80]; /* Temporary username until registration */
465 char tohost[80]; /* If not dynamic, IP address */
466 char regexten[AST_MAX_EXTENSION]; /* Extension to register (if regcontext is used) */
467 char fromuser[80]; /* From: user when calling this peer */
468 char fromdomain[80]; /* From: domain when calling this peer */
469 char fullcontact[128]; /* Contact registred with us (not in sip.conf) */
470 char cid_num[80]; /* Caller ID num */
471 char cid_name[80]; /* Caller ID name */
472 char mailbox[AST_MAX_EXTENSION]; /* Mailbox setting for MWI checks */
473 char language[MAX_LANGUAGE]; /* Default language for prompts */
474 char musicclass[MAX_LANGUAGE]; /* Music on Hold class */
475 char useragent[256]; /* User agent in SIP request (saved from registration) */
476 struct ast_codec_pref prefs; /* codec prefs */
478 time_t lastmsgcheck; /* Last time we checked for MWI */
479 unsigned int flags; /* SIP_ flags */
480 struct ast_flags flags_page2; /* SIP_PAGE2 flags */
481 int expire; /* Registration expiration */
483 int capability; /* Codec capability */
486 int rtpkeepalive; /* Send RTP packets for keepalive */
487 ast_group_t callgroup; /* Call group */
488 ast_group_t pickupgroup; /* Pickup group */
489 struct sockaddr_in addr; /* IP address of peer */
493 struct sip_pvt *call; /* Call pointer */
494 int pokeexpire; /* When to expire poke (qualify= checking) */
495 int lastms; /* How long last response took (in ms), or -1 for no response */
496 int maxms; /* Max ms we will accept for the host to be up, 0 to not monitor */
497 struct timeval ps; /* Ping send time */
499 struct sockaddr_in defaddr; /* Default IP address, used until registration */
500 struct ast_ha *ha; /* Access control list */
504 AST_MUTEX_DEFINE_STATIC(sip_reload_lock);
505 static int sip_reloading = 0;
507 /* States for outbound registrations (with register= lines in sip.conf */
508 #define REG_STATE_UNREGISTERED 0
509 #define REG_STATE_REGSENT 1
510 #define REG_STATE_AUTHSENT 2
511 #define REG_STATE_REGISTERED 3
512 #define REG_STATE_REJECTED 4
513 #define REG_STATE_TIMEOUT 5
514 #define REG_STATE_NOAUTH 6
517 /* sip_registry: Registrations with other SIP proxies */
518 struct sip_registry {
519 ASTOBJ_COMPONENTS_FULL(struct sip_registry,1,1);
520 int portno; /* Optional port override */
521 char username[80]; /* Who we are registering as */
522 char authuser[80]; /* Who we *authenticate* as */
523 char hostname[80]; /* Domain or host we register to */
524 char secret[80]; /* Password or key name in []'s */
526 char contact[80]; /* Contact extension */
528 int expire; /* Sched ID of expiration */
529 int timeout; /* sched id of sip_reg_timeout */
530 int refresh; /* How often to refresh */
531 struct sip_pvt *call; /* create a sip_pvt structure for each outbound "registration call" in progress */
532 int regstate; /* Registration state (see above) */
533 int callid_valid; /* 0 means we haven't chosen callid for this registry yet. */
534 char callid[80]; /* Global CallID for this registry */
535 unsigned int ocseq; /* Sequence number we got to for REGISTERs for this registry */
536 struct sockaddr_in us; /* Who the server thinks we are */
539 char realm[256]; /* Authorization realm */
540 char nonce[256]; /* Authorization nonce */
541 char domain[256]; /* Authorization domain */
542 char opaque[256]; /* Opaque nonsense */
543 char qop[80]; /* Quality of Protection. */
545 char lastmsg[256]; /* Last Message sent/received */
548 /*--- The user list: Users and friends ---*/
549 static struct ast_user_list {
550 ASTOBJ_CONTAINER_COMPONENTS(struct sip_user);
553 /*--- The peer list: Peers and Friends ---*/
554 static struct ast_peer_list {
555 ASTOBJ_CONTAINER_COMPONENTS(struct sip_peer);
558 /*--- The register list: Other SIP proxys we register with and call ---*/
559 static struct ast_register_list {
560 ASTOBJ_CONTAINER_COMPONENTS(struct sip_registry);
565 static int __sip_do_register(struct sip_registry *r);
567 static int sipsock = -1;
570 static struct sockaddr_in bindaddr;
571 static struct sockaddr_in externip;
572 static char externhost[256] = "";
573 static time_t externexpire = 0;
574 static int externrefresh = 10;
575 static struct ast_ha *localaddr;
577 /* The list of manual NOTIFY types we know how to send */
578 struct ast_config *notify_types;
580 static struct ast_frame *sip_read(struct ast_channel *ast);
581 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req);
582 static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans);
583 static int transmit_response_with_auth(struct sip_pvt *p, char *msg, struct sip_request *req, char *rand, int reliable, char *header);
584 static int transmit_request(struct sip_pvt *p, char *msg, int inc, int reliable, int newbranch);
585 static int transmit_request_with_auth(struct sip_pvt *p, char *msg, int inc, int reliable, int newbranch);
586 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 addsipheaders, int init);
587 static int transmit_reinvite_with_sdp(struct sip_pvt *p);
588 static int transmit_info_with_digit(struct sip_pvt *p, char digit);
589 static int transmit_message_with_text(struct sip_pvt *p, char *text);
590 static int transmit_refer(struct sip_pvt *p, char *dest);
591 static struct sip_peer *temp_peer(char *name);
592 static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader, char *msg, int init);
593 static void free_old_route(struct sip_route *route);
594 static int build_reply_digest(struct sip_pvt *p, char *orig_header, char *digest, int digest_len);
595 static int update_user_counter(struct sip_pvt *fup, int event);
596 static void prune_peers(void);
597 static int sip_do_reload(void);
598 static int expire_register(void *data);
599 static int callevents = 0;
601 /*--- sip_debug_test_addr: See if we pass debug IP filter */
602 static inline int sip_debug_test_addr(struct sockaddr_in *addr)
606 if (debugaddr.sin_addr.s_addr) {
607 if (((ntohs(debugaddr.sin_port) != 0)
608 && (debugaddr.sin_port != addr->sin_port))
609 || (debugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
615 static inline int sip_debug_test_pvt(struct sip_pvt *p)
619 return sip_debug_test_addr(((ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE) ? &p->recv : &p->sa));
623 /*--- __sip_xmit: Transmit SIP message ---*/
624 static int __sip_xmit(struct sip_pvt *p, char *data, int len)
627 char iabuf[INET_ADDRSTRLEN];
628 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
629 res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->recv, sizeof(struct sockaddr_in));
631 res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->sa, sizeof(struct sockaddr_in));
633 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));
638 static void sip_destroy(struct sip_pvt *p);
640 /*--- build_via: Build a Via header for a request ---*/
641 static void build_via(struct sip_pvt *p, char *buf, int len)
643 char iabuf[INET_ADDRSTRLEN];
645 /* z9hG4bK is a magic cookie. See RFC 3261 section 8.1.1.7 */
646 if (ast_test_flag(p, SIP_NAT) != SIP_NAT_NEVER)
647 snprintf(buf, len, "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x;rport", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ourport, p->branch);
648 else /* Work around buggy UNIDEN UIP200 firmware */
649 snprintf(buf, len, "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ourport, p->branch);
652 /*--- ast_sip_ouraddrfor: NAT fix - decide which IP address to use for ASterisk server? ---*/
653 /* Only used for outbound registrations */
654 static int ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us)
657 * Using the localaddr structure built up with localnet statements
658 * apply it to their address to see if we need to substitute our
659 * externip or can get away with our internal bindaddr
661 struct sockaddr_in theirs;
662 theirs.sin_addr = *them;
663 if (localaddr && externip.sin_addr.s_addr &&
664 ast_apply_ha(localaddr, &theirs)) {
665 char iabuf[INET_ADDRSTRLEN];
666 if (externexpire && (time(NULL) >= externexpire)) {
667 struct ast_hostent ahp;
670 externexpire += externrefresh;
671 if ((hp = ast_gethostbyname(externhost, &ahp))) {
672 memcpy(&externip.sin_addr, hp->h_addr, sizeof(externip.sin_addr));
674 ast_log(LOG_NOTICE, "Warning: Re-lookup of '%s' failed!\n", externhost);
676 memcpy(us, &externip.sin_addr, sizeof(struct in_addr));
677 ast_inet_ntoa(iabuf, sizeof(iabuf), *(struct in_addr *)&them->s_addr);
678 ast_log(LOG_DEBUG, "Target address %s is not local, substituting externip\n", iabuf);
680 else if (bindaddr.sin_addr.s_addr)
681 memcpy(us, &bindaddr.sin_addr, sizeof(struct in_addr));
683 return ast_ouraddrfor(them, us);
687 static int append_history(struct sip_pvt *p, char *event, char *data)
689 struct sip_history *hist, *prev;
693 hist = malloc(sizeof(struct sip_history));
695 memset(hist, 0, sizeof(struct sip_history));
696 snprintf(hist->event, sizeof(hist->event), "%-15s %s", event, data);
700 if ((*c == '\r') || (*c == '\n')) {
706 /* Enqueue into history */
719 /*--- retrans_pkt: Retransmit SIP message if no answer ---*/
720 static int retrans_pkt(void *data)
722 struct sip_pkt *pkt=data, *prev, *cur;
724 char iabuf[INET_ADDRSTRLEN];
725 ast_mutex_lock(&pkt->owner->lock);
726 if (pkt->retrans < MAX_RETRANS) {
728 if (sip_debug_test_pvt(pkt->owner)) {
729 if (ast_test_flag(pkt->owner, SIP_NAT) & SIP_NAT_ROUTE)
730 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));
732 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));
734 append_history(pkt->owner, "ReTx", pkt->data);
735 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
738 ast_log(LOG_WARNING, "Maximum retries exceeded on call %s for seqno %d (%s %s)\n", pkt->owner->callid, pkt->seqno, (ast_test_flag(pkt, FLAG_FATAL)) ? "Critical" : "Non-critical", (ast_test_flag(pkt, FLAG_RESPONSE)) ? "Response" : "Request");
739 append_history(pkt->owner, "MaxRetries", (ast_test_flag(pkt, FLAG_FATAL)) ? "(Critical)" : "(Non-critical)");
741 if (ast_test_flag(pkt, FLAG_FATAL)) {
742 while(pkt->owner->owner && ast_mutex_trylock(&pkt->owner->owner->lock)) {
743 ast_mutex_unlock(&pkt->owner->lock);
745 ast_mutex_lock(&pkt->owner->lock);
747 if (pkt->owner->owner) {
748 ast_set_flag(pkt->owner, SIP_ALREADYGONE);
749 ast_queue_hangup(pkt->owner->owner);
750 ast_mutex_unlock(&pkt->owner->owner->lock);
752 /* If no owner, destroy now */
753 ast_set_flag(pkt->owner, SIP_NEEDDESTROY);
756 /* In any case, go ahead and remove the packet */
758 cur = pkt->owner->packets;
767 prev->next = cur->next;
769 pkt->owner->packets = cur->next;
770 ast_mutex_unlock(&pkt->owner->lock);
774 ast_log(LOG_WARNING, "Weird, couldn't find packet owner!\n");
777 ast_mutex_unlock(&pkt->owner->lock);
781 /*--- __sip_reliable_xmit: transmit packet with retransmits ---*/
782 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal)
785 pkt = malloc(sizeof(struct sip_pkt) + len + 1);
788 memset(pkt, 0, sizeof(struct sip_pkt));
789 memcpy(pkt->data, data, len);
790 pkt->packetlen = len;
791 pkt->next = p->packets;
795 pkt->data[len] = '\0';
797 ast_set_flag(pkt, FLAG_FATAL);
798 /* Schedule retransmission */
799 pkt->retransid = ast_sched_add(sched, DEFAULT_RETRANS, retrans_pkt, pkt);
800 pkt->next = p->packets;
802 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
803 if (!strncasecmp(pkt->data, "INVITE", 6)) {
804 /* Note this is a pending invite */
805 p->pendinginvite = seqno;
810 /*--- __sip_autodestruct: Kill a call (called by scheduler) ---*/
811 static int __sip_autodestruct(void *data)
813 struct sip_pvt *p = data;
815 ast_log(LOG_DEBUG, "Auto destroying call '%s'\n", p->callid);
816 append_history(p, "AutoDestroy", "");
818 ast_log(LOG_WARNING, "Autodestruct on call '%s' with owner in place\n", p->callid);
819 ast_queue_hangup(p->owner);
826 /*--- sip_scheddestroy: Schedule destruction of SIP call ---*/
827 static int sip_scheddestroy(struct sip_pvt *p, int ms)
830 if (sip_debug_test_pvt(p))
831 ast_verbose("Scheduling destruction of call '%s' in %d ms\n", p->callid, ms);
833 snprintf(tmp, sizeof(tmp), "%d ms", ms);
834 append_history(p, "SchedDestroy", tmp);
836 if (p->autokillid > -1)
837 ast_sched_del(sched, p->autokillid);
838 p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, p);
842 /*--- sip_cancel_destroy: Cancel destruction of SIP call ---*/
843 static int sip_cancel_destroy(struct sip_pvt *p)
845 if (p->autokillid > -1)
846 ast_sched_del(sched, p->autokillid);
847 append_history(p, "CancelDestroy", "");
852 /*--- __sip_ack: Acknowledges receipt of a packet and stops retransmission ---*/
853 static int __sip_ack(struct sip_pvt *p, int seqno, int resp, const char *msg)
855 struct sip_pkt *cur, *prev = NULL;
858 /* Just in case... */
859 if (!msg) msg = "___NEVER___";
862 if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
863 ((ast_test_flag(cur, FLAG_RESPONSE)) ||
864 (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
865 if (!resp && (seqno == p->pendinginvite)) {
866 ast_log(LOG_DEBUG, "Acked pending invite %d\n", p->pendinginvite);
867 p->pendinginvite = 0;
870 /* this is our baby */
872 prev->next = cur->next;
874 p->packets = cur->next;
875 if (cur->retransid > -1)
876 ast_sched_del(sched, cur->retransid);
884 ast_log(LOG_DEBUG, "Stopping retransmission on '%s' of %s %d: %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
888 /* Pretend to ack all packets */
889 static int __sip_pretend_ack(struct sip_pvt *p)
892 __sip_ack(p, p->packets->seqno, (ast_test_flag(p->packets, FLAG_RESPONSE)), p->packets->data);
897 /*--- __sip_semi_ack: Acks receipt of packet, keep it around (used for provisional responses) ---*/
898 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp, const char *msg)
904 if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
905 ((ast_test_flag(cur, FLAG_RESPONSE)) ||
906 (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
907 /* this is our baby */
908 if (cur->retransid > -1)
909 ast_sched_del(sched, cur->retransid);
916 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");
920 static void parse(struct sip_request *req);
921 static char *get_header(struct sip_request *req, char *name);
922 static void copy_request(struct sip_request *dst,struct sip_request *src);
924 static void parse_copy(struct sip_request *dst, struct sip_request *src)
926 memset(dst, 0, sizeof(*dst));
927 memcpy(dst->data, src->data, sizeof(dst->data));
931 /*--- send_response: Transmit response on SIP request---*/
932 static int send_response(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
935 char iabuf[INET_ADDRSTRLEN];
936 struct sip_request tmp;
938 if (sip_debug_test_pvt(p)) {
939 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
940 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));
942 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));
946 parse_copy(&tmp, req);
947 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
948 append_history(p, "TxRespRel", tmpmsg);
950 res = __sip_reliable_xmit(p, seqno, 1, req->data, req->len, (reliable > 1));
953 parse_copy(&tmp, req);
954 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
955 append_history(p, "TxResp", tmpmsg);
957 res = __sip_xmit(p, req->data, req->len);
964 /*--- send_request: Send SIP Request to the other part of the dialogue ---*/
965 static int send_request(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
968 char iabuf[INET_ADDRSTRLEN];
969 struct sip_request tmp;
971 if (sip_debug_test_pvt(p)) {
972 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
973 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));
975 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));
979 parse_copy(&tmp, req);
980 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
981 append_history(p, "TxReqRel", tmpmsg);
983 res = __sip_reliable_xmit(p, seqno, 0, req->data, req->len, (reliable > 1));
986 parse_copy(&tmp, req);
987 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
988 append_history(p, "TxReq", tmpmsg);
990 res = __sip_xmit(p, req->data, req->len);
995 /*--- url_decode: Decode SIP URL ---*/
996 static void url_decode(char *s)
1003 if (strlen(s) > 2) {
1004 if (sscanf(s + 1, "%2x", &tmp) == 1) {
1006 s += 2; /* Will be incremented once more when we break out */
1010 /* Fall through if something wasn't right with the formatting */
1020 /*--- ditch_braces: Pick out text in braces from character string ---*/
1021 static char *ditch_braces(char *tmp)
1026 if ((q = strchr(tmp, '"')) ) {
1028 if ((q = strchr(c, '"')) )
1031 ast_log(LOG_WARNING, "No closing quote in '%s'\n", tmp);
1035 if ((n = strchr(c, '<')) ) {
1037 while(*c && *c != '>') c++;
1039 ast_log(LOG_WARNING, "No closing brace in '%s'\n", tmp);
1048 /*--- sip_sendtext: Send SIP MESSAGE text within a call ---*/
1049 /* Called from PBX core text message functions */
1050 static int sip_sendtext(struct ast_channel *ast, char *text)
1052 struct sip_pvt *p = ast->pvt->pvt;
1053 int debug=sip_debug_test_pvt(p);
1056 ast_verbose("Sending text %s on %s\n", text, ast->name);
1059 if (!text || ast_strlen_zero(text))
1062 ast_verbose("Really sending text %s on %s\n", text, ast->name);
1063 transmit_message_with_text(p, text);
1067 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, const char *username, int expirey)
1071 char regseconds[20];
1076 snprintf(regseconds, sizeof(regseconds), "%ld", nowtime);
1077 ast_inet_ntoa(ipaddr, sizeof(ipaddr), sin->sin_addr);
1078 snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
1079 ast_update_realtime("sipfriends", "name", peername, "ipaddr", ipaddr, "port", port, "regseconds", regseconds, "username", username, NULL);
1082 static void register_peer_exten(struct sip_peer *peer, int onoff)
1084 unsigned char multi[256]="";
1085 char *stringp, *ext;
1086 if (!ast_strlen_zero(regcontext)) {
1087 strncpy(multi, ast_strlen_zero(peer->regexten) ? peer->name : peer->regexten, sizeof(multi) - 1);
1089 while((ext = strsep(&stringp, "&"))) {
1091 ast_add_extension(regcontext, 1, ext, 1, NULL, NULL, "Noop", strdup(peer->name), free, channeltype);
1093 ast_context_remove_extension(regcontext, ext, 1, NULL);
1098 static void sip_destroy_peer(struct sip_peer *peer)
1100 /* Delete it, it needs to disappear */
1102 sip_destroy(peer->call);
1103 if (peer->expire > -1)
1104 ast_sched_del(sched, peer->expire);
1105 if (peer->pokeexpire > -1)
1106 ast_sched_del(sched, peer->pokeexpire);
1107 register_peer_exten(peer, 0);
1108 ast_free_ha(peer->ha);
1109 if (ast_test_flag(peer, SIP_SELFDESTRUCT))
1111 else if (ast_test_flag(peer, SIP_REALTIME))
1118 /*--- update_peer: Update peer data in database (if used) ---*/
1119 static void update_peer(struct sip_peer *p, int expiry)
1121 if (!ast_test_flag((&global_flags_page2), SIP_PAGE2_RTNOUPDATE) &&
1122 (ast_test_flag(p, SIP_REALTIME) ||
1123 ast_test_flag(&(p->flags_page2), SIP_PAGE2_RTCACHEFRIENDS)))
1124 realtime_update_peer(p->name, &p->addr, p->username, expiry);
1127 static struct sip_peer *build_peer(const char *name, struct ast_variable *v, int realtime);
1129 static struct sip_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
1131 struct sip_peer *peer=NULL;
1132 struct ast_variable *var;
1133 struct ast_variable *tmp;
1136 var = ast_load_realtime("sipfriends", "name", peername, NULL);
1140 ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr);
1141 var = ast_load_realtime("sipfriends", "ipaddr", iabuf, NULL);
1150 if (!strcasecmp(tmp->name, "type") &&
1151 !strcasecmp(tmp->value, "user")) {
1152 ast_variables_destroy(var);
1158 peer = build_peer(peername, var, ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS) ? 0 : 1);
1160 if(ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS)) {
1161 ast_copy_flags((&peer->flags_page2),(&global_flags_page2), SIP_PAGE2_RTAUTOCLEAR|SIP_PAGE2_RTCACHEFRIENDS);
1162 if(ast_test_flag((&global_flags_page2), SIP_PAGE2_RTAUTOCLEAR)) {
1163 peer->expire = ast_sched_add(sched, (global_rtautoclear) * 1000, expire_register, (void *)peer);
1165 ASTOBJ_CONTAINER_LINK(&peerl,peer);
1167 ast_set_flag(peer, SIP_REALTIME);
1170 ast_variables_destroy(var);
1174 static int sip_addrcmp(char *name, struct sockaddr_in *sin)
1176 /* We know name is the first field, so we can cast */
1177 struct sip_peer *p = (struct sip_peer *)name;
1178 return !(!inaddrcmp(&p->addr, sin) ||
1179 (ast_test_flag(p, SIP_INSECURE) &&
1180 (p->addr.sin_addr.s_addr == sin->sin_addr.s_addr)));
1183 /*--- find_peer: Locate peer by name or ip address */
1184 static struct sip_peer *find_peer(const char *peer, struct sockaddr_in *sin, int realtime)
1186 struct sip_peer *p = NULL;
1189 p = ASTOBJ_CONTAINER_FIND(&peerl,peer);
1191 p = ASTOBJ_CONTAINER_FIND_FULL(&peerl,sin,name,sip_addr_hashfunc,1,sip_addrcmp);
1193 if (!p && realtime) {
1194 p = realtime_peer(peer, sin);
1200 static void sip_destroy_user(struct sip_user *user)
1202 ast_free_ha(user->ha);
1204 ast_variables_destroy(user->vars);
1207 if (ast_test_flag(user, SIP_REALTIME))
1214 static struct sip_user *build_user(const char *name, struct ast_variable *v, int realtime);
1215 static struct sip_user *realtime_user(const char *username)
1217 struct ast_variable *var;
1218 struct ast_variable *tmp;
1219 struct sip_user *user = NULL;
1221 var = ast_load_realtime("sipfriends", "name", username, NULL);
1228 if (!strcasecmp(tmp->name, "type") &&
1229 !strcasecmp(tmp->value, "peer")) {
1230 ast_variables_destroy(var);
1238 user = build_user(username, var, !ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS));
1241 /* Add some finishing touches, addresses, etc */
1242 if(ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS)) {
1245 ASTOBJ_CONTAINER_LINK(&userl,user);
1247 /* Move counter from s to r... */
1250 ast_set_flag(user, SIP_REALTIME);
1253 ast_variables_destroy(var);
1257 /*--- find_user: Locate user by name */
1258 static struct sip_user *find_user(const char *name)
1260 struct sip_user *u = NULL;
1261 u = ASTOBJ_CONTAINER_FIND(&userl,name);
1263 u = realtime_user(name);
1268 /*--- create_addr: create address structure from peer definition ---*/
1269 /* Or, if peer not found, find it in the global DNS */
1270 /* returns TRUE on failure, FALSE on success */
1271 static int create_addr(struct sip_pvt *r, char *opeer)
1274 struct ast_hostent ahp;
1280 char host[256], *hostn;
1283 strncpy(peer, opeer, sizeof(peer) - 1);
1284 port = strchr(peer, ':');
1289 r->sa.sin_family = AF_INET;
1290 p = find_peer(peer, NULL, 1);
1294 ast_copy_flags(r, p, SIP_PROMISCREDIR | SIP_USEREQPHONE | SIP_DTMF | SIP_NAT | SIP_REINVITE | SIP_INSECURE);
1295 r->capability = p->capability;
1297 ast_log(LOG_DEBUG, "Setting NAT on RTP to %d\n", (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1298 ast_rtp_setnat(r->rtp, (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1301 ast_log(LOG_DEBUG, "Setting NAT on VRTP to %d\n", (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1302 ast_rtp_setnat(r->vrtp, (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1304 strncpy(r->peername, p->username, sizeof(r->peername)-1);
1305 strncpy(r->authname, p->username, sizeof(r->authname)-1);
1306 strncpy(r->peersecret, p->secret, sizeof(r->peersecret)-1);
1307 strncpy(r->peermd5secret, p->md5secret, sizeof(r->peermd5secret)-1);
1308 strncpy(r->username, p->username, sizeof(r->username)-1);
1309 strncpy(r->tohost, p->tohost, sizeof(r->tohost)-1);
1310 strncpy(r->fullcontact, p->fullcontact, sizeof(r->fullcontact)-1);
1311 if (!r->initreq.headers && !ast_strlen_zero(p->fromdomain)) {
1312 if ((callhost = strchr(r->callid, '@'))) {
1313 strncpy(callhost + 1, p->fromdomain, sizeof(r->callid) - (callhost - r->callid) - 2);
1316 if (ast_strlen_zero(r->tohost)) {
1317 if (p->addr.sin_addr.s_addr)
1318 ast_inet_ntoa(r->tohost, sizeof(r->tohost), p->addr.sin_addr);
1320 ast_inet_ntoa(r->tohost, sizeof(r->tohost), p->defaddr.sin_addr);
1322 if (!ast_strlen_zero(p->fromdomain))
1323 strncpy(r->fromdomain, p->fromdomain, sizeof(r->fromdomain)-1);
1324 if (!ast_strlen_zero(p->fromuser))
1325 strncpy(r->fromuser, p->fromuser, sizeof(r->fromuser)-1);
1326 r->maxtime = p->maxms;
1327 r->callgroup = p->callgroup;
1328 r->pickupgroup = p->pickupgroup;
1329 if (ast_test_flag(r, SIP_DTMF) == SIP_DTMF_RFC2833)
1330 r->noncodeccapability |= AST_RTP_DTMF;
1332 r->noncodeccapability &= ~AST_RTP_DTMF;
1333 strncpy(r->context, p->context,sizeof(r->context)-1);
1334 if ((p->addr.sin_addr.s_addr || p->defaddr.sin_addr.s_addr) &&
1335 (!p->maxms || ((p->lastms >= 0) && (p->lastms <= p->maxms)))) {
1336 if (p->addr.sin_addr.s_addr) {
1337 r->sa.sin_addr = p->addr.sin_addr;
1338 r->sa.sin_port = p->addr.sin_port;
1340 r->sa.sin_addr = p->defaddr.sin_addr;
1341 r->sa.sin_port = p->defaddr.sin_port;
1343 memcpy(&r->recv, &r->sa, sizeof(r->recv));
1345 ASTOBJ_UNREF(p,sip_destroy_peer);
1351 portno = atoi(port);
1353 portno = DEFAULT_SIP_PORT;
1358 snprintf(service, sizeof(service), "_sip._udp.%s", peer);
1359 ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service);
1365 hp = ast_gethostbyname(hostn, &ahp);
1367 strncpy(r->tohost, peer, sizeof(r->tohost) - 1);
1368 memcpy(&r->sa.sin_addr, hp->h_addr, sizeof(r->sa.sin_addr));
1369 r->sa.sin_port = htons(portno);
1370 memcpy(&r->recv, &r->sa, sizeof(r->recv));
1373 ast_log(LOG_WARNING, "No such host: %s\n", peer);
1379 ASTOBJ_UNREF(p,sip_destroy_peer);
1384 /*--- auto_congest: Scheduled congestion on a call ---*/
1385 static int auto_congest(void *nothing)
1387 struct sip_pvt *p = nothing;
1388 ast_mutex_lock(&p->lock);
1391 if (!ast_mutex_trylock(&p->owner->lock)) {
1392 ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name);
1393 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
1394 ast_mutex_unlock(&p->owner->lock);
1397 ast_mutex_unlock(&p->lock);
1404 /*--- sip_call: Initiate SIP call from PBX ---*/
1405 /* used from the dial() application */
1406 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
1410 char *vxml_url = NULL;
1411 char *distinctive_ring = NULL;
1412 char *osptoken = NULL;
1414 char *osphandle = NULL;
1416 struct varshead *headp;
1417 struct ast_var_t *current;
1418 int addsipheaders = 0;
1421 if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
1422 ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
1425 /* Check whether there is vxml_url, distinctive ring variables */
1427 headp=&ast->varshead;
1428 AST_LIST_TRAVERSE(headp,current,entries) {
1429 /* Check whether there is a VXML_URL variable */
1430 if (!vxml_url && !strcasecmp(ast_var_name(current),"VXML_URL")) {
1431 vxml_url = ast_var_value(current);
1432 } else if (!distinctive_ring && !strcasecmp(ast_var_name(current),"ALERT_INFO")) {
1433 /* Check whether there is a ALERT_INFO variable */
1434 distinctive_ring = ast_var_value(current);
1435 } else if (!addsipheaders && !strncasecmp(ast_var_name(current),"SIPADDHEADER",strlen("SIPADDHEADER"))) {
1436 /* Check whether there is a variable with a name starting with SIPADDHEADER */
1442 else if (!osptoken && !strcasecmp(ast_var_name(current), "OSPTOKEN")) {
1443 osptoken = ast_var_value(current);
1444 } else if (!osphandle && !strcasecmp(ast_var_name(current), "OSPHANDLE")) {
1445 osphandle = ast_var_value(current);
1451 ast_set_flag(p, SIP_OUTGOING);
1453 if (!osptoken || !osphandle || (sscanf(osphandle, "%i", &p->osphandle) != 1)) {
1454 /* Force Disable OSP support */
1455 ast_log(LOG_DEBUG, "Disabling OSP support for this call. osptoken = %s, osphandle = %s\n", osptoken, osphandle);
1461 ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);
1462 res = update_user_counter(p,INC_OUT_USE);
1464 p->callingpres = ast->cid.cid_pres;
1465 p->jointcapability = p->capability;
1466 transmit_invite(p, "INVITE", 1, NULL, NULL, vxml_url,distinctive_ring, osptoken, addsipheaders, 1);
1468 /* Initialize auto-congest time */
1469 p->initid = ast_sched_add(sched, p->maxtime * 4, auto_congest, p);
1475 static void sip_registry_destroy(struct sip_registry *reg)
1479 /* Clear registry before destroying to ensure
1480 we don't get reentered trying to grab the registry lock */
1481 reg->call->registry = NULL;
1482 sip_destroy(reg->call);
1484 if (reg->expire > -1)
1485 ast_sched_del(sched, reg->expire);
1486 if (reg->timeout > -1)
1487 ast_sched_del(sched, reg->timeout);
1493 /*--- __sip_destroy: Execute destrucion of call structure, release memory---*/
1494 static void __sip_destroy(struct sip_pvt *p, int lockowner)
1496 struct sip_pvt *cur, *prev = NULL;
1498 struct sip_history *hist;
1500 if (sip_debug_test_pvt(p))
1501 ast_verbose("Destroying call '%s'\n", p->callid);
1502 if (p->stateid > -1)
1503 ast_extension_state_del(p->stateid, NULL);
1505 ast_sched_del(sched, p->initid);
1506 if (p->autokillid > -1)
1507 ast_sched_del(sched, p->autokillid);
1510 ast_rtp_destroy(p->rtp);
1513 ast_rtp_destroy(p->vrtp);
1516 free_old_route(p->route);
1520 if (p->registry->call == p)
1521 p->registry->call = NULL;
1522 ASTOBJ_UNREF(p->registry,sip_registry_destroy);
1524 /* Unlink us from the owner if we have one */
1527 ast_mutex_lock(&p->owner->lock);
1528 ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
1529 p->owner->pvt->pvt = NULL;
1531 ast_mutex_unlock(&p->owner->lock);
1536 p->history = p->history->next;
1543 prev->next = cur->next;
1552 ast_log(LOG_WARNING, "%p is not in list?!?! \n", cur);
1555 ast_sched_del(sched, p->initid);
1556 while((cp = p->packets)) {
1557 p->packets = p->packets->next;
1558 if (cp->retransid > -1)
1559 ast_sched_del(sched, cp->retransid);
1562 ast_mutex_destroy(&p->lock);
1564 ast_variables_destroy(p->vars);
1571 /*--- update_user_counter: Handle incominglimit and outgoinglimit for SIP users ---*/
1572 /* Note: This is going to be replaced by app_groupcount */
1573 static int update_user_counter(struct sip_pvt *fup, int event)
1575 char name[256] = "";
1577 strncpy(name, fup->username, sizeof(name) - 1);
1578 u = find_user(name);
1580 ast_log(LOG_DEBUG, "%s is not a local user\n", name);
1584 /* incoming and outgoing affects the inUse counter */
1587 if ( u->inUse > 0 ) {
1595 if (u->incominglimit > 0 ) {
1596 if (u->inUse >= u->incominglimit) {
1597 ast_log(LOG_ERROR, "Call from user '%s' rejected due to usage limit of %d\n", u->name, u->incominglimit);
1598 /* inc inUse as well */
1599 if ( event == INC_OUT_USE ) {
1602 ASTOBJ_UNREF(u,sip_destroy_user);
1607 ast_log(LOG_DEBUG, "Call from user '%s' is %d out of %d\n", u->name, u->inUse, u->incominglimit);
1609 /* we don't use these anymore
1611 if ( u->outUse > 0 ) {
1618 if ( u->outgoinglimit > 0 ) {
1619 if ( u->outUse >= u->outgoinglimit ) {
1620 ast_log(LOG_ERROR, "Outgoing call from user '%s' rejected due to usage limit of %d\n", u->name, u->outgoinglimit);
1621 ast_mutex_unlock(&userl.lock);
1632 ast_log(LOG_ERROR, "update_user_counter(%s,%d) called with no event!\n",u->name,event);
1634 ASTOBJ_UNREF(u,sip_destroy_user);
1638 /*--- sip_destroy: Destroy SIP call structure ---*/
1639 static void sip_destroy(struct sip_pvt *p)
1641 ast_mutex_lock(&iflock);
1642 __sip_destroy(p, 1);
1643 ast_mutex_unlock(&iflock);
1647 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal);
1649 static int hangup_sip2cause(int cause)
1651 /* Possible values from causes.h
1652 AST_CAUSE_NOTDEFINED AST_CAUSE_NORMAL AST_CAUSE_BUSY
1653 AST_CAUSE_FAILURE AST_CAUSE_CONGESTION AST_CAUSE_UNALLOCATED
1657 case 404: /* Not found */
1658 return AST_CAUSE_UNALLOCATED;
1659 case 483: /* Too many hops */
1660 return AST_CAUSE_FAILURE;
1662 return AST_CAUSE_BUSY;
1664 return AST_CAUSE_NORMAL;
1670 static char *hangup_cause2sip(int cause)
1674 case AST_CAUSE_FAILURE:
1675 return "500 Server internal failure";
1676 case AST_CAUSE_CONGESTION:
1677 return "503 Service Unavailable";
1678 case AST_CAUSE_BUSY:
1687 /*--- sip_hangup: Hangup SIP call */
1688 static int sip_hangup(struct ast_channel *ast)
1690 struct sip_pvt *p = ast->pvt->pvt;
1692 struct ast_flags locflags = {0};
1694 ast_log(LOG_DEBUG, "sip_hangup(%s)\n", ast->name);
1695 if (!ast->pvt->pvt) {
1696 ast_log(LOG_DEBUG, "Asked to hangup channel not connected\n");
1699 ast_mutex_lock(&p->lock);
1701 if ((p->osphandle > -1) && (ast->_state == AST_STATE_UP)) {
1702 ast_osp_terminate(p->osphandle, AST_CAUSE_NORMAL, p->ospstart, time(NULL) - p->ospstart);
1705 if (ast_test_flag(p, SIP_OUTGOING)) {
1706 ast_log(LOG_DEBUG, "update_user_counter(%s) - decrement outUse counter\n", p->username);
1707 update_user_counter(p, DEC_OUT_USE);
1709 ast_log(LOG_DEBUG, "update_user_counter(%s) - decrement inUse counter\n", p->username);
1710 update_user_counter(p, DEC_IN_USE);
1712 /* Determine how to disconnect */
1713 if (p->owner != ast) {
1714 ast_log(LOG_WARNING, "Huh? We aren't the owner?\n");
1715 ast_mutex_unlock(&p->lock);
1718 if (!ast || (ast->_state != AST_STATE_UP))
1723 ast_dsp_free(p->vad);
1726 ast->pvt->pvt = NULL;
1728 ast_mutex_lock(&usecnt_lock);
1730 ast_mutex_unlock(&usecnt_lock);
1731 ast_update_use_count();
1733 ast_set_flag(&locflags, SIP_NEEDDESTROY);
1734 /* Start the process if it's not already started */
1735 if (!ast_test_flag(p, SIP_ALREADYGONE) && !ast_strlen_zero(p->initreq.data)) {
1737 if (ast_test_flag(p, SIP_OUTGOING)) {
1738 transmit_request_with_auth(p, "CANCEL", p->ocseq, 1, 0);
1739 /* Actually don't destroy us yet, wait for the 487 on our original
1740 INVITE, but do set an autodestruct just in case we never get it. */
1741 ast_clear_flag(&locflags, SIP_NEEDDESTROY);
1742 sip_scheddestroy(p, 15000);
1743 if ( p->initid != -1 ) {
1744 /* channel still up - reverse dec of inUse counter
1745 only if the channel is not auto-congested */
1746 if (ast_test_flag(p, SIP_OUTGOING)) {
1747 update_user_counter(p, INC_OUT_USE);
1750 update_user_counter(p, INC_IN_USE);
1755 if (ast->hangupcause && ((res = hangup_cause2sip(ast->hangupcause)))) {
1756 transmit_response_reliable(p, res, &p->initreq, 1);
1758 transmit_response_reliable(p, "403 Forbidden", &p->initreq, 1);
1761 if (!p->pendinginvite) {
1763 transmit_request_with_auth(p, "BYE", 0, 1, 1);
1765 /* Note we will need a BYE when this all settles out
1766 but we can't send one while we have "INVITE" outstanding. */
1767 ast_set_flag(p, SIP_PENDINGBYE);
1768 ast_clear_flag(p, SIP_NEEDREINVITE);
1772 ast_copy_flags(p, (&locflags), SIP_NEEDDESTROY);
1773 ast_mutex_unlock(&p->lock);
1777 /*--- sip_answer: Answer SIP call , send 200 OK on Invite */
1778 static int sip_answer(struct ast_channel *ast)
1782 struct sip_pvt *p = ast->pvt->pvt;
1784 ast_mutex_lock(&p->lock);
1785 if (ast->_state != AST_STATE_UP) {
1790 codec=pbx_builtin_getvar_helper(p->owner,"SIP_CODEC");
1792 fmt=ast_getformatbyname(codec);
1794 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC) variable\n",codec);
1795 if (p->jointcapability & fmt) {
1796 p->jointcapability &= fmt;
1797 p->capability &= fmt;
1799 ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because it is not shared by both ends.\n");
1800 } else ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n",codec);
1803 ast_setstate(ast, AST_STATE_UP);
1805 ast_log(LOG_DEBUG, "sip_answer(%s)\n", ast->name);
1806 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, 1);
1808 ast_mutex_unlock(&p->lock);
1812 /*--- sip_write: Send response, support audio media ---*/
1813 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
1815 struct sip_pvt *p = ast->pvt->pvt;
1817 if (frame->frametype == AST_FRAME_VOICE) {
1818 if (!(frame->subclass & ast->nativeformats)) {
1819 ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
1820 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
1824 ast_mutex_lock(&p->lock);
1826 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
1827 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1828 ast_set_flag(p, SIP_PROGRESS_SENT);
1830 time(&p->lastrtptx);
1831 res = ast_rtp_write(p->rtp, frame);
1833 ast_mutex_unlock(&p->lock);
1835 } else if (frame->frametype == AST_FRAME_VIDEO) {
1837 ast_mutex_lock(&p->lock);
1839 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
1840 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1841 ast_set_flag(p, SIP_PROGRESS_SENT);
1843 time(&p->lastrtptx);
1844 res = ast_rtp_write(p->vrtp, frame);
1846 ast_mutex_unlock(&p->lock);
1848 } else if (frame->frametype == AST_FRAME_IMAGE) {
1851 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
1858 /*--- sip_fixup: Fix up a channel: If a channel is consumed, this is called.
1859 Basically update any ->owner links ----*/
1860 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
1862 struct sip_pvt *p = newchan->pvt->pvt;
1863 ast_mutex_lock(&p->lock);
1864 if (p->owner != oldchan) {
1865 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
1866 ast_mutex_unlock(&p->lock);
1870 ast_mutex_unlock(&p->lock);
1874 /*--- sip_senddigit: Send DTMF character on SIP channel */
1875 /* within one call, we're able to transmit in many methods simultaneously */
1876 static int sip_senddigit(struct ast_channel *ast, char digit)
1878 struct sip_pvt *p = ast->pvt->pvt;
1880 ast_mutex_lock(&p->lock);
1881 switch (ast_test_flag(p, SIP_DTMF)) {
1883 transmit_info_with_digit(p, digit);
1885 case SIP_DTMF_RFC2833:
1887 ast_rtp_senddigit(p->rtp, digit);
1889 case SIP_DTMF_INBAND:
1893 ast_mutex_unlock(&p->lock);
1898 /*--- sip_transfer: Transfer SIP call */
1899 static int sip_transfer(struct ast_channel *ast, char *dest)
1901 struct sip_pvt *p = ast->pvt->pvt;
1903 ast_mutex_lock(&p->lock);
1904 res = transmit_refer(p, dest);
1905 ast_mutex_unlock(&p->lock);
1909 /*--- sip_indicate: Play indication to user */
1910 /* With SIP a lot of indications is sent as messages, letting the device play
1911 the indication - busy signal, congestion etc */
1912 static int sip_indicate(struct ast_channel *ast, int condition)
1914 struct sip_pvt *p = ast->pvt->pvt;
1917 ast_mutex_lock(&p->lock);
1919 case AST_CONTROL_RINGING:
1920 if (ast->_state == AST_STATE_RING) {
1921 if (!ast_test_flag(p, SIP_PROGRESS_SENT) ||
1922 (ast_test_flag(p, SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER)) {
1923 /* Send 180 ringing if out-of-band seems reasonable */
1924 transmit_response(p, "180 Ringing", &p->initreq);
1925 ast_set_flag(p, SIP_RINGING);
1926 if (ast_test_flag(p, SIP_PROG_INBAND) != SIP_PROG_INBAND_YES)
1929 /* Well, if it's not reasonable, just send in-band */
1934 case AST_CONTROL_BUSY:
1935 if (ast->_state != AST_STATE_UP) {
1936 transmit_response(p, "486 Busy Here", &p->initreq);
1937 ast_set_flag(p, SIP_ALREADYGONE);
1938 ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1943 case AST_CONTROL_CONGESTION:
1944 if (ast->_state != AST_STATE_UP) {
1945 transmit_response(p, "503 Service Unavailable", &p->initreq);
1946 ast_set_flag(p, SIP_ALREADYGONE);
1947 ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1952 case AST_CONTROL_PROGRESS:
1953 case AST_CONTROL_PROCEEDING:
1954 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
1955 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1956 ast_set_flag(p, SIP_PROGRESS_SENT);
1965 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
1969 ast_mutex_unlock(&p->lock);
1975 /*--- sip_new: Initiate a call in the SIP channel */
1976 /* called from sip_request_call (calls from the pbx ) */
1977 static struct ast_channel *sip_new(struct sip_pvt *i, int state, char *title)
1979 struct ast_channel *tmp;
1980 struct ast_variable *v = NULL;
1983 ast_mutex_unlock(&i->lock);
1984 /* Don't hold a sip pvt lock while we allocate a channel */
1985 tmp = ast_channel_alloc(1);
1986 ast_mutex_lock(&i->lock);
1988 /* Select our native format based on codec preference until we receive
1989 something from another device to the contrary. */
1990 ast_mutex_lock(&i->lock);
1991 if (i->jointcapability)
1992 tmp->nativeformats = ast_codec_choose(&i->prefs, i->jointcapability, 1);
1993 else if (i->capability)
1994 tmp->nativeformats = ast_codec_choose(&i->prefs, i->capability, 1);
1996 tmp->nativeformats = ast_codec_choose(&i->prefs, global_capability, 1);
1997 ast_mutex_unlock(&i->lock);
1998 fmt = ast_best_codec(tmp->nativeformats);
2000 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%04x", title, rand() & 0xffff);
2002 if (strchr(i->fromdomain,':'))
2004 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", strchr(i->fromdomain,':')+1, (int)(long)(i));
2008 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", i->fromdomain, (int)(long)(i));
2010 tmp->type = channeltype;
2011 if (ast_test_flag(i, SIP_DTMF) == SIP_DTMF_INBAND) {
2012 i->vad = ast_dsp_new();
2013 ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
2015 ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
2017 tmp->fds[0] = ast_rtp_fd(i->rtp);
2018 tmp->fds[1] = ast_rtcp_fd(i->rtp);
2020 tmp->fds[2] = ast_rtp_fd(i->vrtp);
2021 tmp->fds[3] = ast_rtcp_fd(i->vrtp);
2023 if (state == AST_STATE_RING)
2025 tmp->adsicpe = AST_ADSI_UNAVAILABLE;
2026 tmp->writeformat = fmt;
2027 tmp->pvt->rawwriteformat = fmt;
2028 tmp->readformat = fmt;
2029 tmp->pvt->rawreadformat = fmt;
2031 tmp->pvt->send_text = sip_sendtext;
2032 tmp->pvt->call = sip_call;
2033 tmp->pvt->hangup = sip_hangup;
2034 tmp->pvt->answer = sip_answer;
2035 tmp->pvt->read = sip_read;
2036 tmp->pvt->write = sip_write;
2037 tmp->pvt->write_video = sip_write;
2038 tmp->pvt->indicate = sip_indicate;
2039 tmp->pvt->transfer = sip_transfer;
2040 tmp->pvt->fixup = sip_fixup;
2041 tmp->pvt->send_digit = sip_senddigit;
2043 tmp->pvt->bridge = ast_rtp_bridge;
2045 tmp->callgroup = i->callgroup;
2046 tmp->pickupgroup = i->pickupgroup;
2047 tmp->cid.cid_pres = i->callingpres;
2048 if (!ast_strlen_zero(i->accountcode))
2049 strncpy(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode)-1);
2051 tmp->amaflags = i->amaflags;
2052 if (!ast_strlen_zero(i->language))
2053 strncpy(tmp->language, i->language, sizeof(tmp->language)-1);
2054 if (!ast_strlen_zero(i->musicclass))
2055 strncpy(tmp->musicclass, i->musicclass, sizeof(tmp->musicclass)-1);
2057 ast_mutex_lock(&usecnt_lock);
2059 ast_mutex_unlock(&usecnt_lock);
2060 strncpy(tmp->context, i->context, sizeof(tmp->context)-1);
2061 strncpy(tmp->exten, i->exten, sizeof(tmp->exten)-1);
2062 if (!ast_strlen_zero(i->cid_num))
2063 tmp->cid.cid_num = strdup(i->cid_num);
2064 if (!ast_strlen_zero(i->cid_name))
2065 tmp->cid.cid_name = strdup(i->cid_name);
2066 if (!ast_strlen_zero(i->rdnis))
2067 tmp->cid.cid_rdnis = strdup(i->rdnis);
2068 if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
2069 tmp->cid.cid_dnid = strdup(i->exten);
2071 if (!ast_strlen_zero(i->uri)) {
2072 pbx_builtin_setvar_helper(tmp, "SIPURI", i->uri);
2074 if (!ast_strlen_zero(i->domain)) {
2075 pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
2077 if (!ast_strlen_zero(i->useragent)) {
2078 pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
2080 if (!ast_strlen_zero(i->callid)) {
2081 pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
2083 ast_setstate(tmp, state);
2084 if (state != AST_STATE_DOWN) {
2085 if (ast_pbx_start(tmp)) {
2086 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
2091 for (v = i->vars ; v ; v = v->next)
2092 pbx_builtin_setvar_helper(tmp,v->name,v->value);
2095 ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
2099 static struct cfalias {
2103 { "Content-Type", "c" },
2104 { "Content-Encoding", "e" },
2108 { "Content-Length", "l" },
2111 { "Supported", "k" },
2112 { "Refer-To", "r" },
2113 { "Allow-Events", "u" },
2118 /*--- get_sdp_by_line: Reads one line of SIP message body */
2119 static char* get_sdp_by_line(char* line, char *name, int nameLen) {
2120 if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
2121 char* r = line + nameLen + 1;
2122 while (*r && (*r < 33)) ++r;
2129 /*--- get_sdp: Gets all kind of SIP message bodies, including SDP,
2130 but the name wrongly applies _only_ sdp */
2131 static char *get_sdp(struct sip_request *req, char *name) {
2133 int len = strlen(name);
2136 for (x=0; x<req->lines; x++) {
2137 r = get_sdp_by_line(req->line[x], name, len);
2138 if (r[0] != '\0') return r;
2144 static void sdpLineNum_iterator_init(int* iterator) {
2148 static char* get_sdp_iterate(int* iterator,
2149 struct sip_request *req, char *name) {
2150 int len = strlen(name);
2152 while (*iterator < req->lines) {
2153 r = get_sdp_by_line(req->line[(*iterator)++], name, len);
2154 if (r[0] != '\0') return r;
2159 static char *__get_header(struct sip_request *req, char *name, int *start)
2162 int len = strlen(name);
2164 if (pedanticsipchecking) {
2165 /* Technically you can place arbitrary whitespace both before and after the ':' in
2166 a header, although RFC3261 clearly says you shouldn't before, and place just
2167 one afterwards. If you shouldn't do it, what absolute idiot decided it was
2168 a good idea to say you can do it, and if you can do it, why in the hell would
2169 you say you shouldn't. */
2170 for (x=*start;x<req->headers;x++) {
2171 if (!strncasecmp(req->header[x], name, len)) {
2172 r = req->header[x] + len;
2173 while(*r && (*r < 33))
2177 while(*r && (*r < 33))
2185 /* We probably shouldn't even bother counting whitespace afterwards but
2186 I guess for backwards compatibility we will */
2187 for (x=*start;x<req->headers;x++) {
2188 if (!strncasecmp(req->header[x], name, len) &&
2189 (req->header[x][len] == ':')) {
2190 r = req->header[x] + len + 1;
2191 while(*r && (*r < 33))
2199 for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++)
2200 if (!strcasecmp(aliases[x].fullname, name))
2201 return __get_header(req, aliases[x].shortname, start);
2203 /* Don't return NULL, so get_header is always a valid pointer */
2207 /*--- get_header: Get header from SIP request ---*/
2208 static char *get_header(struct sip_request *req, char *name)
2211 return __get_header(req, name, &start);
2214 /*--- sip_rtp_read: Read RTP from network ---*/
2215 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p)
2217 /* Retrieve audio/etc from channel. Assumes p->lock is already held. */
2218 struct ast_frame *f;
2219 static struct ast_frame null_frame = { AST_FRAME_NULL, };
2222 f = ast_rtp_read(p->rtp); /* RTP Audio */
2225 f = ast_rtcp_read(p->rtp); /* RTCP Control Channel */
2228 f = ast_rtp_read(p->vrtp); /* RTP Video */
2231 f = ast_rtcp_read(p->vrtp); /* RTCP Control Channel for video */
2236 /* Don't send RFC2833 if we're not supposed to */
2237 if (f && (f->frametype == AST_FRAME_DTMF) && (ast_test_flag(p, SIP_DTMF) != SIP_DTMF_RFC2833))
2240 /* We already hold the channel lock */
2241 if (f->frametype == AST_FRAME_VOICE) {
2242 if (f->subclass != p->owner->nativeformats) {
2243 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
2244 p->owner->nativeformats = f->subclass;
2245 ast_set_read_format(p->owner, p->owner->readformat);
2246 ast_set_write_format(p->owner, p->owner->writeformat);
2248 if ((ast_test_flag(p, SIP_DTMF) == SIP_DTMF_INBAND) && p->vad) {
2249 f = ast_dsp_process(p->owner,p->vad,f);
2250 if (f && (f->frametype == AST_FRAME_DTMF))
2251 ast_log(LOG_DEBUG, "Detected DTMF '%c'\n", f->subclass);
2258 /*--- sip_read: Read SIP RTP from channel */
2259 static struct ast_frame *sip_read(struct ast_channel *ast)
2261 struct ast_frame *fr;
2262 struct sip_pvt *p = ast->pvt->pvt;
2263 ast_mutex_lock(&p->lock);
2264 fr = sip_rtp_read(ast, p);
2265 time(&p->lastrtprx);
2266 ast_mutex_unlock(&p->lock);
2270 /*--- build_callid: Build SIP CALLID header ---*/
2271 static void build_callid(char *callid, int len, struct in_addr ourip, char *fromdomain)
2276 char iabuf[INET_ADDRSTRLEN];
2279 res = snprintf(callid, len, "%08x", val);
2283 if (!ast_strlen_zero(fromdomain))
2284 snprintf(callid, len, "@%s", fromdomain);
2286 /* It's not important that we really use our right IP here... */
2287 snprintf(callid, len, "@%s", ast_inet_ntoa(iabuf, sizeof(iabuf), ourip));
2290 /*--- sip_alloc: Allocate SIP_PVT structure and set defaults ---*/
2291 static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useglobal_nat)
2295 p = malloc(sizeof(struct sip_pvt));
2298 /* Keep track of stuff */
2299 memset(p, 0, sizeof(struct sip_pvt));
2300 ast_mutex_init(&p->lock);
2310 memcpy(&p->sa, sin, sizeof(p->sa));
2311 if (ast_sip_ouraddrfor(&p->sa.sin_addr,&p->ourip))
2312 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2314 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2316 p->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2318 p->vrtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2322 /* Start with 101 instead of 1 */
2325 ast_log(LOG_WARNING, "Unable to create RTP session: %s\n", strerror(errno));
2326 ast_mutex_destroy(&p->lock);
2328 ast_variables_destroy(p->vars);
2334 ast_rtp_settos(p->rtp, tos);
2336 ast_rtp_settos(p->vrtp, tos);
2337 if (useglobal_nat && sin) {
2338 /* Setup NAT structure according to global settings if we have an address */
2339 ast_copy_flags(p, &global_flags, SIP_NAT);
2340 memcpy(&p->recv, sin, sizeof(p->recv));
2341 ast_rtp_setnat(p->rtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
2343 ast_rtp_setnat(p->vrtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
2346 strncpy(p->fromdomain, default_fromdomain, sizeof(p->fromdomain) - 1);
2347 build_via(p, p->via, sizeof(p->via));
2349 build_callid(p->callid, sizeof(p->callid), p->ourip, p->fromdomain);
2351 strncpy(p->callid, callid, sizeof(p->callid) - 1);
2352 ast_copy_flags(p, (&global_flags), SIP_PROMISCREDIR | SIP_TRUSTRPID | SIP_DTMF | SIP_REINVITE | SIP_PROG_INBAND | SIP_OSPAUTH);
2353 /* Assign default music on hold class */
2354 strncpy(p->musicclass, global_musicclass, sizeof(p->musicclass) - 1);
2355 p->rtptimeout = global_rtptimeout;
2356 p->rtpholdtimeout = global_rtpholdtimeout;
2357 p->rtpkeepalive = global_rtpkeepalive;
2358 p->capability = global_capability;
2359 if (ast_test_flag(p, SIP_DTMF) == SIP_DTMF_RFC2833)
2360 p->noncodeccapability |= AST_RTP_DTMF;
2361 strncpy(p->context, default_context, sizeof(p->context) - 1);
2363 ast_mutex_lock(&iflock);
2366 ast_mutex_unlock(&iflock);
2368 ast_log(LOG_DEBUG, "Allocating new SIP call for %s\n", callid);
2372 /*--- find_call: Connect incoming SIP message to current call or create new call structure */
2373 /* Called by handle_request ,sipsock_read */
2374 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin)
2379 char iabuf[INET_ADDRSTRLEN];
2383 callid = get_header(req, "Call-ID");
2385 if (pedanticsipchecking) {
2386 /* In principle Call-ID's uniquely identify a call, however some vendors
2387 (i.e. Pingtel) send multiple calls with the same Call-ID and different
2388 tags in order to simplify billing. The RFC does state that we have to
2389 compare tags in addition to the call-id, but this generate substantially
2390 more overhead which is totally unnecessary for the vast majority of sane
2391 SIP implementations, and thus Asterisk does not enable this behavior
2392 by default. Short version: You'll need this option to support conferencing
2394 strncpy(tmp, req->header[0], sizeof(tmp) - 1);
2396 c = strchr(tmp, ' ');
2399 if (!strcasecmp(cmd, "SIP/2.0"))
2400 strncpy(tmp, get_header(req, "To"), sizeof(tmp) - 1);
2402 strncpy(tmp, get_header(req, "From"), sizeof(tmp) - 1);
2403 tag = strstr(tmp, "tag=");
2406 c = strchr(tag, ';');
2413 if (ast_strlen_zero(callid)) {
2414 ast_log(LOG_WARNING, "Call missing call ID from '%s'\n", ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr));
2417 ast_mutex_lock(&iflock);
2420 if (!strcmp(p->callid, callid) &&
2421 (!pedanticsipchecking || !tag || ast_strlen_zero(p->theirtag) || !strcmp(p->theirtag, tag))) {
2422 /* Found the call */
2423 ast_mutex_lock(&p->lock);
2424 ast_mutex_unlock(&iflock);
2429 ast_mutex_unlock(&iflock);
2430 p = sip_alloc(callid, sin, 1);
2432 ast_mutex_lock(&p->lock);
2436 /*--- sip_register: Parse register=> line in sip.conf and add to registry */
2437 static int sip_register(char *value, int lineno)
2439 struct sip_registry *reg;
2440 char copy[256] = "";
2441 char *username=NULL, *hostname=NULL, *secret=NULL, *authuser=NULL;
2448 strncpy(copy, value, sizeof(copy)-1);
2451 hostname = strrchr(stringp, '@');
2456 if (!username || ast_strlen_zero(username) || !hostname || ast_strlen_zero(hostname)) {
2457 ast_log(LOG_WARNING, "Format for registration is user[:secret[:authuser]]@host[:port][/contact] at line %d", lineno);
2461 username = strsep(&stringp, ":");
2463 secret = strsep(&stringp, ":");
2465 authuser = strsep(&stringp, ":");
2468 hostname = strsep(&stringp, "/");
2470 contact = strsep(&stringp, "/");
2471 if (!contact || ast_strlen_zero(contact))
2474 hostname = strsep(&stringp, ":");
2475 porta = strsep(&stringp, ":");
2477 if (porta && !atoi(porta)) {
2478 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
2481 reg = malloc(sizeof(struct sip_registry));
2483 memset(reg, 0, sizeof(struct sip_registry));
2486 strncpy(reg->contact, contact, sizeof(reg->contact) - 1);
2488 strncpy(reg->username, username, sizeof(reg->username)-1);
2490 strncpy(reg->hostname, hostname, sizeof(reg->hostname)-1);
2492 strncpy(reg->authuser, authuser, sizeof(reg->authuser)-1);
2494 strncpy(reg->secret, secret, sizeof(reg->secret)-1);
2497 reg->refresh = default_expiry;
2498 reg->portno = porta ? atoi(porta) : 0;
2499 reg->callid_valid = 0;
2501 ASTOBJ_CONTAINER_LINK(®l, reg);
2502 ASTOBJ_UNREF(reg,sip_registry_destroy);
2504 ast_log(LOG_ERROR, "Out of memory\n");
2510 /*--- lws2sws: Parse multiline SIP headers into one header */
2511 /* This is enabled if pedanticsipchecking is enabled */
2512 static int lws2sws(char *msgbuf, int len)
2518 /* Eliminate all CRs */
2519 if (msgbuf[h] == '\r') {
2523 /* Check for end-of-line */
2524 if (msgbuf[h] == '\n') {
2525 /* Check for end-of-message */
2528 /* Check for a continuation line */
2529 if (msgbuf[h + 1] == ' ' || msgbuf[h + 1] == '\t') {
2530 /* Merge continuation line */
2534 /* Propagate LF and start new line */
2535 msgbuf[t++] = msgbuf[h++];
2539 if (msgbuf[h] == ' ' || msgbuf[h] == '\t') {
2544 msgbuf[t++] = msgbuf[h++];
2548 msgbuf[t++] = msgbuf[h++];
2556 /*--- parse: Parse a SIP message ----*/
2557 static void parse(struct sip_request *req)
2559 /* Divide fields by NULL's */
2564 /* First header starts immediately */
2568 /* We've got a new header */
2572 printf("Header: %s (%d)\n", req->header[f], strlen(req->header[f]));
2574 if (ast_strlen_zero(req->header[f])) {
2575 /* Line by itself means we're now in content */
2579 if (f >= SIP_MAX_HEADERS - 1) {
2580 ast_log(LOG_WARNING, "Too many SIP headers...\n");
2583 req->header[f] = c + 1;
2584 } else if (*c == '\r') {
2585 /* Ignore but eliminate \r's */
2590 /* Check for last header */
2591 if (!ast_strlen_zero(req->header[f]))
2594 /* Now we process any mime content */
2599 /* We've got a new line */
2602 printf("Line: %s (%d)\n", req->line[f], strlen(req->line[f]));
2604 if (f >= SIP_MAX_LINES - 1) {
2605 ast_log(LOG_WARNING, "Too many SDP lines...\n");
2608 req->line[f] = c + 1;
2609 } else if (*c == '\r') {
2610 /* Ignore and eliminate \r's */
2615 /* Check for last line */
2616 if (!ast_strlen_zero(req->line[f]))
2620 ast_log(LOG_WARNING, "Odd content, extra stuff left over ('%s')\n", c);
2623 /*--- process_sdp: Process SIP SDP ---*/
2624 static int process_sdp(struct sip_pvt *p, struct sip_request *req)
2630 char iabuf[INET_ADDRSTRLEN];
2634 int peercapability, peernoncodeccapability;
2635 int vpeercapability=0, vpeernoncodeccapability=0;
2636 struct sockaddr_in sin;
2639 struct ast_hostent ahp;
2641 int destiterator = 0;
2645 int debug=sip_debug_test_pvt(p);
2647 /* Update our last rtprx when we receive an SDP, too */
2648 time(&p->lastrtprx);
2649 time(&p->lastrtptx);
2651 /* Get codec and RTP info from SDP */
2652 if (strcasecmp(get_header(req, "Content-Type"), "application/sdp")) {
2653 ast_log(LOG_NOTICE, "Content is '%s', not 'application/sdp'\n", get_header(req, "Content-Type"));
2656 m = get_sdp(req, "m");
2657 sdpLineNum_iterator_init(&destiterator);
2658 c = get_sdp_iterate(&destiterator, req, "c");
2659 if (ast_strlen_zero(m) || ast_strlen_zero(c)) {
2660 ast_log(LOG_WARNING, "Insufficient information for SDP (m = '%s', c = '%s')\n", m, c);
2663 if (sscanf(c, "IN IP4 %256s", host) != 1) {
2664 ast_log(LOG_WARNING, "Invalid host in c= line, '%s'\n", c);
2667 /* XXX This could block for a long time, and block the main thread! XXX */
2668 hp = ast_gethostbyname(host, &ahp);
2670 ast_log(LOG_WARNING, "Unable to lookup host in c= line, '%s'\n", c);
2673 sdpLineNum_iterator_init(&iterator);
2674 ast_set_flag(p, SIP_NOVIDEO);
2675 while ((m = get_sdp_iterate(&iterator, req, "m"))[0] != '\0') {
2676 if ((sscanf(m, "audio %d RTP/AVP %n", &x, &len) == 1) ||
2677 (sscanf(m, "audio %d/%d RTP/AVP %n", &x, &y, &len) == 2)) {
2679 /* Scan through the RTP payload types specified in a "m=" line: */
2680 ast_rtp_pt_clear(p->rtp);
2682 while(!ast_strlen_zero(codecs)) {
2683 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2684 ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2688 ast_verbose("Found RTP audio format %d\n", codec);
2689 ast_rtp_set_m_type(p->rtp, codec);
2691 /* Skip over any whitespace */
2692 while(*codecs && (*codecs < 33)) codecs++;
2696 ast_rtp_pt_clear(p->vrtp); /* Must be cleared in case no m=video line exists */
2698 if (p->vrtp && (sscanf(m, "video %d RTP/AVP %n", &x, &len) == 1)) {
2699 ast_clear_flag(p, SIP_NOVIDEO);
2701 /* Scan through the RTP payload types specified in a "m=" line: */
2703 while(!ast_strlen_zero(codecs)) {
2704 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2705 ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2709 ast_verbose("Found video format %s\n", ast_getformatname(codec));
2710 ast_rtp_set_m_type(p->vrtp, codec);
2712 /* Skip over any whitespace */
2713 while(*codecs && (*codecs < 33)) codecs++;
2717 /* Check for Media-description-level-address for audio */
2718 if (pedanticsipchecking) {
2719 c = get_sdp_iterate(&destiterator, req, "c");
2720 if (!ast_strlen_zero(c)) {
2721 if (sscanf(c, "IN IP4 %256s", host) != 1) {
2722 ast_log(LOG_WARNING, "Invalid secondary host in c= line, '%s'\n", c);
2724 /* XXX This could block for a long time, and block the main thread! XXX */
2725 hp = ast_gethostbyname(host, &ahp);
2727 ast_log(LOG_WARNING, "Unable to lookup host in secondary c= line, '%s'\n", c);
2732 /* RTP addresses and ports for audio and video */
2733 sin.sin_family = AF_INET;
2734 memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
2736 /* Setup audio port number */
2737 sin.sin_port = htons(portno);
2738 if (p->rtp && sin.sin_port) {
2739 ast_rtp_set_peer(p->rtp, &sin);
2741 ast_verbose("Peer audio RTP is at port %s:%d\n", ast_inet_ntoa(iabuf,sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2742 ast_log(LOG_DEBUG,"Peer audio RTP is at port %s:%d\n",ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2745 /* Check for Media-description-level-address for video */
2746 if (pedanticsipchecking) {
2747 c = get_sdp_iterate(&destiterator, req, "c");
2748 if (!ast_strlen_zero(c)) {
2749 if (sscanf(c, "IN IP4 %256s", host) != 1) {
2750 ast_log(LOG_WARNING, "Invalid secondary host in c= line, '%s'\n", c);
2752 /* XXX This could block for a long time, and block the main thread! XXX */
2753 hp = ast_gethostbyname(host, &ahp);
2755 ast_log(LOG_WARNING, "Unable to lookup host in secondary c= line, '%s'\n", c);
2760 /* Setup video port number */
2761 sin.sin_port = htons(vportno);
2762 if (p->vrtp && sin.sin_port) {
2763 ast_rtp_set_peer(p->vrtp, &sin);
2765 ast_verbose("Peer video RTP is at port %s:%d\n", ast_inet_ntoa(iabuf,sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2766 ast_log(LOG_DEBUG,"Peer video RTP is at port %s:%d\n",ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2770 /* Next, scan through each "a=rtpmap:" line, noting each
2771 * specified RTP payload type (with corresponding MIME subtype):
2773 sdpLineNum_iterator_init(&iterator);
2774 while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
2775 char* mimeSubtype = ast_strdupa(a); /* ensures we have enough space */
2776 if (!strcasecmp(a, "sendonly")) {
2780 if (!strcasecmp(a, "sendrecv")) {
2783 if (sscanf(a, "rtpmap: %u %[^/]/", &codec, mimeSubtype) != 2) continue;
2785 ast_verbose("Found description format %s\n", mimeSubtype);
2786 /* Note: should really look at the 'freq' and '#chans' params too */
2787 ast_rtp_set_rtpmap_type(p->rtp, codec, "audio", mimeSubtype);
2789 ast_rtp_set_rtpmap_type(p->vrtp, codec, "video", mimeSubtype);
2792 /* Now gather all of the codecs that were asked for: */
2793 ast_rtp_get_current_formats(p->rtp,
2794 &peercapability, &peernoncodeccapability);
2796 ast_rtp_get_current_formats(p->vrtp,
2797 &vpeercapability, &vpeernoncodeccapability);
2798 p->jointcapability = p->capability & (peercapability | vpeercapability);
2799 p->peercapability = (peercapability | vpeercapability);
2800 p->noncodeccapability = noncodeccapability & peernoncodeccapability;
2803 /* shame on whoever coded this.... */
2804 const unsigned slen=512;
2805 char s1[slen], s2[slen], s3[slen], s4[slen];
2807 ast_verbose("Capabilities: us - %s, peer - audio=%s/video=%s, combined - %s\n",
2808 ast_getformatname_multiple(s1, slen, p->capability),
2809 ast_getformatname_multiple(s2, slen, peercapability),
2810 ast_getformatname_multiple(s3, slen, vpeercapability),
2811 ast_getformatname_multiple(s4, slen, p->jointcapability));
2813 ast_verbose("Non-codec capabilities: us - %s, peer - %s, combined - %s\n",
2814 ast_getformatname_multiple(s1, slen, noncodeccapability),
2815 ast_getformatname_multiple(s2, slen, peernoncodeccapability),
2816 ast_getformatname_multiple(s3, slen, p->noncodeccapability));
2818 if (!p->jointcapability) {
2819 ast_log(LOG_NOTICE, "No compatible codecs!\n");
2823 if (!(p->owner->nativeformats & p->jointcapability)) {
2824 const unsigned slen=512;
2825 char s1[slen], s2[slen];
2826 ast_log(LOG_DEBUG, "Oooh, we need to change our formats since our peer supports only %s and not %s\n",
2827 ast_getformatname_multiple(s1, slen, p->jointcapability),
2828 ast_getformatname_multiple(s2, slen, p->owner->nativeformats));
2829 p->owner->nativeformats = ast_codec_choose(&p->prefs, p->jointcapability, 1);
2830 ast_set_read_format(p->owner, p->owner->readformat);
2831 ast_set_write_format(p->owner, p->owner->writeformat);
2833 if (ast_bridged_channel(p->owner)) {
2834 /* Turn on/off music on hold if we are holding/unholding */
2835 if (sin.sin_addr.s_addr && !sendonly) {
2836 ast_moh_stop(ast_bridged_channel(p->owner));
2837 if (callevents && p->onhold) {
2838 manager_event(EVENT_FLAG_CALL, "Unhold",
2842 p->owner->uniqueid);
2846 if (callevents && !p->onhold) {
2847 manager_event(EVENT_FLAG_CALL, "Hold",
2851 p->owner->uniqueid);
2854 ast_moh_start(ast_bridged_channel(p->owner), NULL);
2856 ast_rtp_stop(p->rtp);
2864 /*--- add_header: Add header to SIP message */
2865 static int add_header(struct sip_request *req, char *var, char *value)
2868 char *shortname = "";
2869 if (req->len >= sizeof(req->data) - 4) {
2870 ast_log(LOG_WARNING, "Out of space, can't add anymore (%s:%s)\n", var, value);
2874 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
2878 req->header[req->headers] = req->data + req->len;
2879 if (compactheaders) {
2880 for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++)
2881 if (!strcasecmp(aliases[x].fullname, var))
2882 shortname = aliases[x].shortname;
2884 if(!ast_strlen_zero(shortname)) {
2885 snprintf(req->header[req->headers], sizeof(req->data) - req->len - 4, "%s: %s\r\n", shortname, value);
2887 snprintf(req->header[req->headers], sizeof(req->data) - req->len - 4, "%s: %s\r\n", var, value);
2889 req->len += strlen(req->header[req->headers]);
2890 if (req->headers < SIP_MAX_HEADERS)
2893 ast_log(LOG_WARNING, "Out of header space\n");
2899 /*--- add_blank_header: Add blank header to SIP message */
2900 static int add_blank_header(struct sip_request *req)
2902 if (req->len >= sizeof(req->data) - 4) {
2903 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
2907 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
2910 req->header[req->headers] = req->data + req->len;
2911 snprintf(req->header[req->headers], sizeof(req->data) - req->len, "\r\n");
2912 req->len += strlen(req->header[req->headers]);
2913 if (req->headers < SIP_MAX_HEADERS)
2916 ast_log(LOG_WARNING, "Out of header space\n");
2922 /*--- add_line: Add content (not header) to SIP message */
2923 static int add_line(struct sip_request *req, char *line)
2925 if (req->len >= sizeof(req->data) - 4) {
2926 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
2930 /* Add extra empty return */
2931 snprintf(req->data + req->len, sizeof(req->data) - req->len, "\r\n");
2932 req->len += strlen(req->data + req->len);
2934 req->line[req->lines] = req->data + req->len;
2935 snprintf(req->line[req->lines], sizeof(req->data) - req->len, "%s", line);
2936 req->len += strlen(req->line[req->lines]);
2937 if (req->lines < SIP_MAX_LINES)
2940 ast_log(LOG_WARNING, "Out of line space\n");
2946 /*--- copy_header: Copy one header field from one request to another */
2947 static int copy_header(struct sip_request *req, struct sip_request *orig, char *field)
2950 tmp = get_header(orig, field);
2951 if (!ast_strlen_zero(tmp)) {
2952 /* Add what we're responding to */
2953 return add_header(req, field, tmp);
2955 ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
2959 /*--- copy_all_header: Copy all headers from one request to another ---*/
2960 static int copy_all_header(struct sip_request *req, struct sip_request *orig, char *field)
2966 tmp = __get_header(orig, field, &start);
2967 if (!ast_strlen_zero(tmp)) {
2968 /* Add what we're responding to */
2969 add_header(req, field, tmp);
2974 return copied ? 0 : -1;
2977 /*--- copy_via_headers: Copy SIP VIA Headers from one request to another ---*/
2978 static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, struct sip_request *orig, char *field)
2980 char tmp[256]="", *oh, *end;
2984 char iabuf[INET_ADDRSTRLEN];
2986 oh = __get_header(orig, field, &start);
2987 if (!ast_strlen_zero(oh)) {
2989 strncpy(tmp, oh, sizeof(tmp) - 1);
2990 oh = strstr(tmp, ";rport");
2992 end = strchr(oh + 1, ';');
2994 memmove(oh, end, strlen(end) + 1);
2998 if (!copied && (ast_test_flag(p, SIP_NAT) == SIP_NAT_ALWAYS)) {
2999 /* Whoo hoo! Now we can indicate port address translation too! Just
3000 another RFC (RFC3581). I'll leave the original comments in for
3002 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));
3003 add_header(req, field, new);
3005 /* Add what we're responding to */
3006 add_header(req, field, tmp);
3013 ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
3019 /*--- add_route: Add route header into request per learned route ---*/
3020 static void add_route(struct sip_request *req, struct sip_route *route)
3023 int n, rem = 255; /* sizeof(r)-1: Room for terminating 0 */
3029 n = strlen(route->hop);
3030 if ((n+3)>rem) break;
3036 strncpy(p, route->hop, rem); p += n;
3039 route = route->next;
3042 add_header(req, "Route", r);
3045 /*--- set_destination: Set destination from SIP URI ---*/
3046 static void set_destination(struct sip_pvt *p, char *uri)
3048 char *h, *maddr, hostname[256] = "";
3049 char iabuf[INET_ADDRSTRLEN];
3052 struct ast_hostent ahp;
3053 int debug=sip_debug_test_pvt(p);
3055 /* Parse uri to h (host) and port - uri is already just the part inside the <> */
3056 /* general form we are expecting is sip[s]:username[:password]@host[:port][;...] */
3059 ast_verbose("set_destination: Parsing <%s> for address/port to send to\n", uri);
3061 /* Find and parse hostname */
3062 h = strchr(uri, '@');
3067 if (strncmp(h, "sip:", 4) == 0)
3069 else if (strncmp(h, "sips:", 5) == 0)
3072 hn = strcspn(h, ":;>");
3073 if (hn > (sizeof(hostname) - 1)) hn = sizeof(hostname) - 1;
3074 strncpy(hostname, h, hn); hostname[hn] = '\0'; /* safe */
3077 /* Is "port" present? if not default to 5060 */
3081 port = strtol(h, &h, 10);
3086 /* Got the hostname:port - but maybe there's a "maddr=" to override address? */
3087 maddr = strstr(h, "maddr=");
3090 hn = strspn(maddr, "0123456789.");
3091 if (hn > (sizeof(hostname) - 1)) hn = sizeof(hostname) - 1;
3092 strncpy(hostname, maddr, hn); hostname[hn] = '\0'; /* safe */
3095 hp = ast_gethostbyname(hostname, &ahp);
3097 ast_log(LOG_WARNING, "Can't find address for host '%s'\n", hostname);
3100 p->sa.sin_family = AF_INET;
3101 memcpy(&p->sa.sin_addr, hp->h_addr, sizeof(p->sa.sin_addr));
3102 p->sa.sin_port = htons(port);
3104 ast_verbose("set_destination: set destination to %s, port %d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), p->sa.sin_addr), port);
3107 /*--- init_resp: Initialize SIP response, based on SIP request ---*/
3108 static int init_resp(struct sip_request *req, char *resp, struct sip_request *orig)
3110 /* Initialize a response */
3111 if (req->headers || req->len) {
3112 ast_log(LOG_WARNING, "Request already initialized?!?\n");
3115 req->header[req->headers] = req->data + req->len;
3116 snprintf(req->header[req->headers], sizeof(req->data) - req->len, "SIP/2.0 %s\r\n", resp);
3117 req->len += strlen(req->header[req->headers]);
3118 if (req->headers < SIP_MAX_HEADERS)
3121 ast_log(LOG_WARNING, "Out of header space\n");
3125 /*--- init_req: Initialize SIP request ---*/
3126 static int init_req(struct sip_request *req, char *resp, char *recip)
3128 /* Initialize a response */
3129 if (req->headers || req->len) {
3130 ast_log(LOG_WARNING, "Request already initialized?!?\n");
3133 req->header[req->headers] = req->data + req->len;
3134 snprintf(req->header[req->headers], sizeof(req->data) - req->len, "%s %s SIP/2.0\r\n", resp, recip);
3135 req->len += strlen(req->header[req->headers]);
3136 if (req->headers < SIP_MAX_HEADERS)
3139 ast_log(LOG_WARNING, "Out of header space\n");
3144 /*--- respprep: Prepare SIP response packet ---*/
3145 static int respprep(struct sip_request *resp, struct sip_pvt *p, char *msg, struct sip_request *req)
3147 char newto[256] = "", *ot;
3149 memset(resp, 0, sizeof(*resp));
3150 init_resp(resp, msg, req);
3151 copy_via_headers(p, resp, req, "Via");
3153 copy_all_header(resp, req, "Record-Route");
3154 copy_header(resp, req, "From");
3155 ot = get_header(req, "To");
3156 if (!strstr(ot, "tag=")) {
3157 /* Add the proper tag if we don't have it already. If they have specified
3158 their tag, use it. Otherwise, use our own tag */
3159 if (!ast_strlen_zero(p->theirtag) && ast_test_flag(p, SIP_OUTGOING))
3160 snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
3161 else if (p->tag && !ast_test_flag(p, SIP_OUTGOING))
3162 snprintf(newto, sizeof(newto), "%s;tag=as%08x", ot, p->tag);
3164 strncpy(newto, ot, sizeof(newto) - 1);
3165 newto[sizeof(newto) - 1] = '\0';
3169 add_header(resp, "To", ot);
3170 copy_header(resp, req, "Call-ID");
3171 copy_header(resp, req, "CSeq");
3172 add_header(resp, "User-Agent", default_useragent);
3173 add_header(resp, "Allow", ALLOWED_METHODS);
3175 /* For registration responses, we also need expiry and
3179 snprintf(contact, sizeof(contact), "%s;expires=%d", p->our_contact, p->expiry);
3180 snprintf(tmp, sizeof(tmp), "%d", p->expiry);
3181 add_header(resp, "Expires", tmp);
3182 add_header(resp, "Contact", contact);
3184 add_header(resp, "Contact", p->our_contact);
3189 /*--- reqprep: Initialize a SIP request packet ---*/
3190 static int reqprep(struct sip_request *req, struct sip_pvt *p, char *msg, int seqno, int newbranch)
3192 struct sip_request *orig = &p->initreq;
3193 char stripped[80] ="";
3199 memset(req, 0, sizeof(struct sip_request));
3201 snprintf(p->lastmsg, sizeof(p->lastmsg), "Tx: %s", msg);
3209 p->branch ^= rand();
3210 build_via(p, p->via, sizeof(p->via));
3212 if (!strcasecmp(msg, "CANCEL")) {
3213 c = p->initreq.rlPart2; /* Use original URI */
3214 } else if (!strcasecmp(msg, "ACK")) {
3215 /* Use URI from Contact: in 200 OK (if INVITE)
3216 (we only have the contacturi on INVITEs) */
3217 if (!ast_strlen_zero(p->okcontacturi))
3218 c = p->okcontacturi;
3220 c = p->initreq.rlPart2;
3221 } else if (!ast_strlen_zero(p->okcontacturi)) {
3222 c = p->okcontacturi; /* Use for BYE or REINVITE */
3223 } else if (!ast_strlen_zero(p->uri)) {
3226 /* We have no URI, use To: or From: header as URI (depending on direction) */
3227 if (ast_test_flag(p, SIP_OUTGOING))
3228 strncpy(stripped, get_header(orig, "To"), sizeof(stripped) - 1);
3230 strncpy(stripped, get_header(orig, "From"), sizeof(stripped) - 1);
3232 c = strchr(stripped, '<');
3244 init_req(req, msg, c);
3246 snprintf(tmp, sizeof(tmp), "%d %s", seqno, msg);
3248 add_header(req, "Via", p->via);
3250 set_destination(p, p->route->hop);
3251 add_route(req, p->route->next);
3254 ot = get_header(orig, "To");
3255 of = get_header(orig, "From");
3257 /* Add tag *unless* this is a CANCEL, in which case we need to send it exactly
3258 as our original request, including tag (or presumably lack thereof) */
3259 if (!strstr(ot, "tag=") && strcasecmp(msg, "CANCEL")) {
3260 /* Add the proper tag if we don't have it already. If they have specified
3261 their tag, use it. Otherwise, use our own tag */
3262 if (ast_test_flag(p, SIP_OUTGOING) && !ast_strlen_zero(p->theirtag))
3263 snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
3264 else if (!ast_test_flag(p, SIP_OUTGOING))
3265 snprintf(newto, sizeof(newto), "%s;tag=as%08x", ot, p->tag);
3267 snprintf(newto, sizeof(newto), "%s", ot);
3271 if (ast_test_flag(p, SIP_OUTGOING)) {
3272 add_header(req, "From", of);
3273 add_header(req, "To", ot);
3275 add_header(req, "From", ot);
3276 add_header(req, "To", of);
3278 add_header(req, "Contact", p->our_contact);
3279 copy_header(req, orig, "Call-ID");
3280 add_header(req, "CSeq", tmp);
3282 add_header(req, "User-Agent", default_useragent);
3286 static int __transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req, int reliable)
3288 struct sip_request resp;
3290 if (reliable && (sscanf(get_header(req, "CSeq"), "%i ", &seqno) != 1)) {
3291 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
3294 respprep(&resp, p, msg, req);
3295 add_header(&resp, "Content-Length", "0");
3296 add_blank_header(&resp);
3297 return send_response(p, &resp, reliable, seqno);
3300 /*--- transmit_response: Transmit response, no retransmits */
3301 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req)
3303 return __transmit_response(p, msg, req, 0);
3306 /*--- transmit_response: Transmit response, Make sure you get a reply */
3307 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal)
3309 return __transmit_response(p, msg, req, fatal ? 2 : 1);
3312 /*--- append_date: Append date to SIP message ---*/
3313 static void append_date(struct sip_request *req)
3320 strftime(tmpdat, sizeof(tmpdat), "%a, %d %b %Y %T GMT", &tm);
3321 add_header(req, "Date", tmpdat);
3324 /*--- transmit_response_with_date: Append date and content length before transmitting response ---*/
3325 static int transmit_response_with_date(struct sip_pvt *p, char *msg, struct sip_request *req)
3327 struct sip_request resp;
3328 respprep(&resp, p, msg, req);
3330 add_header(&resp, "Content-Length", "0");
3331 add_blank_header(&resp);
3332 return send_response(p, &resp, 0, 0);
3335 /*--- transmit_response_with_allow: Append Accept header, content length before transmitting response ---*/
3336 static int transmit_response_with_allow(struct sip_pvt *p, char *msg, struct sip_request *req, int reliable)
3338 struct sip_request resp;
3339 respprep(&resp, p, msg, req);
3340 add_header(&resp, "Accept", "application/sdp");
3341 add_header(&resp, "Content-Length", "0");
3342 add_blank_header(&resp);
3343 return send_response(p, &resp, reliable, 0);
3346 /* transmit_response_with_auth: Respond with authorization request */
3347 static int transmit_response_with_auth(struct sip_pvt *p, char *msg, struct sip_request *req, char *randdata, int reliable, char *header)
3349 struct sip_request resp;
3352 if (reliable && (sscanf(get_header(req, "CSeq"), "%i ", &seqno) != 1)) {
3353 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
3356 snprintf(tmp, sizeof(tmp), "Digest realm=\"%s\", nonce=\"%s\"", global_realm, randdata);
3357 respprep(&resp, p, msg, req);
3358 add_header(&resp, header, tmp);
3359 add_header(&resp, "Content-Length", "0");
3360 add_blank_header(&resp);
3361 return send_response(p, &resp, reliable, seqno);
3364 /*--- add_text: Add text body to SIP message ---*/
3365 static int add_text(struct sip_request *req, char *text)
3367 /* XXX Convert \n's to \r\n's XXX */
3368 int len = strlen(text);
3370 snprintf(clen, sizeof(clen), "%d", len);
3371 add_header(req, "Content-Type", "text/plain");
3372 add_header(req, "Content-Length", clen);
3373 add_line(req, text);
3377 /*--- add_digit: add DTMF INFO tone to sip message ---*/
3378 /* Always adds default duration 250 ms, regardless of what came in over the line */
3379 static int add_digit(struct sip_request *req, char digit)
3384 snprintf(tmp, sizeof(tmp), "Signal=%c\r\nDuration=250\r\n", digit);
3386 snprintf(clen, sizeof(clen), "%d", len);
3387 add_header(req, "Content-Type", "application/dtmf-relay");
3388 add_header(req, "Content-Length", clen);
3393 /*--- add_sdp: Add Session Description Protocol message ---*/
3394 static int add_sdp(struct sip_request *resp, struct sip_pvt *p)
3399 int alreadysent = 0;
3401 struct sockaddr_in sin;
3402 struct sockaddr_in vsin;
3412 char iabuf[INET_ADDRSTRLEN];
3414 int capability = 0 ;
3415 struct sockaddr_in dest;
3416 struct sockaddr_in vdest = { 0, };
3419 debug = sip_debug_test_pvt(p);
3421 /* XXX We break with the "recommendation" and send our IP, in order that our
3422 peer doesn't have to ast_gethostbyname() us XXX */
3425 ast_log(LOG_WARNING, "No way to add SDP without an RTP structure\n");
3428 capability = p->capability;
3430 if (!p->sessionid) {
3431 p->sessionid = getpid();
3432 p->sessionversion = p->sessionid;
3434 p->sessionversion++;
3435 ast_rtp_get_us(p->rtp, &sin);
3437 ast_rtp_get_us(p->vrtp, &vsin);
3439 if (p->redirip.sin_addr.s_addr) {
3440 dest.sin_port = p->redirip.sin_port;
3441 dest.sin_addr = p->redirip.sin_addr;
3443 capability = p->redircodecs;
3445 dest.sin_addr = p->ourip;
3446 dest.sin_port = sin.sin_port;
3449 /* Determine video destination */
3451 if (p->vredirip.sin_addr.s_addr) {
3452 vdest.sin_port = p->vredirip.sin_port;
3453 vdest.sin_addr = p->vredirip.sin_addr;
3455 vdest.sin_addr = p->ourip;
3456 vdest.sin_port = vsin.sin_port;
3460 ast_verbose("We're at %s port %d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ntohs(sin.sin_port));
3462 ast_verbose("Video is at %s port %d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ntohs(vsin.sin_port));
3464 snprintf(v, sizeof(v), "v=0\r\n");
3465 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));
3466 snprintf(s, sizeof(s), "s=session\r\n");
3467 snprintf(c, sizeof(c), "c=IN IP4 %s\r\n", ast_inet_ntoa(iabuf, sizeof(iabuf), dest.sin_addr));
3468 snprintf(t, sizeof(t), "t=0 0\r\n");
3469 snprintf(m, sizeof(m), "m=audio %d RTP/AVP", ntohs(dest.sin_port));
3470 snprintf(m2, sizeof(m2), "m=video %d RTP/AVP", ntohs(vdest.sin_port));
3471 /* Prefer the codec we were requested to use, first, no matter what */
3472 if (capability & p->prefcodec) {
3474 ast_verbose("Answering/Requesting with root capability 0x%x (%s)\n", p->prefcodec, ast_getformatname(p->prefcodec));
3475 codec = ast_rtp_lookup_code(p->rtp, 1, p->prefcodec);
3477 snprintf(costr, sizeof(costr), " %d", codec);
3478 if (p->prefcodec <= AST_FORMAT_MAX_AUDIO) {
3479 strncat(m, costr, sizeof(m) - strlen(m) - 1);
3480 snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(1, p->prefcodec));
3481 strncpy(a, costr, sizeof(a) - 1);
3483 strncat(m2, costr, sizeof(m2) - strlen(m2) - 1);
3484 snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/90000\r\n", codec, ast_rtp_lookup_mime_subtype(1, p->prefcodec));
3485 strncpy(a2, costr, sizeof(a2) - 1);