2 * Asterisk -- A telephony toolkit for Linux.
4 * Implementation of Session Initiation Protocol
6 * Copyright (C) 2004, 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_pvt.h>
22 #include <asterisk/config.h>
23 #include <asterisk/logger.h>
24 #include <asterisk/module.h>
25 #include <asterisk/pbx.h>
26 #include <asterisk/options.h>
27 #include <asterisk/lock.h>
28 #include <asterisk/sched.h>
29 #include <asterisk/io.h>
30 #include <asterisk/rtp.h>
31 #include <asterisk/acl.h>
32 #include <asterisk/manager.h>
33 #include <asterisk/callerid.h>
34 #include <asterisk/cli.h>
35 #include <asterisk/md5.h>
36 #include <asterisk/app.h>
37 #include <asterisk/musiconhold.h>
38 #include <asterisk/dsp.h>
39 #include <asterisk/features.h>
40 #include <asterisk/acl.h>
41 #include <asterisk/srv.h>
42 #include <asterisk/astdb.h>
43 #include <asterisk/causes.h>
44 #include <asterisk/utils.h>
45 #include <asterisk/file.h>
46 #include <asterisk/astobj.h>
48 #include <asterisk/astosp.h>
50 #include <sys/socket.h>
51 #include <sys/ioctl.h>
58 #include <arpa/inet.h>
60 #include <sys/signal.h>
61 #include <netinet/in_systm.h>
62 #include <netinet/ip.h>
65 #ifndef DEFAULT_USERAGENT
66 #define DEFAULT_USERAGENT "Asterisk PBX"
69 #define VIDEO_CODEC_MASK 0x1fc0000 /* Video codecs from H.261 thru AST_FORMAT_MAX_VIDEO */
71 #define IPTOS_MINCOST 0x02
74 /* #define VOCAL_DATA_HACK */
77 #define DEFAULT_DEFAULT_EXPIRY 120
78 #define DEFAULT_MAX_EXPIRY 3600
79 #define DEFAULT_REGISTRATION_TIMEOUT 20
81 /* guard limit must be larger than guard secs */
82 /* guard min must be < 1000, and should be >= 250 */
83 #define EXPIRY_GUARD_SECS 15 /* How long before expiry do we reregister */
84 #define EXPIRY_GUARD_LIMIT 30 /* Below here, we use EXPIRY_GUARD_PCT instead of
86 #define EXPIRY_GUARD_MIN 500 /* This is the minimum guard time applied. If
87 GUARD_PCT turns out to be lower than this, it
88 will use this time instead.
89 This is in milliseconds. */
90 #define EXPIRY_GUARD_PCT 0.20 /* Percentage of expires timeout to use when
91 below EXPIRY_GUARD_LIMIT */
93 static int max_expiry = DEFAULT_MAX_EXPIRY;
94 static int default_expiry = DEFAULT_DEFAULT_EXPIRY;
97 #define MAX(a,b) ((a) > (b) ? (a) : (b))
100 #define CALLERID_UNKNOWN "Unknown"
104 #define DEFAULT_MAXMS 2000 /* Must be faster than 2 seconds by default */
105 #define DEFAULT_FREQ_OK 60 * 1000 /* How often to check for the host to be up */
106 #define DEFAULT_FREQ_NOTOK 10 * 1000 /* How often to check, if the host is down... */
108 #define DEFAULT_RETRANS 1000 /* How frequently to retransmit */
109 #define MAX_RETRANS 5 /* Try only 5 times for retransmissions */
112 #define DEBUG_READ 0 /* Recieved data */
113 #define DEBUG_SEND 1 /* Transmit data */
115 static char *desc = "Session Initiation Protocol (SIP)";
116 static char *channeltype = "SIP";
117 static char *tdesc = "Session Initiation Protocol (SIP)";
118 static char *config = "sip.conf";
119 static char *notify_config = "sip_notify.conf";
121 #define DEFAULT_SIP_PORT 5060 /* From RFC 2543 */
122 #define SIP_MAX_PACKET 4096 /* Also from RFC 2543, should sub headers tho */
124 #define ALLOWED_METHODS "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER"
126 static char default_useragent[AST_MAX_EXTENSION] = DEFAULT_USERAGENT;
128 #define DEFAULT_CONTEXT "default"
129 static char default_context[AST_MAX_EXTENSION] = DEFAULT_CONTEXT;
131 static char default_language[MAX_LANGUAGE] = "";
133 #define DEFAULT_CALLERID "asterisk"
134 static char default_callerid[AST_MAX_EXTENSION] = DEFAULT_CALLERID;
136 static char default_fromdomain[AST_MAX_EXTENSION] = "";
138 #define DEFAULT_NOTIFYMIME "application/simple-message-summary"
139 static char default_notifymime[AST_MAX_EXTENSION] = DEFAULT_NOTIFYMIME;
141 static struct ast_flags global_flags = {0}; /* 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 char ourhost[256];
196 static struct in_addr __ourip;
197 static struct sockaddr_in outboundproxyip;
200 static int sipdebug = 0;
201 static struct sockaddr_in debugaddr;
205 static int videosupport = 0;
207 static int compactheaders = 0; /* send compact sip headers */
209 static int recordhistory = 0; /* Record SIP history. Off by default */
211 static char global_musicclass[MAX_LANGUAGE] = ""; /* Global music on hold class */
212 #define DEFAULT_REALM "asterisk"
213 static char global_realm[AST_MAX_EXTENSION] = DEFAULT_REALM; /* Default realm */
214 static char regcontext[AST_MAX_EXTENSION] = ""; /* Context for auto-extensions */
217 #define DEFAULT_EXPIRY 900
218 static int expiry = DEFAULT_EXPIRY;
220 static struct sched_context *sched;
221 static struct io_context *io;
222 /* The private structures of the sip channels are linked for
223 selecting outgoing channels */
225 #define SIP_MAX_HEADERS 64
226 #define SIP_MAX_LINES 64
230 #define DEC_OUT_USE 2
231 #define INC_OUT_USE 3
233 static struct ast_codec_pref prefs;
236 /* sip_request: The data grabbed from the UDP socket */
238 char *rlPart1; /* SIP Method Name or "SIP/2.0" protocol version */
239 char *rlPart2; /* The Request URI or Response Status */
240 int len; /* Length */
241 int headers; /* # of SIP Headers */
242 char *header[SIP_MAX_HEADERS];
243 int lines; /* SDP Content */
244 char *line[SIP_MAX_LINES];
245 char data[SIP_MAX_PACKET];
251 struct sip_route *next;
257 struct sip_history *next;
260 #define SIP_ALREADYGONE (1 << 0) /* Whether or not we've already been destroyed by our peer */
261 #define SIP_NEEDDESTROY (1 << 1) /* if we need to be destroyed */
262 #define SIP_NOVIDEO (1 << 2) /* Didn't get video in invite, don't offer */
263 #define SIP_RINGING (1 << 3) /* Have sent 180 ringing */
264 #define SIP_PROGRESS_SENT (1 << 4) /* Have sent 183 message progress */
265 #define SIP_NEEDREINVITE (1 << 5) /* Do we need to send another reinvite? */
266 #define SIP_PENDINGBYE (1 << 6) /* Need to send bye after we ack? */
267 #define SIP_GOTREFER (1 << 7) /* Got a refer? */
268 #define SIP_PROMISCREDIR (1 << 8) /* Promiscuous redirection */
269 #define SIP_TRUSTRPID (1 << 9) /* Trust RPID headers? */
270 #define SIP_USEREQPHONE (1 << 10) /* Add user=phone to numeric URI. Default off */
271 #define SIP_REALTIME (1 << 11) /* Flag for realtime users */
272 #define SIP_USECLIENTCODE (1 << 12) /* Trust X-ClientCode info message */
273 #define SIP_OUTGOING (1 << 13) /* Is this an outgoing call? */
274 #define SIP_SELFDESTRUCT (1 << 14)
275 #define SIP_DYNAMIC (1 << 15) /* Is this a dynamic peer? */
276 /* --- Choices for DTMF support in SIP channel */
277 #define SIP_DTMF (3 << 16) /* three settings, uses two bits */
278 #define SIP_DTMF_RFC2833 (0 << 16) /* RTP DTMF */
279 #define SIP_DTMF_INBAND (1 << 16) /* Inband audio, only for ULAW/ALAW */
280 #define SIP_DTMF_INFO (2 << 16) /* SIP Info messages */
282 #define SIP_NAT (3 << 18) /* four settings, uses two bits */
283 #define SIP_NAT_NEVER (0 << 18) /* No nat support */
284 #define SIP_NAT_RFC3581 (1 << 18)
285 #define SIP_NAT_ROUTE (2 << 18)
286 #define SIP_NAT_ALWAYS (3 << 18)
287 /* re-INVITE related settings */
288 #define SIP_REINVITE (3 << 20) /* two bits used */
289 #define SIP_CAN_REINVITE (1 << 20) /* allow peers to be reinvited to send media directly p2p */
290 #define SIP_REINVITE_UPDATE (2 << 20) /* use UPDATE (RFC3311) when reinviting this peer */
291 /* "insecure" settings */
292 #define SIP_INSECURE (3 << 22) /* three settings, uses two bits */
293 #define SIP_SECURE (0 << 22)
294 #define SIP_INSECURE_NORMAL (1 << 22)
295 #define SIP_INSECURE_VERY (2 << 22)
296 /* Sending PROGRESS in-band settings */
297 #define SIP_PROG_INBAND (3 << 24) /* three settings, uses two bits */
298 #define SIP_PROG_INBAND_NEVER (0 << 24)
299 #define SIP_PROG_INBAND_NO (1 << 24)
300 #define SIP_PROG_INBAND_YES (2 << 24)
301 /* Open Settlement Protocol authentication */
302 #define SIP_OSPAUTH (3 << 26) /* three settings, uses two bits */
303 #define SIP_OSPAUTH_NO (0 << 26)
304 #define SIP_OSPAUTH_YES (1 << 26)
305 #define SIP_OSPAUTH_EXCLUSIVE (2 << 26)
307 /* sip_pvt: PVT structures are used for each SIP conversation, ie. a call */
308 static struct sip_pvt {
309 ast_mutex_t lock; /* Channel private lock */
310 char callid[80]; /* Global CallID */
311 char randdata[80]; /* Random data */
312 struct ast_codec_pref prefs; /* codec prefs */
313 unsigned int ocseq; /* Current outgoing seqno */
314 unsigned int icseq; /* Current incoming seqno */
315 ast_group_t callgroup; /* Call group */
316 ast_group_t pickupgroup; /* Pickup group */
317 int lastinvite; /* Last Cseq of invite */
318 unsigned int flags; /* SIP_ flags */
319 int capability; /* Special capability (codec) */
320 int jointcapability; /* Supported capability at both ends (codecs ) */
321 int peercapability; /* Supported peer capability */
322 int prefcodec; /* Preferred codec (outbound only) */
323 int noncodeccapability;
324 int callingpres; /* Calling presentation */
325 int authtries; /* Times we've tried to authenticate */
326 int expiry; /* How long we take to expire */
327 int branch; /* One random number */
328 int tag; /* Another random number */
329 int sessionid; /* SDP Session ID */
330 int sessionversion; /* SDP Session Version */
331 struct sockaddr_in sa; /* Our peer */
332 struct sockaddr_in redirip; /* Where our RTP should be going if not to us */
333 struct sockaddr_in vredirip; /* Where our Video RTP should be going if not to us */
334 int redircodecs; /* Redirect codecs */
335 struct sockaddr_in recv; /* Received as */
336 struct in_addr ourip; /* Our IP */
337 struct ast_channel *owner; /* Who owns us */
338 char exten[AST_MAX_EXTENSION]; /* Extension where to start */
339 char refer_to[AST_MAX_EXTENSION]; /* Place to store REFER-TO extension */
340 char referred_by[AST_MAX_EXTENSION]; /* Place to store REFERRED-BY extension */
341 char refer_contact[AST_MAX_EXTENSION]; /* Place to store Contact info from a REFER extension */
342 struct sip_pvt *refer_call; /* Call we are referring */
343 struct sip_route *route; /* Head of linked list of routing steps (fm Record-Route) */
344 int route_persistant; /* Is this the "real" route? */
345 char from[256]; /* The From: header */
346 char useragent[256]; /* User agent in SIP request */
347 char context[AST_MAX_EXTENSION]; /* Context for this call */
348 char fromdomain[AST_MAX_EXTENSION]; /* Domain to show in the from field */
349 char fromuser[AST_MAX_EXTENSION]; /* Domain to show in the user field */
350 char tohost[AST_MAX_EXTENSION]; /* Host we should put in the "to" field */
351 char language[MAX_LANGUAGE]; /* Default language for this call */
352 char musicclass[MAX_LANGUAGE]; /* Music on Hold class */
353 char rdnis[256]; /* Referring DNIS */
354 char theirtag[256]; /* Their tag */
357 char authname[256]; /* Who we use for authentication */
358 char uri[256]; /* Original requested URI */
359 char okcontacturi[256]; /* URI from the 200 OK on INVITE */
360 char peersecret[256]; /* Password */
361 char peermd5secret[256];
362 char cid_num[256]; /* Caller*ID */
363 char cid_name[256]; /* Caller*ID */
364 char via[256]; /* Via: header */
365 char fullcontact[128]; /* The Contact: that the UA registers with us */
366 char accountcode[20]; /* Account code */
367 char our_contact[256]; /* Our contact header */
368 char realm[256]; /* Authorization realm */
369 char nonce[256]; /* Authorization nonce */
370 char opaque[256]; /* Opaque nonsense */
371 char qop[80]; /* Quality of Protection, since SIP wasn't complicated enough yet. */
372 char domain[256]; /* Authorization domain */
373 char lastmsg[256]; /* Last Message sent/received */
374 int amaflags; /* AMA Flags */
375 int pendinginvite; /* Any pending invite */
377 int osphandle; /* OSP Handle for call */
378 time_t ospstart; /* OSP Start time */
380 struct sip_request initreq; /* Initial request */
382 int maxtime; /* Max time for first response */
383 int initid; /* Auto-congest ID if appropriate */
384 int autokillid; /* Auto-kill ID */
385 time_t lastrtprx; /* Last RTP received */
386 time_t lastrtptx; /* Last RTP sent */
387 int rtptimeout; /* RTP timeout time */
388 int rtpholdtimeout; /* RTP timeout when on hold */
389 int rtpkeepalive; /* Send RTP packets for keepalive */
391 int subscribed; /* Is this call a subscription? */
397 struct sip_peer *peerpoke; /* If this calls is to poke a peer, which one */
398 struct sip_registry *registry; /* If this is a REGISTER call, to which registry */
399 struct ast_rtp *rtp; /* RTP Session */
400 struct ast_rtp *vrtp; /* Video RTP session */
401 struct sip_pkt *packets; /* Packets scheduled for re-transmission */
402 struct sip_history *history; /* History of this SIP dialog */
403 struct ast_variable *vars;
404 struct sip_pvt *next; /* Next call in chain */
407 #define FLAG_RESPONSE (1 << 0)
408 #define FLAG_FATAL (1 << 1)
410 /* sip packet - read in sipsock_read, transmitted in send_request */
412 struct sip_pkt *next; /* Next packet */
413 int retrans; /* Retransmission number */
414 int seqno; /* Sequence number */
415 unsigned int flags; /* non-zero if this is a response packet (e.g. 200 OK) */
416 struct sip_pvt *owner; /* Owner call */
417 int retransid; /* Retransmission ID */
418 int packetlen; /* Length of packet */
422 /* Structure for SIP user data. User's place calls to us */
424 /* Users who can access various contexts */
425 ASTOBJ_COMPONENTS(struct sip_user);
426 char secret[80]; /* Password */
427 char md5secret[80]; /* Password in md5 */
428 char context[80]; /* Default context for incoming calls */
429 char cid_num[80]; /* Caller ID num */
430 char cid_name[80]; /* Caller ID name */
431 char accountcode[20]; /* Account code */
432 char language[MAX_LANGUAGE]; /* Default language for this user */
433 char musicclass[MAX_LANGUAGE]; /* Music on Hold class */
434 char useragent[256]; /* User agent in SIP request */
435 struct ast_codec_pref prefs; /* codec prefs */
436 ast_group_t callgroup; /* Call group */
437 ast_group_t pickupgroup; /* Pickup Group */
438 unsigned int flags; /* SIP_ flags */
439 int amaflags; /* AMA flags for billing */
440 int callingpres; /* Calling id presentation */
441 int capability; /* Codec capability */
446 struct ast_ha *ha; /* ACL setting */
447 struct ast_variable *vars;
450 /* Structure for SIP peer data, we place calls to peers if registred or fixed IP address (host) */
452 ASTOBJ_COMPONENTS(struct sip_peer);
453 char secret[80]; /* Password */
454 char md5secret[80]; /* Password in MD5 */
455 char context[80]; /* Default context for incoming calls */
456 char username[80]; /* Temporary username until registration */
457 char tohost[80]; /* If not dynamic, IP address */
458 char regexten[AST_MAX_EXTENSION]; /* Extension to register (if regcontext is used) */
459 char fromuser[80]; /* From: user when calling this peer */
460 char fromdomain[80]; /* From: domain when calling this peer */
461 char fullcontact[128]; /* Contact registred with us (not in sip.conf) */
462 char cid_num[80]; /* Caller ID num */
463 char cid_name[80]; /* Caller ID name */
464 char mailbox[AST_MAX_EXTENSION]; /* Mailbox setting for MWI checks */
465 char language[MAX_LANGUAGE]; /* Default language for prompts */
466 char musicclass[MAX_LANGUAGE]; /* Music on Hold class */
467 char useragent[256]; /* User agent in SIP request (saved from registration) */
468 struct ast_codec_pref prefs; /* codec prefs */
470 time_t lastmsgcheck; /* Last time we checked for MWI */
471 unsigned int flags; /* SIP_ flags */
472 int expire; /* Registration expiration */
474 int capability; /* Codec capability */
477 int rtpkeepalive; /* Send RTP packets for keepalive */
478 ast_group_t callgroup; /* Call group */
479 ast_group_t pickupgroup; /* Pickup group */
480 struct sockaddr_in addr; /* IP address of peer */
484 struct sip_pvt *call; /* Call pointer */
485 int pokeexpire; /* When to expire poke (qualify= checking) */
486 int lastms; /* How long last response took (in ms), or -1 for no response */
487 int maxms; /* Max ms we will accept for the host to be up, 0 to not monitor */
488 struct timeval ps; /* Ping send time */
490 struct sockaddr_in defaddr; /* Default IP address, used until registration */
491 struct ast_ha *ha; /* Access control list */
495 AST_MUTEX_DEFINE_STATIC(sip_reload_lock);
496 static int sip_reloading = 0;
498 /* States for outbound registrations (with register= lines in sip.conf */
499 #define REG_STATE_UNREGISTERED 0
500 #define REG_STATE_REGSENT 1
501 #define REG_STATE_AUTHSENT 2
502 #define REG_STATE_REGISTERED 3
503 #define REG_STATE_REJECTED 4
504 #define REG_STATE_TIMEOUT 5
505 #define REG_STATE_NOAUTH 6
508 /* sip_registry: Registrations with other SIP proxies */
509 struct sip_registry {
510 ASTOBJ_COMPONENTS_FULL(struct sip_registry,1,1);
511 int portno; /* Optional port override */
512 char username[80]; /* Who we are registering as */
513 char authuser[80]; /* Who we *authenticate* as */
514 char hostname[80]; /* Domain or host we register to */
515 char secret[80]; /* Password or key name in []'s */
517 char contact[80]; /* Contact extension */
519 int expire; /* Sched ID of expiration */
520 int timeout; /* sched id of sip_reg_timeout */
521 int refresh; /* How often to refresh */
522 struct sip_pvt *call; /* create a sip_pvt structure for each outbound "registration call" in progress */
523 int regstate; /* Registration state (see above) */
524 int callid_valid; /* 0 means we haven't chosen callid for this registry yet. */
525 char callid[80]; /* Global CallID for this registry */
526 unsigned int ocseq; /* Sequence number we got to for REGISTERs for this registry */
527 struct sockaddr_in us; /* Who the server thinks we are */
530 char realm[256]; /* Authorization realm */
531 char nonce[256]; /* Authorization nonce */
532 char domain[256]; /* Authorization domain */
533 char opaque[256]; /* Opaque nonsense */
534 char qop[80]; /* Quality of Protection. */
536 char lastmsg[256]; /* Last Message sent/received */
539 /*--- The user list: Users and friends ---*/
540 static struct ast_user_list {
541 ASTOBJ_CONTAINER_COMPONENTS(struct sip_user);
544 /*--- The peer list: Peers and Friends ---*/
545 static struct ast_peer_list {
546 ASTOBJ_CONTAINER_COMPONENTS(struct sip_peer);
549 /*--- The register list: Other SIP proxys we register with and call ---*/
550 static struct ast_register_list {
551 ASTOBJ_CONTAINER_COMPONENTS(struct sip_registry);
556 static int __sip_do_register(struct sip_registry *r);
558 static int sipsock = -1;
561 static struct sockaddr_in bindaddr;
562 static struct sockaddr_in externip;
563 static char externhost[256] = "";
564 static time_t externexpire = 0;
565 static int externrefresh = 10;
566 static struct ast_ha *localaddr;
568 /* The list of manual NOTIFY types we know how to send */
569 struct ast_config *notify_types;
571 static struct ast_frame *sip_read(struct ast_channel *ast);
572 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req);
573 static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans);
574 static int transmit_response_with_auth(struct sip_pvt *p, char *msg, struct sip_request *req, char *rand, int reliable, char *header);
575 static int transmit_request(struct sip_pvt *p, char *msg, int inc, int reliable, int newbranch);
576 static int transmit_request_with_auth(struct sip_pvt *p, char *msg, int inc, int reliable, int newbranch);
577 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);
578 static int transmit_reinvite_with_sdp(struct sip_pvt *p);
579 static int transmit_info_with_digit(struct sip_pvt *p, char digit);
580 static int transmit_message_with_text(struct sip_pvt *p, char *text);
581 static int transmit_refer(struct sip_pvt *p, char *dest);
582 static struct sip_peer *temp_peer(char *name);
583 static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader, char *msg, int init);
584 static void free_old_route(struct sip_route *route);
585 static int build_reply_digest(struct sip_pvt *p, char *orig_header, char *digest, int digest_len);
586 static int update_user_counter(struct sip_pvt *fup, int event);
587 static void prune_peers(void);
588 static int sip_do_reload(void);
591 /*--- sip_debug_test_addr: See if we pass debug IP filter */
592 static inline int sip_debug_test_addr(struct sockaddr_in *addr)
596 if (debugaddr.sin_addr.s_addr) {
597 if (((ntohs(debugaddr.sin_port) != 0)
598 && (debugaddr.sin_port != addr->sin_port))
599 || (debugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
605 static inline int sip_debug_test_pvt(struct sip_pvt *p)
609 return sip_debug_test_addr(((ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE) ? &p->recv : &p->sa));
613 /*--- __sip_xmit: Transmit SIP message ---*/
614 static int __sip_xmit(struct sip_pvt *p, char *data, int len)
617 char iabuf[INET_ADDRSTRLEN];
618 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
619 res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->recv, sizeof(struct sockaddr_in));
621 res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->sa, sizeof(struct sockaddr_in));
623 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));
628 static void sip_destroy(struct sip_pvt *p);
630 /*--- build_via: Build a Via header for a request ---*/
631 static void build_via(struct sip_pvt *p, char *buf, int len)
633 char iabuf[INET_ADDRSTRLEN];
635 /* z9hG4bK is a magic cookie. See RFC 3261 section 8.1.1.7 */
636 if (ast_test_flag(p, SIP_NAT) != SIP_NAT_NEVER)
637 snprintf(buf, len, "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x;rport", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ourport, p->branch);
638 else /* Work around buggy UNIDEN UIP200 firmware */
639 snprintf(buf, len, "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ourport, p->branch);
642 /*--- ast_sip_ouraddrfor: NAT fix - decide which IP address to use for ASterisk server? ---*/
643 /* Only used for outbound registrations */
644 static int ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us)
647 * Using the localaddr structure built up with localnet statements
648 * apply it to their address to see if we need to substitute our
649 * externip or can get away with our internal bindaddr
651 struct sockaddr_in theirs;
652 theirs.sin_addr = *them;
653 if (localaddr && externip.sin_addr.s_addr &&
654 ast_apply_ha(localaddr, &theirs)) {
655 char iabuf[INET_ADDRSTRLEN];
656 if (externexpire && (time(NULL) >= externexpire)) {
657 struct ast_hostent ahp;
660 externexpire += externrefresh;
661 if ((hp = ast_gethostbyname(externhost, &ahp))) {
662 memcpy(&externip.sin_addr, hp->h_addr, sizeof(externip.sin_addr));
664 ast_log(LOG_NOTICE, "Warning: Re-lookup of '%s' failed!\n", externhost);
666 memcpy(us, &externip.sin_addr, sizeof(struct in_addr));
667 ast_inet_ntoa(iabuf, sizeof(iabuf), *(struct in_addr *)&them->s_addr);
668 ast_log(LOG_DEBUG, "Target address %s is not local, substituting externip\n", iabuf);
670 else if (bindaddr.sin_addr.s_addr)
671 memcpy(us, &bindaddr.sin_addr, sizeof(struct in_addr));
673 return ast_ouraddrfor(them, us);
677 static int append_history(struct sip_pvt *p, char *event, char *data)
679 struct sip_history *hist, *prev;
683 hist = malloc(sizeof(struct sip_history));
685 memset(hist, 0, sizeof(struct sip_history));
686 snprintf(hist->event, sizeof(hist->event), "%-15s %s", event, data);
690 if ((*c == '\r') || (*c == '\n')) {
696 /* Enqueue into history */
709 /*--- retrans_pkt: Retransmit SIP message if no answer ---*/
710 static int retrans_pkt(void *data)
712 struct sip_pkt *pkt=data, *prev, *cur;
714 char iabuf[INET_ADDRSTRLEN];
715 ast_mutex_lock(&pkt->owner->lock);
716 if (pkt->retrans < MAX_RETRANS) {
718 if (sip_debug_test_pvt(pkt->owner)) {
719 if (ast_test_flag(pkt->owner, SIP_NAT) & SIP_NAT_ROUTE)
720 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));
722 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));
724 append_history(pkt->owner, "ReTx", pkt->data);
725 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
728 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");
729 append_history(pkt->owner, "MaxRetries", (ast_test_flag(pkt, FLAG_FATAL)) ? "(Critical)" : "(Non-critical)");
731 if (ast_test_flag(pkt, FLAG_FATAL)) {
732 while(pkt->owner->owner && ast_mutex_trylock(&pkt->owner->owner->lock)) {
733 ast_mutex_unlock(&pkt->owner->lock);
735 ast_mutex_lock(&pkt->owner->lock);
737 if (pkt->owner->owner) {
738 ast_set_flag(pkt->owner, SIP_ALREADYGONE);
739 ast_queue_hangup(pkt->owner->owner);
740 ast_mutex_unlock(&pkt->owner->owner->lock);
742 /* If no owner, destroy now */
743 ast_set_flag(pkt->owner, SIP_NEEDDESTROY);
746 /* In any case, go ahead and remove the packet */
748 cur = pkt->owner->packets;
757 prev->next = cur->next;
759 pkt->owner->packets = cur->next;
760 ast_mutex_unlock(&pkt->owner->lock);
764 ast_log(LOG_WARNING, "Weird, couldn't find packet owner!\n");
767 ast_mutex_unlock(&pkt->owner->lock);
771 /*--- __sip_reliable_xmit: transmit packet with retransmits ---*/
772 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal)
775 pkt = malloc(sizeof(struct sip_pkt) + len + 1);
778 memset(pkt, 0, sizeof(struct sip_pkt));
779 memcpy(pkt->data, data, len);
780 pkt->packetlen = len;
781 pkt->next = p->packets;
785 pkt->data[len] = '\0';
787 ast_set_flag(pkt, FLAG_FATAL);
788 /* Schedule retransmission */
789 pkt->retransid = ast_sched_add(sched, DEFAULT_RETRANS, retrans_pkt, pkt);
790 pkt->next = p->packets;
792 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
793 if (!strncasecmp(pkt->data, "INVITE", 6)) {
794 /* Note this is a pending invite */
795 p->pendinginvite = seqno;
800 /*--- __sip_autodestruct: Kill a call (called by scheduler) ---*/
801 static int __sip_autodestruct(void *data)
803 struct sip_pvt *p = data;
805 ast_log(LOG_DEBUG, "Auto destroying call '%s'\n", p->callid);
806 append_history(p, "AutoDestroy", "");
808 ast_log(LOG_WARNING, "Autodestruct on call '%s' with owner in place\n", p->callid);
809 ast_queue_hangup(p->owner);
816 /*--- sip_scheddestroy: Schedule destruction of SIP call ---*/
817 static int sip_scheddestroy(struct sip_pvt *p, int ms)
820 if (sip_debug_test_pvt(p))
821 ast_verbose("Scheduling destruction of call '%s' in %d ms\n", p->callid, ms);
823 snprintf(tmp, sizeof(tmp), "%d ms", ms);
824 append_history(p, "SchedDestroy", tmp);
826 if (p->autokillid > -1)
827 ast_sched_del(sched, p->autokillid);
828 p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, p);
832 /*--- sip_cancel_destroy: Cancel destruction of SIP call ---*/
833 static int sip_cancel_destroy(struct sip_pvt *p)
835 if (p->autokillid > -1)
836 ast_sched_del(sched, p->autokillid);
837 append_history(p, "CancelDestroy", "");
842 /*--- __sip_ack: Acknowledges receipt of a packet and stops retransmission ---*/
843 static int __sip_ack(struct sip_pvt *p, int seqno, int resp, const char *msg)
845 struct sip_pkt *cur, *prev = NULL;
848 /* Just in case... */
849 if (!msg) msg = "___NEVER___";
852 if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
853 ((ast_test_flag(cur, FLAG_RESPONSE)) ||
854 (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
855 if (!resp && (seqno == p->pendinginvite)) {
856 ast_log(LOG_DEBUG, "Acked pending invite %d\n", p->pendinginvite);
857 p->pendinginvite = 0;
860 /* this is our baby */
862 prev->next = cur->next;
864 p->packets = cur->next;
865 if (cur->retransid > -1)
866 ast_sched_del(sched, cur->retransid);
874 ast_log(LOG_DEBUG, "Stopping retransmission on '%s' of %s %d: %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
878 /* Pretend to ack all packets */
879 static int __sip_pretend_ack(struct sip_pvt *p)
882 __sip_ack(p, p->packets->seqno, (ast_test_flag(p->packets, FLAG_RESPONSE)), p->packets->data);
887 /*--- __sip_semi_ack: Acks receipt of packet, keep it around (used for provisional responses) ---*/
888 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp, const char *msg)
894 if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
895 ((ast_test_flag(cur, FLAG_RESPONSE)) ||
896 (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
897 /* this is our baby */
898 if (cur->retransid > -1)
899 ast_sched_del(sched, cur->retransid);
906 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");
910 static void parse(struct sip_request *req);
911 static char *get_header(struct sip_request *req, char *name);
912 static void copy_request(struct sip_request *dst,struct sip_request *src);
914 static void parse_copy(struct sip_request *dst, struct sip_request *src)
916 memset(dst, 0, sizeof(*dst));
917 memcpy(dst->data, src->data, sizeof(dst->data));
921 /*--- send_response: Transmit response on SIP request---*/
922 static int send_response(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
925 char iabuf[INET_ADDRSTRLEN];
926 struct sip_request tmp;
928 if (sip_debug_test_pvt(p)) {
929 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
930 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));
932 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));
936 parse_copy(&tmp, req);
937 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
938 append_history(p, "TxRespRel", tmpmsg);
940 res = __sip_reliable_xmit(p, seqno, 1, req->data, req->len, (reliable > 1));
943 parse_copy(&tmp, req);
944 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
945 append_history(p, "TxResp", tmpmsg);
947 res = __sip_xmit(p, req->data, req->len);
954 /*--- send_request: Send SIP Request to the other part of the dialogue ---*/
955 static int send_request(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
958 char iabuf[INET_ADDRSTRLEN];
959 struct sip_request tmp;
961 if (sip_debug_test_pvt(p)) {
962 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
963 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));
965 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));
969 parse_copy(&tmp, req);
970 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
971 append_history(p, "TxReqRel", tmpmsg);
973 res = __sip_reliable_xmit(p, seqno, 0, req->data, req->len, (reliable > 1));
976 parse_copy(&tmp, req);
977 snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
978 append_history(p, "TxReq", tmpmsg);
980 res = __sip_xmit(p, req->data, req->len);
985 /*--- url_decode: Decode SIP URL ---*/
986 static void url_decode(char *s)
994 if (sscanf(s + 1, "%2x", &tmp) == 1) {
996 s += 2; /* Will be incremented once more when we break out */
1000 /* Fall through if something wasn't right with the formatting */
1010 /*--- ditch_braces: Pick out text in braces from character string ---*/
1011 static char *ditch_braces(char *tmp)
1016 if ((q = strchr(tmp, '"')) ) {
1018 if ((q = strchr(c, '"')) )
1021 ast_log(LOG_WARNING, "No closing quote in '%s'\n", tmp);
1025 if ((n = strchr(c, '<')) ) {
1027 while(*c && *c != '>') c++;
1029 ast_log(LOG_WARNING, "No closing brace in '%s'\n", tmp);
1038 /*--- sip_sendtext: Send SIP MESSAGE text within a call ---*/
1039 /* Called from PBX core text message functions */
1040 static int sip_sendtext(struct ast_channel *ast, char *text)
1042 struct sip_pvt *p = ast->pvt->pvt;
1043 int debug=sip_debug_test_pvt(p);
1046 ast_verbose("Sending text %s on %s\n", text, ast->name);
1049 if (!text || ast_strlen_zero(text))
1052 ast_verbose("Really sending text %s on %s\n", text, ast->name);
1053 transmit_message_with_text(p, text);
1057 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, const char *username, int expirey)
1061 char regseconds[20];
1066 snprintf(regseconds, sizeof(regseconds), "%ld", nowtime);
1067 ast_inet_ntoa(ipaddr, sizeof(ipaddr), sin->sin_addr);
1068 snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
1069 ast_update_realtime("sipfriends", "name", peername, "ipaddr", ipaddr, "port", port, "regseconds", regseconds, "username", username, NULL);
1072 static void register_peer_exten(struct sip_peer *peer, int onoff)
1074 unsigned char multi[256]="";
1075 char *stringp, *ext;
1076 if (!ast_strlen_zero(regcontext)) {
1077 strncpy(multi, ast_strlen_zero(peer->regexten) ? peer->name : peer->regexten, sizeof(multi) - 1);
1079 while((ext = strsep(&stringp, "&"))) {
1081 ast_add_extension(regcontext, 1, ext, 1, NULL, NULL, "Noop", strdup(peer->name), free, channeltype);
1083 ast_context_remove_extension(regcontext, ext, 1, NULL);
1088 static void sip_destroy_peer(struct sip_peer *peer)
1090 /* Delete it, it needs to disappear */
1092 sip_destroy(peer->call);
1093 if (peer->expire > -1)
1094 ast_sched_del(sched, peer->expire);
1095 if (peer->pokeexpire > -1)
1096 ast_sched_del(sched, peer->pokeexpire);
1097 register_peer_exten(peer, 0);
1098 ast_free_ha(peer->ha);
1099 if (ast_test_flag(peer, SIP_SELFDESTRUCT))
1101 else if (ast_test_flag(peer, SIP_REALTIME))
1108 /*--- update_peer: Update peer data in database (if used) ---*/
1109 static void update_peer(struct sip_peer *p, int expiry)
1111 if (ast_test_flag(p, SIP_REALTIME))
1112 realtime_update_peer(p->name, &p->addr, p->username, expiry);
1115 static struct sip_peer *build_peer(const char *name, struct ast_variable *v, int realtime);
1117 static struct sip_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
1119 struct sip_peer *peer=NULL;
1120 struct ast_variable *var;
1121 struct ast_variable *tmp;
1124 var = ast_load_realtime("sipfriends", "name", peername, NULL);
1128 ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr);
1129 var = ast_load_realtime("sipfriends", "ipaddr", iabuf, NULL);
1138 if (!strcasecmp(tmp->name, "type") &&
1139 !strcasecmp(tmp->value, "user")) {
1140 ast_destroy_realtime(var);
1146 peer = build_peer(peername, var, 1);
1148 ast_set_flag(peer, SIP_REALTIME);
1149 ast_destroy_realtime(var);
1153 static int sip_addrcmp(char *name, struct sockaddr_in *sin)
1155 /* We know name is the first field, so we can cast */
1156 struct sip_peer *p = (struct sip_peer *)name;
1157 return !(!inaddrcmp(&p->addr, sin) ||
1158 (ast_test_flag(p, SIP_INSECURE) &&
1159 (p->addr.sin_addr.s_addr == sin->sin_addr.s_addr)));
1162 /*--- find_peer: Locate peer by name or ip address */
1163 static struct sip_peer *find_peer(const char *peer, struct sockaddr_in *sin)
1165 struct sip_peer *p = NULL;
1168 p = ASTOBJ_CONTAINER_FIND(&peerl,peer);
1170 p = ASTOBJ_CONTAINER_FIND_FULL(&peerl,sin,name,sip_addr_hashfunc,1,sip_addrcmp);
1173 p = realtime_peer(peer, sin);
1179 static void sip_destroy_user(struct sip_user *user)
1181 ast_free_ha(user->ha);
1183 ast_destroy_realtime(user->vars);
1186 if (ast_test_flag(user, SIP_REALTIME))
1193 static struct sip_user *build_user(const char *name, struct ast_variable *v, int realtime);
1194 static struct sip_user *realtime_user(const char *username)
1196 struct ast_variable *var;
1197 struct ast_variable *tmp;
1198 struct sip_user *user = NULL;
1200 var = ast_load_realtime("sipfriends", "name", username, NULL);
1207 if (!strcasecmp(tmp->name, "type") &&
1208 !strcasecmp(tmp->value, "peer")) {
1209 ast_destroy_realtime(var);
1215 user = build_user(username, var, 1);
1217 /* Move counter from s to r... */
1220 /* Add some finishing touches, addresses, etc */
1221 ast_set_flag(user, SIP_REALTIME);
1223 ast_destroy_realtime(var);
1227 /*--- find_user: Locate user by name */
1228 static struct sip_user *find_user(const char *name)
1230 struct sip_user *u = NULL;
1231 u = ASTOBJ_CONTAINER_FIND(&userl,name);
1233 u = realtime_user(name);
1238 /*--- create_addr: create address structure from peer definition ---*/
1239 /* Or, if peer not found, find it in the global DNS */
1240 /* returns TRUE on failure, FALSE on success */
1241 static int create_addr(struct sip_pvt *r, char *opeer)
1244 struct ast_hostent ahp;
1250 char host[256], *hostn;
1253 strncpy(peer, opeer, sizeof(peer) - 1);
1254 port = strchr(peer, ':');
1259 r->sa.sin_family = AF_INET;
1260 p = find_peer(peer, NULL);
1264 ast_copy_flags(r, p, SIP_PROMISCREDIR | SIP_USEREQPHONE | SIP_DTMF | SIP_NAT | SIP_REINVITE | SIP_INSECURE);
1265 r->capability = p->capability;
1267 ast_log(LOG_DEBUG, "Setting NAT on RTP to %d\n", (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1268 ast_rtp_setnat(r->rtp, (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1271 ast_log(LOG_DEBUG, "Setting NAT on VRTP to %d\n", (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1272 ast_rtp_setnat(r->vrtp, (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1274 strncpy(r->peername, p->username, sizeof(r->peername)-1);
1275 strncpy(r->authname, p->username, sizeof(r->authname)-1);
1276 strncpy(r->peersecret, p->secret, sizeof(r->peersecret)-1);
1277 strncpy(r->peermd5secret, p->md5secret, sizeof(r->peermd5secret)-1);
1278 strncpy(r->username, p->username, sizeof(r->username)-1);
1279 strncpy(r->tohost, p->tohost, sizeof(r->tohost)-1);
1280 strncpy(r->fullcontact, p->fullcontact, sizeof(r->fullcontact)-1);
1281 if (!r->initreq.headers && !ast_strlen_zero(p->fromdomain)) {
1282 if ((callhost = strchr(r->callid, '@'))) {
1283 strncpy(callhost + 1, p->fromdomain, sizeof(r->callid) - (callhost - r->callid) - 2);
1286 if (ast_strlen_zero(r->tohost)) {
1287 if (p->addr.sin_addr.s_addr)
1288 ast_inet_ntoa(r->tohost, sizeof(r->tohost), p->addr.sin_addr);
1290 ast_inet_ntoa(r->tohost, sizeof(r->tohost), p->defaddr.sin_addr);
1292 if (!ast_strlen_zero(p->fromdomain))
1293 strncpy(r->fromdomain, p->fromdomain, sizeof(r->fromdomain)-1);
1294 if (!ast_strlen_zero(p->fromuser))
1295 strncpy(r->fromuser, p->fromuser, sizeof(r->fromuser)-1);
1296 r->maxtime = p->maxms;
1297 r->callgroup = p->callgroup;
1298 r->pickupgroup = p->pickupgroup;
1299 if (ast_test_flag(r, SIP_DTMF) == SIP_DTMF_RFC2833)
1300 r->noncodeccapability |= AST_RTP_DTMF;
1302 r->noncodeccapability &= ~AST_RTP_DTMF;
1303 strncpy(r->context, p->context,sizeof(r->context)-1);
1304 if ((p->addr.sin_addr.s_addr || p->defaddr.sin_addr.s_addr) &&
1305 (!p->maxms || ((p->lastms >= 0) && (p->lastms <= p->maxms)))) {
1306 if (p->addr.sin_addr.s_addr) {
1307 r->sa.sin_addr = p->addr.sin_addr;
1308 r->sa.sin_port = p->addr.sin_port;
1310 r->sa.sin_addr = p->defaddr.sin_addr;
1311 r->sa.sin_port = p->defaddr.sin_port;
1313 memcpy(&r->recv, &r->sa, sizeof(r->recv));
1315 ASTOBJ_UNREF(p,sip_destroy_peer);
1321 portno = atoi(port);
1323 portno = DEFAULT_SIP_PORT;
1328 snprintf(service, sizeof(service), "_sip._udp.%s", peer);
1329 ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service);
1335 hp = ast_gethostbyname(hostn, &ahp);
1337 strncpy(r->tohost, peer, sizeof(r->tohost) - 1);
1338 memcpy(&r->sa.sin_addr, hp->h_addr, sizeof(r->sa.sin_addr));
1339 r->sa.sin_port = htons(portno);
1340 memcpy(&r->recv, &r->sa, sizeof(r->recv));
1343 ast_log(LOG_WARNING, "No such host: %s\n", peer);
1349 ASTOBJ_UNREF(p,sip_destroy_peer);
1354 /*--- auto_congest: Scheduled congestion on a call ---*/
1355 static int auto_congest(void *nothing)
1357 struct sip_pvt *p = nothing;
1358 ast_mutex_lock(&p->lock);
1361 if (!ast_mutex_trylock(&p->owner->lock)) {
1362 ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name);
1363 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
1364 ast_mutex_unlock(&p->owner->lock);
1367 ast_mutex_unlock(&p->lock);
1374 /*--- sip_call: Initiate SIP call from PBX ---*/
1375 /* used from the dial() application */
1376 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
1380 char *vxml_url = NULL;
1381 char *distinctive_ring = NULL;
1382 char *osptoken = NULL;
1384 char *osphandle = NULL;
1386 struct varshead *headp;
1387 struct ast_var_t *current;
1388 int addsipheaders = 0;
1391 if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
1392 ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
1395 /* Check whether there is vxml_url, distinctive ring variables */
1397 headp=&ast->varshead;
1398 AST_LIST_TRAVERSE(headp,current,entries) {
1399 /* Check whether there is a VXML_URL variable */
1400 if (!vxml_url && !strcasecmp(ast_var_name(current),"VXML_URL")) {
1401 vxml_url = ast_var_value(current);
1402 } else if (!distinctive_ring && !strcasecmp(ast_var_name(current),"ALERT_INFO")) {
1403 /* Check whether there is a ALERT_INFO variable */
1404 distinctive_ring = ast_var_value(current);
1405 } else if (!addsipheaders && !strncasecmp(ast_var_name(current),"SIPADDHEADER",strlen("SIPADDHEADER"))) {
1406 /* Check whether there is a variable with a name starting with SIPADDHEADER */
1412 else if (!osptoken && !strcasecmp(ast_var_name(current), "OSPTOKEN")) {
1413 osptoken = ast_var_value(current);
1414 } else if (!osphandle && !strcasecmp(ast_var_name(current), "OSPHANDLE")) {
1415 osphandle = ast_var_value(current);
1421 ast_set_flag(p, SIP_OUTGOING);
1423 if (!osptoken || !osphandle || (sscanf(osphandle, "%i", &p->osphandle) != 1)) {
1424 /* Force Disable OSP support */
1425 ast_log(LOG_DEBUG, "Disabling OSP support for this call. osptoken = %s, osphandle = %s\n", osptoken, osphandle);
1431 ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);
1432 res = update_user_counter(p,INC_OUT_USE);
1434 p->callingpres = ast->cid.cid_pres;
1435 p->jointcapability = p->capability;
1436 transmit_invite(p, "INVITE", 1, NULL, NULL, vxml_url,distinctive_ring, osptoken, addsipheaders, 1);
1438 /* Initialize auto-congest time */
1439 p->initid = ast_sched_add(sched, p->maxtime * 4, auto_congest, p);
1445 static void sip_registry_destroy(struct sip_registry *reg)
1449 /* Clear registry before destroying to ensure
1450 we don't get reentered trying to grab the registry lock */
1451 reg->call->registry = NULL;
1452 sip_destroy(reg->call);
1454 if (reg->expire > -1)
1455 ast_sched_del(sched, reg->expire);
1456 if (reg->timeout > -1)
1457 ast_sched_del(sched, reg->timeout);
1463 /*--- __sip_destroy: Execute destrucion of call structure, release memory---*/
1464 static void __sip_destroy(struct sip_pvt *p, int lockowner)
1466 struct sip_pvt *cur, *prev = NULL;
1468 struct sip_history *hist;
1470 if (sip_debug_test_pvt(p))
1471 ast_verbose("Destroying call '%s'\n", p->callid);
1472 if (p->stateid > -1)
1473 ast_extension_state_del(p->stateid, NULL);
1475 ast_sched_del(sched, p->initid);
1476 if (p->autokillid > -1)
1477 ast_sched_del(sched, p->autokillid);
1480 ast_rtp_destroy(p->rtp);
1483 ast_rtp_destroy(p->vrtp);
1486 free_old_route(p->route);
1490 if (p->registry->call == p)
1491 p->registry->call = NULL;
1492 ASTOBJ_UNREF(p->registry,sip_registry_destroy);
1494 /* Unlink us from the owner if we have one */
1497 ast_mutex_lock(&p->owner->lock);
1498 ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
1499 p->owner->pvt->pvt = NULL;
1501 ast_mutex_unlock(&p->owner->lock);
1506 p->history = p->history->next;
1513 prev->next = cur->next;
1522 ast_log(LOG_WARNING, "%p is not in list?!?! \n", cur);
1525 ast_sched_del(sched, p->initid);
1526 while((cp = p->packets)) {
1527 p->packets = p->packets->next;
1528 if (cp->retransid > -1)
1529 ast_sched_del(sched, cp->retransid);
1532 ast_mutex_destroy(&p->lock);
1534 ast_destroy_realtime(p->vars);
1541 /*--- update_user_counter: Handle incominglimit and outgoinglimit for SIP users ---*/
1542 /* Note: This is going to be replaced by app_groupcount */
1543 static int update_user_counter(struct sip_pvt *fup, int event)
1545 char name[256] = "";
1547 strncpy(name, fup->username, sizeof(name) - 1);
1548 u = find_user(name);
1550 ast_log(LOG_DEBUG, "%s is not a local user\n", name);
1554 /* incoming and outgoing affects the inUse counter */
1557 if ( u->inUse > 0 ) {
1565 if (u->incominglimit > 0 ) {
1566 if (u->inUse >= u->incominglimit) {
1567 ast_log(LOG_ERROR, "Call from user '%s' rejected due to usage limit of %d\n", u->name, u->incominglimit);
1568 /* inc inUse as well */
1569 if ( event == INC_OUT_USE ) {
1572 ASTOBJ_UNREF(u,sip_destroy_user);
1577 ast_log(LOG_DEBUG, "Call from user '%s' is %d out of %d\n", u->name, u->inUse, u->incominglimit);
1579 /* we don't use these anymore
1581 if ( u->outUse > 0 ) {
1588 if ( u->outgoinglimit > 0 ) {
1589 if ( u->outUse >= u->outgoinglimit ) {
1590 ast_log(LOG_ERROR, "Outgoing call from user '%s' rejected due to usage limit of %d\n", u->name, u->outgoinglimit);
1591 ast_mutex_unlock(&userl.lock);
1602 ast_log(LOG_ERROR, "update_user_counter(%s,%d) called with no event!\n",u->name,event);
1604 ASTOBJ_UNREF(u,sip_destroy_user);
1608 /*--- sip_destroy: Destroy SIP call structure ---*/
1609 static void sip_destroy(struct sip_pvt *p)
1611 ast_mutex_lock(&iflock);
1612 __sip_destroy(p, 1);
1613 ast_mutex_unlock(&iflock);
1617 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal);
1619 static int hangup_sip2cause(int cause)
1621 /* Possible values from causes.h
1622 AST_CAUSE_NOTDEFINED AST_CAUSE_NORMAL AST_CAUSE_BUSY
1623 AST_CAUSE_FAILURE AST_CAUSE_CONGESTION AST_CAUSE_UNALLOCATED
1627 case 404: /* Not found */
1628 return AST_CAUSE_UNALLOCATED;
1629 case 483: /* Too many hops */
1630 return AST_CAUSE_FAILURE;
1632 return AST_CAUSE_BUSY;
1634 return AST_CAUSE_NORMAL;
1640 static char *hangup_cause2sip(int cause)
1644 case AST_CAUSE_FAILURE:
1645 return "500 Server internal failure";
1646 case AST_CAUSE_CONGESTION:
1647 return "503 Service Unavailable";
1648 case AST_CAUSE_BUSY:
1657 /*--- sip_hangup: Hangup SIP call */
1658 static int sip_hangup(struct ast_channel *ast)
1660 struct sip_pvt *p = ast->pvt->pvt;
1662 struct ast_flags locflags = {0};
1664 ast_log(LOG_DEBUG, "sip_hangup(%s)\n", ast->name);
1665 if (!ast->pvt->pvt) {
1666 ast_log(LOG_DEBUG, "Asked to hangup channel not connected\n");
1669 ast_mutex_lock(&p->lock);
1671 if ((p->osphandle > -1) && (ast->_state == AST_STATE_UP)) {
1672 ast_osp_terminate(p->osphandle, AST_CAUSE_NORMAL, p->ospstart, time(NULL) - p->ospstart);
1675 if (ast_test_flag(p, SIP_OUTGOING)) {
1676 ast_log(LOG_DEBUG, "update_user_counter(%s) - decrement outUse counter\n", p->username);
1677 update_user_counter(p, DEC_OUT_USE);
1679 ast_log(LOG_DEBUG, "update_user_counter(%s) - decrement inUse counter\n", p->username);
1680 update_user_counter(p, DEC_IN_USE);
1682 /* Determine how to disconnect */
1683 if (p->owner != ast) {
1684 ast_log(LOG_WARNING, "Huh? We aren't the owner?\n");
1685 ast_mutex_unlock(&p->lock);
1688 if (!ast || (ast->_state != AST_STATE_UP))
1693 ast_dsp_free(p->vad);
1696 ast->pvt->pvt = NULL;
1698 ast_mutex_lock(&usecnt_lock);
1700 ast_mutex_unlock(&usecnt_lock);
1701 ast_update_use_count();
1703 ast_set_flag(&locflags, SIP_NEEDDESTROY);
1704 /* Start the process if it's not already started */
1705 if (!ast_test_flag(p, SIP_ALREADYGONE) && !ast_strlen_zero(p->initreq.data)) {
1707 if (ast_test_flag(p, SIP_OUTGOING)) {
1708 transmit_request_with_auth(p, "CANCEL", p->ocseq, 1, 0);
1709 /* Actually don't destroy us yet, wait for the 487 on our original
1710 INVITE, but do set an autodestruct just in case we never get it. */
1711 ast_clear_flag(&locflags, SIP_NEEDDESTROY);
1712 sip_scheddestroy(p, 15000);
1713 if ( p->initid != -1 ) {
1714 /* channel still up - reverse dec of inUse counter
1715 only if the channel is not auto-congested */
1716 if (ast_test_flag(p, SIP_OUTGOING)) {
1717 update_user_counter(p, INC_OUT_USE);
1720 update_user_counter(p, INC_IN_USE);
1725 if (ast->hangupcause && ((res = hangup_cause2sip(ast->hangupcause)))) {
1726 transmit_response_reliable(p, res, &p->initreq, 1);
1728 transmit_response_reliable(p, "403 Forbidden", &p->initreq, 1);
1731 if (!p->pendinginvite) {
1733 transmit_request_with_auth(p, "BYE", 0, 1, 1);
1735 /* Note we will need a BYE when this all settles out
1736 but we can't send one while we have "INVITE" outstanding. */
1737 ast_set_flag(p, SIP_PENDINGBYE);
1738 ast_clear_flag(p, SIP_NEEDREINVITE);
1742 ast_copy_flags(p, (&locflags), SIP_NEEDDESTROY);
1743 ast_mutex_unlock(&p->lock);
1747 /*--- sip_answer: Answer SIP call , send 200 OK on Invite */
1748 static int sip_answer(struct ast_channel *ast)
1752 struct sip_pvt *p = ast->pvt->pvt;
1754 ast_mutex_lock(&p->lock);
1755 if (ast->_state != AST_STATE_UP) {
1760 codec=pbx_builtin_getvar_helper(p->owner,"SIP_CODEC");
1762 fmt=ast_getformatbyname(codec);
1764 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC) variable\n",codec);
1765 if (p->jointcapability & fmt) {
1766 p->jointcapability &= fmt;
1767 p->capability &= fmt;
1769 ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because it is not shared by both ends.\n");
1770 } else ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n",codec);
1773 ast_setstate(ast, AST_STATE_UP);
1775 ast_log(LOG_DEBUG, "sip_answer(%s)\n", ast->name);
1776 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, 1);
1778 ast_mutex_unlock(&p->lock);
1782 /*--- sip_write: Send response, support audio media ---*/
1783 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
1785 struct sip_pvt *p = ast->pvt->pvt;
1787 if (frame->frametype == AST_FRAME_VOICE) {
1788 if (!(frame->subclass & ast->nativeformats)) {
1789 ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
1790 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
1794 ast_mutex_lock(&p->lock);
1796 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
1797 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1798 ast_set_flag(p, SIP_PROGRESS_SENT);
1800 time(&p->lastrtptx);
1801 res = ast_rtp_write(p->rtp, frame);
1803 ast_mutex_unlock(&p->lock);
1805 } else if (frame->frametype == AST_FRAME_VIDEO) {
1807 ast_mutex_lock(&p->lock);
1809 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
1810 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1811 ast_set_flag(p, SIP_PROGRESS_SENT);
1813 time(&p->lastrtptx);
1814 res = ast_rtp_write(p->vrtp, frame);
1816 ast_mutex_unlock(&p->lock);
1818 } else if (frame->frametype == AST_FRAME_IMAGE) {
1821 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
1828 /*--- sip_fixup: Fix up a channel: If a channel is consumed, this is called.
1829 Basically update any ->owner links ----*/
1830 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
1832 struct sip_pvt *p = newchan->pvt->pvt;
1833 ast_mutex_lock(&p->lock);
1834 if (p->owner != oldchan) {
1835 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
1836 ast_mutex_unlock(&p->lock);
1840 ast_mutex_unlock(&p->lock);
1844 /*--- sip_senddigit: Send DTMF character on SIP channel */
1845 /* within one call, we're able to transmit in many methods simultaneously */
1846 static int sip_senddigit(struct ast_channel *ast, char digit)
1848 struct sip_pvt *p = ast->pvt->pvt;
1850 ast_mutex_lock(&p->lock);
1851 switch (ast_test_flag(p, SIP_DTMF)) {
1853 transmit_info_with_digit(p, digit);
1855 case SIP_DTMF_RFC2833:
1857 ast_rtp_senddigit(p->rtp, digit);
1859 case SIP_DTMF_INBAND:
1863 ast_mutex_unlock(&p->lock);
1868 /*--- sip_transfer: Transfer SIP call */
1869 static int sip_transfer(struct ast_channel *ast, char *dest)
1871 struct sip_pvt *p = ast->pvt->pvt;
1873 ast_mutex_lock(&p->lock);
1874 res = transmit_refer(p, dest);
1875 ast_mutex_unlock(&p->lock);
1879 /*--- sip_indicate: Play indication to user */
1880 /* With SIP a lot of indications is sent as messages, letting the device play
1881 the indication - busy signal, congestion etc */
1882 static int sip_indicate(struct ast_channel *ast, int condition)
1884 struct sip_pvt *p = ast->pvt->pvt;
1887 ast_mutex_lock(&p->lock);
1889 case AST_CONTROL_RINGING:
1890 if (ast->_state == AST_STATE_RING) {
1891 if (!ast_test_flag(p, SIP_PROGRESS_SENT) ||
1892 (ast_test_flag(p, SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER)) {
1893 /* Send 180 ringing if out-of-band seems reasonable */
1894 transmit_response(p, "180 Ringing", &p->initreq);
1895 ast_set_flag(p, SIP_RINGING);
1896 if (ast_test_flag(p, SIP_PROG_INBAND) != SIP_PROG_INBAND_YES)
1899 /* Well, if it's not reasonable, just send in-band */
1904 case AST_CONTROL_BUSY:
1905 if (ast->_state != AST_STATE_UP) {
1906 transmit_response(p, "486 Busy Here", &p->initreq);
1907 ast_set_flag(p, SIP_ALREADYGONE);
1908 ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1913 case AST_CONTROL_CONGESTION:
1914 if (ast->_state != AST_STATE_UP) {
1915 transmit_response(p, "503 Service Unavailable", &p->initreq);
1916 ast_set_flag(p, SIP_ALREADYGONE);
1917 ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
1922 case AST_CONTROL_PROGRESS:
1923 case AST_CONTROL_PROCEEDING:
1924 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
1925 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1926 ast_set_flag(p, SIP_PROGRESS_SENT);
1935 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
1939 ast_mutex_unlock(&p->lock);
1945 /*--- sip_new: Initiate a call in the SIP channel */
1946 /* called from sip_request_call (calls from the pbx ) */
1947 static struct ast_channel *sip_new(struct sip_pvt *i, int state, char *title)
1949 struct ast_channel *tmp;
1950 struct ast_variable *v = NULL;
1953 ast_mutex_unlock(&i->lock);
1954 /* Don't hold a sip pvt lock while we allocate a channel */
1955 tmp = ast_channel_alloc(1);
1956 ast_mutex_lock(&i->lock);
1958 /* Select our native format based on codec preference until we receive
1959 something from another device to the contrary. */
1960 ast_mutex_lock(&i->lock);
1961 if (i->jointcapability)
1962 tmp->nativeformats = ast_codec_choose(&i->prefs, i->jointcapability, 1);
1963 else if (i->capability)
1964 tmp->nativeformats = ast_codec_choose(&i->prefs, i->capability, 1);
1966 tmp->nativeformats = ast_codec_choose(&i->prefs, global_capability, 1);
1967 ast_mutex_unlock(&i->lock);
1968 fmt = ast_best_codec(tmp->nativeformats);
1970 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%04x", title, rand() & 0xffff);
1972 if (strchr(i->fromdomain,':'))
1974 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", strchr(i->fromdomain,':')+1, (int)(long)(i));
1978 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", i->fromdomain, (int)(long)(i));
1980 tmp->type = channeltype;
1981 if (ast_test_flag(i, SIP_DTMF) == SIP_DTMF_INBAND) {
1982 i->vad = ast_dsp_new();
1983 ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
1985 ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
1987 tmp->fds[0] = ast_rtp_fd(i->rtp);
1988 tmp->fds[1] = ast_rtcp_fd(i->rtp);
1990 tmp->fds[2] = ast_rtp_fd(i->vrtp);
1991 tmp->fds[3] = ast_rtcp_fd(i->vrtp);
1993 if (state == AST_STATE_RING)
1995 tmp->adsicpe = AST_ADSI_UNAVAILABLE;
1996 tmp->writeformat = fmt;
1997 tmp->pvt->rawwriteformat = fmt;
1998 tmp->readformat = fmt;
1999 tmp->pvt->rawreadformat = fmt;
2001 tmp->pvt->send_text = sip_sendtext;
2002 tmp->pvt->call = sip_call;
2003 tmp->pvt->hangup = sip_hangup;
2004 tmp->pvt->answer = sip_answer;
2005 tmp->pvt->read = sip_read;
2006 tmp->pvt->write = sip_write;
2007 tmp->pvt->write_video = sip_write;
2008 tmp->pvt->indicate = sip_indicate;
2009 tmp->pvt->transfer = sip_transfer;
2010 tmp->pvt->fixup = sip_fixup;
2011 tmp->pvt->send_digit = sip_senddigit;
2013 tmp->pvt->bridge = ast_rtp_bridge;
2015 tmp->callgroup = i->callgroup;
2016 tmp->pickupgroup = i->pickupgroup;
2017 tmp->cid.cid_pres = i->callingpres;
2018 if (!ast_strlen_zero(i->accountcode))
2019 strncpy(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode)-1);
2021 tmp->amaflags = i->amaflags;
2022 if (!ast_strlen_zero(i->language))
2023 strncpy(tmp->language, i->language, sizeof(tmp->language)-1);
2024 if (!ast_strlen_zero(i->musicclass))
2025 strncpy(tmp->musicclass, i->musicclass, sizeof(tmp->musicclass)-1);
2027 ast_mutex_lock(&usecnt_lock);
2029 ast_mutex_unlock(&usecnt_lock);
2030 strncpy(tmp->context, i->context, sizeof(tmp->context)-1);
2031 strncpy(tmp->exten, i->exten, sizeof(tmp->exten)-1);
2032 if (!ast_strlen_zero(i->cid_num))
2033 tmp->cid.cid_num = strdup(i->cid_num);
2034 if (!ast_strlen_zero(i->cid_name))
2035 tmp->cid.cid_name = strdup(i->cid_name);
2036 if (!ast_strlen_zero(i->rdnis))
2037 tmp->cid.cid_rdnis = strdup(i->rdnis);
2038 if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
2039 tmp->cid.cid_dnid = strdup(i->exten);
2041 if (!ast_strlen_zero(i->uri)) {
2042 pbx_builtin_setvar_helper(tmp, "SIPURI", i->uri);
2044 if (!ast_strlen_zero(i->domain)) {
2045 pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
2047 if (!ast_strlen_zero(i->useragent)) {
2048 pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
2050 if (!ast_strlen_zero(i->callid)) {
2051 pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
2053 ast_setstate(tmp, state);
2054 if (state != AST_STATE_DOWN) {
2055 if (ast_pbx_start(tmp)) {
2056 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
2061 for (v = i->vars ; v ; v = v->next)
2062 pbx_builtin_setvar_helper(tmp,v->name,v->value);
2065 ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
2069 static struct cfalias {
2073 { "Content-Type", "c" },
2074 { "Content-Encoding", "e" },
2078 { "Content-Length", "l" },
2081 { "Supported", "k" },
2082 { "Refer-To", "r" },
2083 { "Allow-Events", "u" },
2088 /*--- get_sdp_by_line: Reads one line of SIP message body */
2089 static char* get_sdp_by_line(char* line, char *name, int nameLen) {
2090 if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
2091 char* r = line + nameLen + 1;
2092 while (*r && (*r < 33)) ++r;
2099 /*--- get_sdp: Gets all kind of SIP message bodies, including SDP,
2100 but the name wrongly applies _only_ sdp */
2101 static char *get_sdp(struct sip_request *req, char *name) {
2103 int len = strlen(name);
2106 for (x=0; x<req->lines; x++) {
2107 r = get_sdp_by_line(req->line[x], name, len);
2108 if (r[0] != '\0') return r;
2114 static void sdpLineNum_iterator_init(int* iterator) {
2118 static char* get_sdp_iterate(int* iterator,
2119 struct sip_request *req, char *name) {
2120 int len = strlen(name);
2122 while (*iterator < req->lines) {
2123 r = get_sdp_by_line(req->line[(*iterator)++], name, len);
2124 if (r[0] != '\0') return r;
2129 static char *__get_header(struct sip_request *req, char *name, int *start)
2132 int len = strlen(name);
2134 if (pedanticsipchecking) {
2135 /* Technically you can place arbitrary whitespace both before and after the ':' in
2136 a header, although RFC3261 clearly says you shouldn't before, and place just
2137 one afterwards. If you shouldn't do it, what absolute idiot decided it was
2138 a good idea to say you can do it, and if you can do it, why in the hell would
2139 you say you shouldn't. */
2140 for (x=*start;x<req->headers;x++) {
2141 if (!strncasecmp(req->header[x], name, len)) {
2142 r = req->header[x] + len;
2143 while(*r && (*r < 33))
2147 while(*r && (*r < 33))
2155 /* We probably shouldn't even bother counting whitespace afterwards but
2156 I guess for backwards compatibility we will */
2157 for (x=*start;x<req->headers;x++) {
2158 if (!strncasecmp(req->header[x], name, len) &&
2159 (req->header[x][len] == ':')) {
2160 r = req->header[x] + len + 1;
2161 while(*r && (*r < 33))
2169 for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++)
2170 if (!strcasecmp(aliases[x].fullname, name))
2171 return __get_header(req, aliases[x].shortname, start);
2173 /* Don't return NULL, so get_header is always a valid pointer */
2177 /*--- get_header: Get header from SIP request ---*/
2178 static char *get_header(struct sip_request *req, char *name)
2181 return __get_header(req, name, &start);
2184 /*--- sip_rtp_read: Read RTP from network ---*/
2185 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p)
2187 /* Retrieve audio/etc from channel. Assumes p->lock is already held. */
2188 struct ast_frame *f;
2189 static struct ast_frame null_frame = { AST_FRAME_NULL, };
2192 f = ast_rtp_read(p->rtp); /* RTP Audio */
2195 f = ast_rtcp_read(p->rtp); /* RTCP Control Channel */
2198 f = ast_rtp_read(p->vrtp); /* RTP Video */
2201 f = ast_rtcp_read(p->vrtp); /* RTCP Control Channel for video */
2206 /* Don't send RFC2833 if we're not supposed to */
2207 if (f && (f->frametype == AST_FRAME_DTMF) && (ast_test_flag(p, SIP_DTMF) != SIP_DTMF_RFC2833))
2210 /* We already hold the channel lock */
2211 if (f->frametype == AST_FRAME_VOICE) {
2212 if (f->subclass != p->owner->nativeformats) {
2213 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
2214 p->owner->nativeformats = f->subclass;
2215 ast_set_read_format(p->owner, p->owner->readformat);
2216 ast_set_write_format(p->owner, p->owner->writeformat);
2218 if ((ast_test_flag(p, SIP_DTMF) == SIP_DTMF_INBAND) && p->vad) {
2219 f = ast_dsp_process(p->owner,p->vad,f);
2220 if (f && (f->frametype == AST_FRAME_DTMF))
2221 ast_log(LOG_DEBUG, "Detected DTMF '%c'\n", f->subclass);
2228 /*--- sip_read: Read SIP RTP from channel */
2229 static struct ast_frame *sip_read(struct ast_channel *ast)
2231 struct ast_frame *fr;
2232 struct sip_pvt *p = ast->pvt->pvt;
2233 ast_mutex_lock(&p->lock);
2234 fr = sip_rtp_read(ast, p);
2235 time(&p->lastrtprx);
2236 ast_mutex_unlock(&p->lock);
2240 /*--- build_callid: Build SIP CALLID header ---*/
2241 static void build_callid(char *callid, int len, struct in_addr ourip, char *fromdomain)
2246 char iabuf[INET_ADDRSTRLEN];
2249 res = snprintf(callid, len, "%08x", val);
2253 if (!ast_strlen_zero(fromdomain))
2254 snprintf(callid, len, "@%s", fromdomain);
2256 /* It's not important that we really use our right IP here... */
2257 snprintf(callid, len, "@%s", ast_inet_ntoa(iabuf, sizeof(iabuf), ourip));
2260 /*--- sip_alloc: Allocate SIP_PVT structure and set defaults ---*/
2261 static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useglobal_nat)
2265 p = malloc(sizeof(struct sip_pvt));
2268 /* Keep track of stuff */
2269 memset(p, 0, sizeof(struct sip_pvt));
2270 ast_mutex_init(&p->lock);
2280 memcpy(&p->sa, sin, sizeof(p->sa));
2281 if (ast_sip_ouraddrfor(&p->sa.sin_addr,&p->ourip))
2282 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2284 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2286 p->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2288 p->vrtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2292 /* Start with 101 instead of 1 */
2295 ast_log(LOG_WARNING, "Unable to create RTP session: %s\n", strerror(errno));
2296 ast_mutex_destroy(&p->lock);
2298 ast_destroy_realtime(p->vars);
2304 ast_rtp_settos(p->rtp, tos);
2306 ast_rtp_settos(p->vrtp, tos);
2307 if (useglobal_nat && sin) {
2308 /* Setup NAT structure according to global settings if we have an address */
2309 ast_copy_flags(p, &global_flags, SIP_NAT);
2310 memcpy(&p->recv, sin, sizeof(p->recv));
2311 ast_rtp_setnat(p->rtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
2313 ast_rtp_setnat(p->vrtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
2316 strncpy(p->fromdomain, default_fromdomain, sizeof(p->fromdomain) - 1);
2317 build_via(p, p->via, sizeof(p->via));
2319 build_callid(p->callid, sizeof(p->callid), p->ourip, p->fromdomain);
2321 strncpy(p->callid, callid, sizeof(p->callid) - 1);
2322 ast_copy_flags(p, (&global_flags), SIP_PROMISCREDIR | SIP_TRUSTRPID | SIP_DTMF | SIP_REINVITE | SIP_PROG_INBAND | SIP_OSPAUTH);
2323 /* Assign default music on hold class */
2324 strncpy(p->musicclass, global_musicclass, sizeof(p->musicclass) - 1);
2325 p->rtptimeout = global_rtptimeout;
2326 p->rtpholdtimeout = global_rtpholdtimeout;
2327 p->rtpkeepalive = global_rtpkeepalive;
2328 p->capability = global_capability;
2329 if (ast_test_flag(p, SIP_DTMF) == SIP_DTMF_RFC2833)
2330 p->noncodeccapability |= AST_RTP_DTMF;
2331 strncpy(p->context, default_context, sizeof(p->context) - 1);
2333 ast_mutex_lock(&iflock);
2336 ast_mutex_unlock(&iflock);
2338 ast_log(LOG_DEBUG, "Allocating new SIP call for %s\n", callid);
2342 /*--- find_call: Connect incoming SIP message to current call or create new call structure */
2343 /* Called by handle_request ,sipsock_read */
2344 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin)
2349 char iabuf[INET_ADDRSTRLEN];
2353 callid = get_header(req, "Call-ID");
2355 if (pedanticsipchecking) {
2356 /* In principle Call-ID's uniquely identify a call, however some vendors
2357 (i.e. Pingtel) send multiple calls with the same Call-ID and different
2358 tags in order to simplify billing. The RFC does state that we have to
2359 compare tags in addition to the call-id, but this generate substantially
2360 more overhead which is totally unnecessary for the vast majority of sane
2361 SIP implementations, and thus Asterisk does not enable this behavior
2362 by default. Short version: You'll need this option to support conferencing
2364 strncpy(tmp, req->header[0], sizeof(tmp) - 1);
2366 c = strchr(tmp, ' ');
2369 if (!strcasecmp(cmd, "SIP/2.0"))
2370 strncpy(tmp, get_header(req, "To"), sizeof(tmp) - 1);
2372 strncpy(tmp, get_header(req, "From"), sizeof(tmp) - 1);
2373 tag = strstr(tmp, "tag=");
2376 c = strchr(tag, ';');
2383 if (ast_strlen_zero(callid)) {
2384 ast_log(LOG_WARNING, "Call missing call ID from '%s'\n", ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr));
2387 ast_mutex_lock(&iflock);
2390 if (!strcmp(p->callid, callid) &&
2391 (!pedanticsipchecking || !tag || ast_strlen_zero(p->theirtag) || !strcmp(p->theirtag, tag))) {
2392 /* Found the call */
2393 ast_mutex_lock(&p->lock);
2394 ast_mutex_unlock(&iflock);
2399 ast_mutex_unlock(&iflock);
2400 p = sip_alloc(callid, sin, 1);
2402 ast_mutex_lock(&p->lock);
2406 /*--- sip_register: Parse register=> line in sip.conf and add to registry */
2407 static int sip_register(char *value, int lineno)
2409 struct sip_registry *reg;
2410 char copy[256] = "";
2411 char *username=NULL, *hostname=NULL, *secret=NULL, *authuser=NULL;
2418 strncpy(copy, value, sizeof(copy)-1);
2421 hostname = strrchr(stringp, '@');
2426 if (!username || ast_strlen_zero(username) || !hostname || ast_strlen_zero(hostname)) {
2427 ast_log(LOG_WARNING, "Format for registration is user[:secret[:authuser]]@host[:port][/contact] at line %d", lineno);
2431 username = strsep(&stringp, ":");
2433 secret = strsep(&stringp, ":");
2435 authuser = strsep(&stringp, ":");
2438 hostname = strsep(&stringp, "/");
2440 contact = strsep(&stringp, "/");
2441 if (!contact || ast_strlen_zero(contact))
2444 hostname = strsep(&stringp, ":");
2445 porta = strsep(&stringp, ":");
2447 if (porta && !atoi(porta)) {
2448 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
2451 reg = malloc(sizeof(struct sip_registry));
2453 memset(reg, 0, sizeof(struct sip_registry));
2456 strncpy(reg->contact, contact, sizeof(reg->contact) - 1);
2458 strncpy(reg->username, username, sizeof(reg->username)-1);
2460 strncpy(reg->hostname, hostname, sizeof(reg->hostname)-1);
2462 strncpy(reg->authuser, authuser, sizeof(reg->authuser)-1);
2464 strncpy(reg->secret, secret, sizeof(reg->secret)-1);
2467 reg->refresh = default_expiry;
2468 reg->portno = porta ? atoi(porta) : 0;
2469 reg->callid_valid = 0;
2471 ASTOBJ_CONTAINER_LINK(®l, reg);
2472 ASTOBJ_UNREF(reg,sip_registry_destroy);
2474 ast_log(LOG_ERROR, "Out of memory\n");
2480 /*--- lws2sws: Parse multiline SIP headers into one header */
2481 /* This is enabled if pedanticsipchecking is enabled */
2482 static int lws2sws(char *msgbuf, int len)
2488 /* Eliminate all CRs */
2489 if (msgbuf[h] == '\r') {
2493 /* Check for end-of-line */
2494 if (msgbuf[h] == '\n') {
2495 /* Check for end-of-message */
2498 /* Check for a continuation line */
2499 if (msgbuf[h + 1] == ' ' || msgbuf[h + 1] == '\t') {
2500 /* Merge continuation line */
2504 /* Propagate LF and start new line */
2505 msgbuf[t++] = msgbuf[h++];
2509 if (msgbuf[h] == ' ' || msgbuf[h] == '\t') {
2514 msgbuf[t++] = msgbuf[h++];
2518 msgbuf[t++] = msgbuf[h++];
2526 /*--- parse: Parse a SIP message ----*/
2527 static void parse(struct sip_request *req)
2529 /* Divide fields by NULL's */
2534 /* First header starts immediately */
2538 /* We've got a new header */
2542 printf("Header: %s (%d)\n", req->header[f], strlen(req->header[f]));
2544 if (ast_strlen_zero(req->header[f])) {
2545 /* Line by itself means we're now in content */
2549 if (f >= SIP_MAX_HEADERS - 1) {
2550 ast_log(LOG_WARNING, "Too many SIP headers...\n");
2553 req->header[f] = c + 1;
2554 } else if (*c == '\r') {
2555 /* Ignore but eliminate \r's */
2560 /* Check for last header */
2561 if (!ast_strlen_zero(req->header[f]))
2564 /* Now we process any mime content */
2569 /* We've got a new line */
2572 printf("Line: %s (%d)\n", req->line[f], strlen(req->line[f]));
2574 if (f >= SIP_MAX_LINES - 1) {
2575 ast_log(LOG_WARNING, "Too many SDP lines...\n");
2578 req->line[f] = c + 1;
2579 } else if (*c == '\r') {
2580 /* Ignore and eliminate \r's */
2585 /* Check for last line */
2586 if (!ast_strlen_zero(req->line[f]))
2590 ast_log(LOG_WARNING, "Odd content, extra stuff left over ('%s')\n", c);
2593 /*--- process_sdp: Process SIP SDP ---*/
2594 static int process_sdp(struct sip_pvt *p, struct sip_request *req)
2600 char iabuf[INET_ADDRSTRLEN];
2604 int peercapability, peernoncodeccapability;
2605 int vpeercapability=0, vpeernoncodeccapability=0;
2606 struct sockaddr_in sin;
2609 struct ast_hostent ahp;
2611 int destiterator = 0;
2615 int debug=sip_debug_test_pvt(p);
2617 /* Update our last rtprx when we receive an SDP, too */
2618 time(&p->lastrtprx);
2619 time(&p->lastrtptx);
2621 /* Get codec and RTP info from SDP */
2622 if (strcasecmp(get_header(req, "Content-Type"), "application/sdp")) {
2623 ast_log(LOG_NOTICE, "Content is '%s', not 'application/sdp'\n", get_header(req, "Content-Type"));
2626 m = get_sdp(req, "m");
2627 sdpLineNum_iterator_init(&destiterator);
2628 c = get_sdp_iterate(&destiterator, req, "c");
2629 if (ast_strlen_zero(m) || ast_strlen_zero(c)) {
2630 ast_log(LOG_WARNING, "Insufficient information for SDP (m = '%s', c = '%s')\n", m, c);
2633 if (sscanf(c, "IN IP4 %256s", host) != 1) {
2634 ast_log(LOG_WARNING, "Invalid host in c= line, '%s'\n", c);
2637 /* XXX This could block for a long time, and block the main thread! XXX */
2638 hp = ast_gethostbyname(host, &ahp);
2640 ast_log(LOG_WARNING, "Unable to lookup host in c= line, '%s'\n", c);
2643 sdpLineNum_iterator_init(&iterator);
2644 ast_set_flag(p, SIP_NOVIDEO);
2645 while ((m = get_sdp_iterate(&iterator, req, "m"))[0] != '\0') {
2646 if ((sscanf(m, "audio %d RTP/AVP %n", &x, &len) == 1) ||
2647 (sscanf(m, "audio %d/%d RTP/AVP %n", &x, &y, &len) == 2)) {
2649 /* Scan through the RTP payload types specified in a "m=" line: */
2650 ast_rtp_pt_clear(p->rtp);
2652 while(!ast_strlen_zero(codecs)) {
2653 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2654 ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2658 ast_verbose("Found RTP audio format %d\n", codec);
2659 ast_rtp_set_m_type(p->rtp, codec);
2661 /* Skip over any whitespace */
2662 while(*codecs && (*codecs < 33)) codecs++;
2666 ast_rtp_pt_clear(p->vrtp); /* Must be cleared in case no m=video line exists */
2668 if (p->vrtp && (sscanf(m, "video %d RTP/AVP %n", &x, &len) == 1)) {
2669 ast_clear_flag(p, SIP_NOVIDEO);
2671 /* Scan through the RTP payload types specified in a "m=" line: */
2673 while(!ast_strlen_zero(codecs)) {
2674 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2675 ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2679 ast_verbose("Found video format %s\n", ast_getformatname(codec));
2680 ast_rtp_set_m_type(p->vrtp, codec);
2682 /* Skip over any whitespace */
2683 while(*codecs && (*codecs < 33)) codecs++;
2687 /* Check for Media-description-level-address for audio */
2688 if (pedanticsipchecking) {
2689 c = get_sdp_iterate(&destiterator, req, "c");
2690 if (!ast_strlen_zero(c)) {
2691 if (sscanf(c, "IN IP4 %256s", host) != 1) {
2692 ast_log(LOG_WARNING, "Invalid secondary host in c= line, '%s'\n", c);
2694 /* XXX This could block for a long time, and block the main thread! XXX */
2695 hp = ast_gethostbyname(host, &ahp);
2697 ast_log(LOG_WARNING, "Unable to lookup host in secondary c= line, '%s'\n", c);
2702 /* RTP addresses and ports for audio and video */
2703 sin.sin_family = AF_INET;
2704 memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
2706 /* Setup audio port number */
2707 sin.sin_port = htons(portno);
2708 if (p->rtp && sin.sin_port) {
2709 ast_rtp_set_peer(p->rtp, &sin);
2711 ast_verbose("Peer audio RTP is at port %s:%d\n", ast_inet_ntoa(iabuf,sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2712 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));
2715 /* Check for Media-description-level-address for video */
2716 if (pedanticsipchecking) {
2717 c = get_sdp_iterate(&destiterator, req, "c");
2718 if (!ast_strlen_zero(c)) {
2719 if (sscanf(c, "IN IP4 %256s", host) != 1) {
2720 ast_log(LOG_WARNING, "Invalid secondary host in c= line, '%s'\n", c);
2722 /* XXX This could block for a long time, and block the main thread! XXX */
2723 hp = ast_gethostbyname(host, &ahp);
2725 ast_log(LOG_WARNING, "Unable to lookup host in secondary c= line, '%s'\n", c);
2730 /* Setup video port number */
2731 sin.sin_port = htons(vportno);
2732 if (p->vrtp && sin.sin_port) {
2733 ast_rtp_set_peer(p->vrtp, &sin);
2735 ast_verbose("Peer video RTP is at port %s:%d\n", ast_inet_ntoa(iabuf,sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2736 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));
2740 /* Next, scan through each "a=rtpmap:" line, noting each
2741 * specified RTP payload type (with corresponding MIME subtype):
2743 sdpLineNum_iterator_init(&iterator);
2744 while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
2745 char* mimeSubtype = ast_strdupa(a); /* ensures we have enough space */
2746 if (!strcasecmp(a, "sendonly")) {
2750 if (!strcasecmp(a, "sendrecv")) {
2753 if (sscanf(a, "rtpmap: %u %[^/]/", &codec, mimeSubtype) != 2) continue;
2755 ast_verbose("Found description format %s\n", mimeSubtype);
2756 /* Note: should really look at the 'freq' and '#chans' params too */
2757 ast_rtp_set_rtpmap_type(p->rtp, codec, "audio", mimeSubtype);
2759 ast_rtp_set_rtpmap_type(p->vrtp, codec, "video", mimeSubtype);
2762 /* Now gather all of the codecs that were asked for: */
2763 ast_rtp_get_current_formats(p->rtp,
2764 &peercapability, &peernoncodeccapability);
2766 ast_rtp_get_current_formats(p->vrtp,
2767 &vpeercapability, &vpeernoncodeccapability);
2768 p->jointcapability = p->capability & (peercapability | vpeercapability);
2769 p->peercapability = (peercapability | vpeercapability);
2770 p->noncodeccapability = noncodeccapability & peernoncodeccapability;
2773 /* shame on whoever coded this.... */
2774 const unsigned slen=512;
2775 char s1[slen], s2[slen], s3[slen], s4[slen];
2777 ast_verbose("Capabilities: us - %s, peer - audio=%s/video=%s, combined - %s\n",
2778 ast_getformatname_multiple(s1, slen, p->capability),
2779 ast_getformatname_multiple(s2, slen, peercapability),
2780 ast_getformatname_multiple(s3, slen, vpeercapability),
2781 ast_getformatname_multiple(s4, slen, p->jointcapability));
2783 ast_verbose("Non-codec capabilities: us - %s, peer - %s, combined - %s\n",
2784 ast_getformatname_multiple(s1, slen, noncodeccapability),
2785 ast_getformatname_multiple(s2, slen, peernoncodeccapability),
2786 ast_getformatname_multiple(s3, slen, p->noncodeccapability));
2788 if (!p->jointcapability) {
2789 ast_log(LOG_NOTICE, "No compatible codecs!\n");
2793 if (!(p->owner->nativeformats & p->jointcapability)) {
2794 const unsigned slen=512;
2795 char s1[slen], s2[slen];
2796 ast_log(LOG_DEBUG, "Oooh, we need to change our formats since our peer supports only %s and not %s\n",
2797 ast_getformatname_multiple(s1, slen, p->jointcapability),
2798 ast_getformatname_multiple(s2, slen, p->owner->nativeformats));
2799 p->owner->nativeformats = ast_codec_choose(&p->prefs, p->jointcapability, 1);
2800 ast_set_read_format(p->owner, p->owner->readformat);
2801 ast_set_write_format(p->owner, p->owner->writeformat);
2803 if (ast_bridged_channel(p->owner)) {
2804 /* Turn on/off music on hold if we are holding/unholding */
2805 if (sin.sin_addr.s_addr && !sendonly) {
2806 ast_moh_stop(ast_bridged_channel(p->owner));
2808 ast_moh_start(ast_bridged_channel(p->owner), NULL);
2810 ast_rtp_stop(p->rtp);
2818 /*--- add_header: Add header to SIP message */
2819 static int add_header(struct sip_request *req, char *var, char *value)
2822 char *shortname = "";
2823 if (req->len >= sizeof(req->data) - 4) {
2824 ast_log(LOG_WARNING, "Out of space, can't add anymore (%s:%s)\n", var, value);
2828 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
2832 req->header[req->headers] = req->data + req->len;
2833 if (compactheaders) {
2834 for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++)
2835 if (!strcasecmp(aliases[x].fullname, var))
2836 shortname = aliases[x].shortname;
2838 if(!ast_strlen_zero(shortname)) {
2839 snprintf(req->header[req->headers], sizeof(req->data) - req->len - 4, "%s: %s\r\n", shortname, value);
2841 snprintf(req->header[req->headers], sizeof(req->data) - req->len - 4, "%s: %s\r\n", var, value);
2843 req->len += strlen(req->header[req->headers]);
2844 if (req->headers < SIP_MAX_HEADERS)
2847 ast_log(LOG_WARNING, "Out of header space\n");
2853 /*--- add_blank_header: Add blank header to SIP message */
2854 static int add_blank_header(struct sip_request *req)
2856 if (req->len >= sizeof(req->data) - 4) {
2857 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
2861 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
2864 req->header[req->headers] = req->data + req->len;
2865 snprintf(req->header[req->headers], sizeof(req->data) - req->len, "\r\n");
2866 req->len += strlen(req->header[req->headers]);
2867 if (req->headers < SIP_MAX_HEADERS)
2870 ast_log(LOG_WARNING, "Out of header space\n");
2876 /*--- add_line: Add content (not header) to SIP message */
2877 static int add_line(struct sip_request *req, char *line)
2879 if (req->len >= sizeof(req->data) - 4) {
2880 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
2884 /* Add extra empty return */
2885 snprintf(req->data + req->len, sizeof(req->data) - req->len, "\r\n");
2886 req->len += strlen(req->data + req->len);
2888 req->line[req->lines] = req->data + req->len;
2889 snprintf(req->line[req->lines], sizeof(req->data) - req->len, "%s", line);
2890 req->len += strlen(req->line[req->lines]);
2891 if (req->lines < SIP_MAX_LINES)
2894 ast_log(LOG_WARNING, "Out of line space\n");
2900 /*--- copy_header: Copy one header field from one request to another */
2901 static int copy_header(struct sip_request *req, struct sip_request *orig, char *field)
2904 tmp = get_header(orig, field);
2905 if (!ast_strlen_zero(tmp)) {
2906 /* Add what we're responding to */
2907 return add_header(req, field, tmp);
2909 ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
2913 /*--- copy_all_header: Copy all headers from one request to another ---*/
2914 static int copy_all_header(struct sip_request *req, struct sip_request *orig, char *field)
2920 tmp = __get_header(orig, field, &start);
2921 if (!ast_strlen_zero(tmp)) {
2922 /* Add what we're responding to */
2923 add_header(req, field, tmp);
2928 return copied ? 0 : -1;
2931 /*--- copy_via_headers: Copy SIP VIA Headers from one request to another ---*/
2932 static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, struct sip_request *orig, char *field)
2934 char tmp[256]="", *oh, *end;
2938 char iabuf[INET_ADDRSTRLEN];
2940 oh = __get_header(orig, field, &start);
2941 if (!ast_strlen_zero(oh)) {
2943 strncpy(tmp, oh, sizeof(tmp) - 1);
2944 oh = strstr(tmp, ";rport");
2946 end = strchr(oh + 1, ';');
2948 memmove(oh, end, strlen(end) + 1);
2952 if (!copied && (ast_test_flag(p, SIP_NAT) == SIP_NAT_ALWAYS)) {
2953 /* Whoo hoo! Now we can indicate port address translation too! Just
2954 another RFC (RFC3581). I'll leave the original comments in for
2956 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));
2957 add_header(req, field, new);
2959 /* Add what we're responding to */
2960 add_header(req, field, tmp);
2967 ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
2973 /*--- add_route: Add route header into request per learned route ---*/
2974 static void add_route(struct sip_request *req, struct sip_route *route)
2977 int n, rem = 255; /* sizeof(r)-1: Room for terminating 0 */
2983 n = strlen(route->hop);
2984 if ((n+3)>rem) break;
2990 strncpy(p, route->hop, rem); p += n;
2993 route = route->next;
2996 add_header(req, "Route", r);
2999 /*--- set_destination: Set destination from SIP URI ---*/
3000 static void set_destination(struct sip_pvt *p, char *uri)
3002 char *h, *maddr, hostname[256] = "";
3003 char iabuf[INET_ADDRSTRLEN];
3006 struct ast_hostent ahp;
3007 int debug=sip_debug_test_pvt(p);
3009 /* Parse uri to h (host) and port - uri is already just the part inside the <> */
3010 /* general form we are expecting is sip[s]:username[:password]@host[:port][;...] */
3013 ast_verbose("set_destination: Parsing <%s> for address/port to send to\n", uri);
3015 /* Find and parse hostname */
3016 h = strchr(uri, '@');
3021 if (strncmp(h, "sip:", 4) == 0)
3023 else if (strncmp(h, "sips:", 5) == 0)
3026 hn = strcspn(h, ":;>");
3027 if (hn > (sizeof(hostname) - 1)) hn = sizeof(hostname) - 1;
3028 strncpy(hostname, h, hn); hostname[hn] = '\0'; /* safe */
3031 /* Is "port" present? if not default to 5060 */
3035 port = strtol(h, &h, 10);
3040 /* Got the hostname:port - but maybe there's a "maddr=" to override address? */
3041 maddr = strstr(h, "maddr=");
3044 hn = strspn(maddr, "0123456789.");
3045 if (hn > (sizeof(hostname) - 1)) hn = sizeof(hostname) - 1;
3046 strncpy(hostname, maddr, hn); hostname[hn] = '\0'; /* safe */
3049 hp = ast_gethostbyname(hostname, &ahp);
3051 ast_log(LOG_WARNING, "Can't find address for host '%s'\n", hostname);
3054 p->sa.sin_family = AF_INET;
3055 memcpy(&p->sa.sin_addr, hp->h_addr, sizeof(p->sa.sin_addr));
3056 p->sa.sin_port = htons(port);
3058 ast_verbose("set_destination: set destination to %s, port %d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), p->sa.sin_addr), port);
3061 /*--- init_resp: Initialize SIP response, based on SIP request ---*/
3062 static int init_resp(struct sip_request *req, char *resp, struct sip_request *orig)
3064 /* Initialize a response */
3065 if (req->headers || req->len) {
3066 ast_log(LOG_WARNING, "Request already initialized?!?\n");
3069 req->header[req->headers] = req->data + req->len;
3070 snprintf(req->header[req->headers], sizeof(req->data) - req->len, "SIP/2.0 %s\r\n", resp);
3071 req->len += strlen(req->header[req->headers]);
3072 if (req->headers < SIP_MAX_HEADERS)
3075 ast_log(LOG_WARNING, "Out of header space\n");
3079 /*--- init_req: Initialize SIP request ---*/
3080 static int init_req(struct sip_request *req, char *resp, char *recip)
3082 /* Initialize a response */
3083 if (req->headers || req->len) {
3084 ast_log(LOG_WARNING, "Request already initialized?!?\n");
3087 req->header[req->headers] = req->data + req->len;
3088 snprintf(req->header[req->headers], sizeof(req->data) - req->len, "%s %s SIP/2.0\r\n", resp, recip);
3089 req->len += strlen(req->header[req->headers]);
3090 if (req->headers < SIP_MAX_HEADERS)
3093 ast_log(LOG_WARNING, "Out of header space\n");
3098 /*--- respprep: Prepare SIP response packet ---*/
3099 static int respprep(struct sip_request *resp, struct sip_pvt *p, char *msg, struct sip_request *req)
3101 char newto[256] = "", *ot;
3103 memset(resp, 0, sizeof(*resp));
3104 init_resp(resp, msg, req);
3105 copy_via_headers(p, resp, req, "Via");
3107 copy_all_header(resp, req, "Record-Route");
3108 copy_header(resp, req, "From");
3109 ot = get_header(req, "To");
3110 if (!strstr(ot, "tag=")) {
3111 /* Add the proper tag if we don't have it already. If they have specified
3112 their tag, use it. Otherwise, use our own tag */
3113 if (!ast_strlen_zero(p->theirtag) && ast_test_flag(p, SIP_OUTGOING))
3114 snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
3115 else if (p->tag && !ast_test_flag(p, SIP_OUTGOING))
3116 snprintf(newto, sizeof(newto), "%s;tag=as%08x", ot, p->tag);
3118 strncpy(newto, ot, sizeof(newto) - 1);
3119 newto[sizeof(newto) - 1] = '\0';
3123 add_header(resp, "To", ot);
3124 copy_header(resp, req, "Call-ID");
3125 copy_header(resp, req, "CSeq");
3126 add_header(resp, "User-Agent", default_useragent);
3127 add_header(resp, "Allow", ALLOWED_METHODS);
3129 /* For registration responses, we also need expiry and
3133 snprintf(contact, sizeof(contact), "%s;expires=%d", p->our_contact, p->expiry);
3134 snprintf(tmp, sizeof(tmp), "%d", p->expiry);
3135 add_header(resp, "Expires", tmp);
3136 add_header(resp, "Contact", contact);
3138 add_header(resp, "Contact", p->our_contact);
3143 /*--- reqprep: Initialize a SIP request packet ---*/
3144 static int reqprep(struct sip_request *req, struct sip_pvt *p, char *msg, int seqno, int newbranch)
3146 struct sip_request *orig = &p->initreq;
3147 char stripped[80] ="";
3153 memset(req, 0, sizeof(struct sip_request));
3155 snprintf(p->lastmsg, sizeof(p->lastmsg), "Tx: %s", msg);
3163 p->branch ^= rand();
3164 build_via(p, p->via, sizeof(p->via));
3166 if (!strcasecmp(msg, "CANCEL")) {
3167 c = p->initreq.rlPart2; /* Use original URI */
3168 } else if (!strcasecmp(msg, "ACK")) {
3169 /* Use URI from Contact: in 200 OK (if INVITE)
3170 (we only have the contacturi on INVITEs) */
3171 if (!ast_strlen_zero(p->okcontacturi))
3172 c = p->okcontacturi;
3174 c = p->initreq.rlPart2;
3175 } else if (!ast_strlen_zero(p->okcontacturi)) {
3176 c = p->okcontacturi; /* Use for BYE or REINVITE */
3177 } else if (!ast_strlen_zero(p->uri)) {
3180 /* We have no URI, use To: or From: header as URI (depending on direction) */
3181 if (ast_test_flag(p, SIP_OUTGOING))
3182 strncpy(stripped, get_header(orig, "To"), sizeof(stripped) - 1);
3184 strncpy(stripped, get_header(orig, "From"), sizeof(stripped) - 1);
3186 c = strchr(stripped, '<');
3198 init_req(req, msg, c);
3200 snprintf(tmp, sizeof(tmp), "%d %s", seqno, msg);
3202 add_header(req, "Via", p->via);
3204 set_destination(p, p->route->hop);
3205 add_route(req, p->route->next);
3208 ot = get_header(orig, "To");
3209 of = get_header(orig, "From");
3211 /* Add tag *unless* this is a CANCEL, in which case we need to send it exactly
3212 as our original request, including tag (or presumably lack thereof) */
3213 if (!strstr(ot, "tag=") && strcasecmp(msg, "CANCEL")) {
3214 /* Add the proper tag if we don't have it already. If they have specified
3215 their tag, use it. Otherwise, use our own tag */
3216 if (ast_test_flag(p, SIP_OUTGOING) && !ast_strlen_zero(p->theirtag))
3217 snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
3218 else if (!ast_test_flag(p, SIP_OUTGOING))
3219 snprintf(newto, sizeof(newto), "%s;tag=as%08x", ot, p->tag);
3221 snprintf(newto, sizeof(newto), "%s", ot);
3225 if (ast_test_flag(p, SIP_OUTGOING)) {
3226 add_header(req, "From", of);
3227 add_header(req, "To", ot);
3229 add_header(req, "From", ot);
3230 add_header(req, "To", of);
3232 add_header(req, "Contact", p->our_contact);
3233 copy_header(req, orig, "Call-ID");
3234 add_header(req, "CSeq", tmp);
3236 add_header(req, "User-Agent", default_useragent);
3240 static int __transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req, int reliable)
3242 struct sip_request resp;
3244 if (reliable && (sscanf(get_header(req, "CSeq"), "%i ", &seqno) != 1)) {
3245 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
3248 respprep(&resp, p, msg, req);
3249 add_header(&resp, "Content-Length", "0");
3250 add_blank_header(&resp);
3251 return send_response(p, &resp, reliable, seqno);
3254 /*--- transmit_response: Transmit response, no retransmits */
3255 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req)
3257 return __transmit_response(p, msg, req, 0);
3260 /*--- transmit_response: Transmit response, Make sure you get a reply */
3261 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal)
3263 return __transmit_response(p, msg, req, fatal ? 2 : 1);
3266 /*--- append_date: Append date to SIP message ---*/
3267 static void append_date(struct sip_request *req)
3274 strftime(tmpdat, sizeof(tmpdat), "%a, %d %b %Y %T GMT", &tm);
3275 add_header(req, "Date", tmpdat);
3278 /*--- transmit_response_with_date: Append date and content length before transmitting response ---*/
3279 static int transmit_response_with_date(struct sip_pvt *p, char *msg, struct sip_request *req)
3281 struct sip_request resp;
3282 respprep(&resp, p, msg, req);
3284 add_header(&resp, "Content-Length", "0");
3285 add_blank_header(&resp);
3286 return send_response(p, &resp, 0, 0);
3289 /*--- transmit_response_with_allow: Append Accept header, content length before transmitting response ---*/
3290 static int transmit_response_with_allow(struct sip_pvt *p, char *msg, struct sip_request *req, int reliable)
3292 struct sip_request resp;
3293 respprep(&resp, p, msg, req);
3294 add_header(&resp, "Accept", "application/sdp");
3295 add_header(&resp, "Content-Length", "0");
3296 add_blank_header(&resp);
3297 return send_response(p, &resp, reliable, 0);
3300 /* transmit_response_with_auth: Respond with authorization request */
3301 static int transmit_response_with_auth(struct sip_pvt *p, char *msg, struct sip_request *req, char *randdata, int reliable, char *header)
3303 struct sip_request resp;
3306 if (reliable && (sscanf(get_header(req, "CSeq"), "%i ", &seqno) != 1)) {
3307 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
3310 snprintf(tmp, sizeof(tmp), "Digest realm=\"%s\", nonce=\"%s\"", global_realm, randdata);
3311 respprep(&resp, p, msg, req);
3312 add_header(&resp, header, tmp);
3313 add_header(&resp, "Content-Length", "0");
3314 add_blank_header(&resp);
3315 return send_response(p, &resp, reliable, seqno);
3318 /*--- add_text: Add text body to SIP message ---*/
3319 static int add_text(struct sip_request *req, char *text)
3321 /* XXX Convert \n's to \r\n's XXX */
3322 int len = strlen(text);
3324 snprintf(clen, sizeof(clen), "%d", len);
3325 add_header(req, "Content-Type", "text/plain");
3326 add_header(req, "Content-Length", clen);
3327 add_line(req, text);
3331 /*--- add_digit: add DTMF INFO tone to sip message ---*/
3332 /* Always adds default duration 250 ms, regardless of what came in over the line */
3333 static int add_digit(struct sip_request *req, char digit)
3338 snprintf(tmp, sizeof(tmp), "Signal=%c\r\nDuration=250\r\n", digit);
3340 snprintf(clen, sizeof(clen), "%d", len);
3341 add_header(req, "Content-Type", "application/dtmf-relay");
3342 add_header(req, "Content-Length", clen);
3347 /*--- add_sdp: Add Session Description Protocol message ---*/
3348 static int add_sdp(struct sip_request *resp, struct sip_pvt *p)
3353 int alreadysent = 0;
3355 struct sockaddr_in sin;
3356 struct sockaddr_in vsin;
3366 char iabuf[INET_ADDRSTRLEN];
3368 int capability = 0 ;
3369 struct sockaddr_in dest;
3370 struct sockaddr_in vdest = { 0, };
3373 debug = sip_debug_test_pvt(p);
3375 /* XXX We break with the "recommendation" and send our IP, in order that our
3376 peer doesn't have to ast_gethostbyname() us XXX */
3379 ast_log(LOG_WARNING, "No way to add SDP without an RTP structure\n");
3382 capability = p->capability;
3384 if (!p->sessionid) {
3385 p->sessionid = getpid();
3386 p->sessionversion = p->sessionid;
3388 p->sessionversion++;
3389 ast_rtp_get_us(p->rtp, &sin);
3391 ast_rtp_get_us(p->vrtp, &vsin);
3393 if (p->redirip.sin_addr.s_addr) {
3394 dest.sin_port = p->redirip.sin_port;
3395 dest.sin_addr = p->redirip.sin_addr;
3397 capability = p->redircodecs;
3399 dest.sin_addr = p->ourip;
3400 dest.sin_port = sin.sin_port;
3403 /* Determine video destination */
3405 if (p->vredirip.sin_addr.s_addr) {
3406 vdest.sin_port = p->vredirip.sin_port;
3407 vdest.sin_addr = p->vredirip.sin_addr;
3409 vdest.sin_addr = p->ourip;
3410 vdest.sin_port = vsin.sin_port;
3414 ast_verbose("We're at %s port %d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ntohs(sin.sin_port));
3416 ast_verbose("Video is at %s port %d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ntohs(vsin.sin_port));
3418 snprintf(v, sizeof(v), "v=0\r\n");
3419 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));
3420 snprintf(s, sizeof(s), "s=session\r\n");
3421 snprintf(c, sizeof(c), "c=IN IP4 %s\r\n", ast_inet_ntoa(iabuf, sizeof(iabuf), dest.sin_addr));
3422 snprintf(t, sizeof(t), "t=0 0\r\n");
3423 snprintf(m, sizeof(m), "m=audio %d RTP/AVP", ntohs(dest.sin_port));
3424 snprintf(m2, sizeof(m2), "m=video %d RTP/AVP", ntohs(vdest.sin_port));
3425 /* Prefer the codec we were requested to use, first, no matter what */
3426 if (capability & p->prefcodec) {
3428 ast_verbose("Answering/Requesting with root capability 0x%x (%s)\n", p->prefcodec, ast_getformatname(p->prefcodec));
3429 codec = ast_rtp_lookup_code(p->rtp, 1, p->prefcodec);
3431 snprintf(costr, sizeof(costr), " %d", codec);
3432 if (p->prefcodec <= AST_FORMAT_MAX_AUDIO) {
3433 strncat(m, costr, sizeof(m) - strlen(m) - 1);
3434 snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(1, p->prefcodec));
3435 strncpy(a, costr, sizeof(a) - 1);
3437 strncat(m2, costr, sizeof(m2) - strlen(m2) - 1);
3438 snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/90000\r\n", codec, ast_rtp_lookup_mime_subtype(1, p->prefcodec));
3439 strncpy(a2, costr, sizeof(a2) - 1);
3442 alreadysent |= p->prefcodec;
3444 /* Start by sending our preferred codecs */
3445 for (x = 0 ; x < 32 ; x++) {
3446 if(!(pref_codec = ast_codec_pref_index(&p->prefs,x)))
3448 if ((capability & pref_codec) && !(alreadysent & pref_codec)) {
3450 ast_verbose("Answering with preferred capability 0x%x (%s)\n", pref_codec, ast_getformatname(pref_codec));
3451 codec = ast_rtp_lookup_code(p->rtp, 1, pref_codec);
3453 snprintf(costr, sizeof(costr), " %d", codec);
3454 if (pref_codec <= AST_FORMAT_MAX_AUDIO) {
3455 strncat(m, costr, sizeof(m) - strlen(m) - 1);
3456 snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(1, pref_codec));
3457 strncat(a, costr, sizeof(a) - strlen(a) - 1);
3459 strncat(m2, costr, sizeof(m2) - strlen(m2) - 1);
3460 snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/90000\r\n", codec, ast_rtp_lookup_mime_subtype(1, pref_codec));
3461 strncat(a2, costr, sizeof(a2) - strlen(a) - 1);
3465 alreadysent |= pref_codec;
3468 /* Now send any other common codecs, and non-codec formats: */
3469 for (x = 1; x <= ((videosupport && p->vrtp) ? AST_FORMAT_MAX_VIDEO : AST_FORMAT_MAX_AUDIO); x <<= 1) {
3470 if ((capability & x) && !(alreadysent & x)) {
3472 ast_verbose("Answering with capability 0x%x (%s)\n", x, ast_getformatname(x));