Home page | Mailing list | Docs

Last updated: Sat Feb 3 05:01:54 2007

Asterisk developer's documentation :: Codename Pineapple

---

sip3funcs.h File Reference

---

Detailed Description

Definitions of functions in the sip3 library files used by chan_sip3.c.

Version 3 of chan_sip

Author:

Mark Spencer <markster@digium.com>

Olle E. Johansson <oej@edvina.net> (all the chan_sip3 changes)

See Also:

• CREDITS

Definition in file sip3funcs.h.

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines
#define	GNURK
Functions
GNURK const char *	__get_header (struct sip_request *req, const char *name, int *start)
GNURK void	__sip_ack (struct sip_dialog *dialog, int seqno, int resp, int sipmethod, int reset)
	For a reliable transmission, we need to get an reply to stop retransmission. Acknowledges receipt of a packet and stops retransmission.
GNURK void	__sip_destroy (struct sip_dialog *p, int lockowner, int lockdialoglist)
	Execute destruction of SIP dialog structure, release memory.
GNURK void	__sip_pretend_ack (struct sip_dialog *p)
	Pretend to ack all packets - nothing to do with SIP_ACK (the method) maybe the lock on p is not strictly necessary but there might be a race.
GNURK int	__sip_semi_ack (struct sip_dialog *p, int seqno, int resp, int sipmethod)
	Acks receipt of packet, keep it around (used for provisional responses).
GNURK int	__transmit_response (struct sip_dialog *p, const char *msg, struct sip_request *req, enum xmittype reliable)
	Base transmit response function.
GNURK void	add_blank (struct sip_request *req)
	add a blank line if no body
GNURK int	add_digit (struct sip_request *req, char digit, unsigned int duration)
	Add DTMF INFO tone to sip message.
GNURK int	add_header (struct sip_request *req, const char *var, const char *value)
	Add header to SIP message.
GNURK int	add_header_contentLength (struct sip_request *req, int len)
	Add 'Content-Length' header to SIP message.
GNURK int	add_line (struct sip_request *req, const char *line)
	Add content (not header) to SIP message.
GNURK struct sip_auth *	add_realm_authentication (struct sip_auth *authlist, char *configuration, int lineno)
	Add realm authentication in list.
GNURK void	add_route (struct sip_request *req, struct sip_route *route)
	Add route header into request per learned route.
GNURK int	add_sdp (struct sip_request *resp, struct sip_dialog *p)
	Add Session Description Protocol message.
GNURK int	add_sip_domain (const char *domain, const enum domain_mode mode, const char *context)
	Add SIP domain to list of domains we are responsible for.
GNURK int	add_t38_sdp (struct sip_request *resp, struct sip_dialog *p)
	Add T.38 Session Description Protocol message.
GNURK int	add_text (struct sip_request *req, const char *text)
	Add text body to SIP message.
GNURK void	append_date (struct sip_request *req)
	Append date to SIP message.
GNURK void	append_history_full (struct sip_dialog *p, const char *fmt,...)
	Append to SIP dialog history with arg list.
GNURK void	append_history_va (struct sip_dialog *p, const char *fmt, va_list ap)
	Append to SIP dialog history with arg list.
GNURK void	append_maxforwards (struct sip_request *req)
	Append Max-Forwards header to request.
GNURK void	ast_quiet_chan (struct ast_channel *chan)
	Turn off generator data XXX Does this function belong in the SIP channel?
GNURK void	auth_headers (enum sip_auth_type code, char **header, char **respheader)
	return the request and response heade for a 401 or 407 code
GNURK void	build_callid_pvt (struct sip_dialog *pvt)
	Build SIP Call-ID value for a non-REGISTER transaction.
GNURK void	build_contact (struct sip_dialog *p)
	Build contact header - the contact header we send out.
GNURK int	build_reply_digest (struct sip_dialog *p, int method, char *digest, int digest_len)
	Build reply digest.
GNURK void	build_rpid (struct sip_dialog *p)
	Build the Remote Party-ID & From using callingpres options.
GNURK void	build_via (struct sip_dialog *p, int forcenewbranch)
	Build a Via header for a request.
GNURK enum check_auth_result	check_auth (struct sip_dialog *p, struct sip_request *req, const char *username, const char *secret, const char *md5secret, int sipmethod, char *uri, enum xmittype reliable, int ignore)
	Check user authorization from peer definition Some actions, like REGISTER and INVITEs from peers require authentication (if peer have secret set).
GNURK int	check_sip_domain (const char *domain, char *context, size_t len)
	check_sip_domain: Check if domain part of uri is local to our server
GNURK int	clear_realm_authentication (struct sip_auth *authlist)
	Clear realm authentication list (at reload).
GNURK void	clear_sip_domains (void)
	Clear our domain list (at reload).
GNURK int	close_sip_sockets (void)
	Close all open network sockets.
GNURK char *	complete_sip_device (const char *word, int state, int flags2)
	Do completion on peer name.
GNURK char *	complete_sip_show_device (const char *line, const char *word, int pos, int state)
	Support routine for 'sip show peer' CLI.
GNURK int	copy_all_header (struct sip_request *req, struct sip_request *orig, const char *field)
	Copy all headers from one request to another.
GNURK int	copy_header (struct sip_request *req, struct sip_request *orig, const char *field)
	Copy one header field from one request to another.
GNURK void	copy_request (struct sip_request *dst, const struct sip_request *src)
	copy SIP request (mostly used to save request for responses)
GNURK int	copy_via_headers (struct sip_dialog *p, struct sip_request *req, struct sip_request *orig, const char *field)
	Copy SIP VIA Headers from the request to the response.
GNURK int	create_addr (struct sip_dialog *dialog, const char *username, char *domain, const char *device)
	create address structure from peer name Or, if peer not found, find it in the global DNS returns TRUE (-1) on failure, FALSE on success
GNURK void	destroy_association (struct sip_device *peer)
	Remove registration data from realtime database or AST/DB when registration expires.
GNURK int	determine_firstline_parts (struct sip_request *req)
	Parse first line of incoming SIP request.
GNURK struct sip_device *	device_ref (struct sip_device *device)
	Add reference for device.
GNURK int	device_status (struct sip_device *peer, char *status, int statuslen)
	Report Device status in character string.
GNURK void	device_unref (struct sip_device *device)
	Remove reference for device. When we reach 0, device is removed from memory.
GNURK void	dialog_lock (struct sip_dialog *dialog, int state)
	Helper function to lock and unlock, hiding the underlying locking mechanism.
GNURK void	dialoglist_lock (void)
	Lock list of active SIP dialogs.
GNURK void	dialoglist_unlock (void)
	Unlock list of active SIP dialogs.
GNURK const char *	dialogstate2str (const enum dialogstate state)
	Convert SIP dialog states to string.
GNURK void	dialogstatechange (struct sip_dialog *dialog, enum dialogstate newstate)
	Change dialog state for a SIP dialog and output to debug.
GNURK int	do_proxy_auth (struct sip_dialog *p, struct sip_request *req, enum sip_auth_type code, int sipmethod, int init)
	Add authentication on outbound SIP packet.
GNURK int	do_register_auth (struct sip_dialog *p, struct sip_request *req, enum sip_auth_type code)
	Authenticate for outbound registration.
GNURK void	do_setnat (struct sip_dialog *p, int natflags)
	Set nat mode on the various media streams.
void *	do_sip_monitor (void *data)
	The SIP monitoring thread.
GNURK const char *	domain_mode_to_text (const enum domain_mode mode)
	Print domain mode to cli.
GNURK int	domains_configured (void)
	return TRUE if any domains are configured for this server
GNURK int	expire_register (void *data)
	Expire registration of SIP peer.
GNURK void	extract_uri (struct sip_dialog *p, struct sip_request *req)
	Check Contact: URI of SIP message.
GNURK const char *	find_alias (const char *name, const char *_default)
	Find compressed SIP alias Structure for conversion between compressed SIP and "normal" SIP.
GNURK struct sip_device *	find_device (const char *peer, struct sockaddr_in *sin, int realtime)
	Locate peer by name or ip address This is used on incoming SIP message to find matching peer on ip or outgoing message to find matching peer on name.
GNURK struct sip_auth *	find_realm_authentication (struct sip_auth *authlist, const char *realm)
	Find authentication for a specific realm.
GNURK int	find_sdp (struct sip_request *req)
	Determine whether a SIP message contains an SDP in its body.
GNURK int	find_sip_method (const char *msg)
	find_sip_method: Find SIP method from header
GNURK const struct cfsubscription_types *	find_subscription_type (enum subscriptiontype subtype)
	Find subscription type in array.
GNURK void	find_via_branch (struct sip_request *req, char *viabuf, size_t vialen)
	Find via branch parameter.
GNURK void	free_old_route (struct sip_route *route)
	Remove route from route list.
GNURK int	func_check_sipdomain (struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
	Dial plan function to check if domain is local.
GNURK char *	generate_random_string (char *buf, size_t size)
	Generate 32 byte random string for callid's etc.
GNURK char *	get_body (struct sip_request *req, char *name)
	Get the message body part identified by name=.
GNURK char *	get_calleridname (const char *input, char *output, size_t outputsize)
	Get caller id name from SIP headers.
GNURK int	get_destination (struct sip_dialog *p, struct sip_request *oreq)
	Find out who the call is for We use the INVITE request uri to find out Runs a dialplan lookup.
GNURK const char *	get_header (struct sip_request *req, const char *name)
	Get header from SIP request.
GNURK char *	get_in_brackets (char *tmp)
	Pick out text in brackets from character string.
GNURK int	get_rdnis (struct sip_dialog *p, struct sip_request *oreq)
	Get referring dnis.
GNURK int	get_rpid_num (const char *input, char *output, int maxlen)
	Get caller id number from Remote-Party-ID header field Returns true if number should be restricted (privacy setting found) output is set to NULL if no number found.
GNURK struct sip_dialog *	get_sip_dialog_byid_locked (const char *callid, const char *totag, const char *fromtag)
	Lock dialog list lock and find matching pvt lock Their tag is fromtag, our tag is to-tag This means that in some transactions, totag needs to be their tag :-) depending upon the direction.
GNURK const char *	gettag (const char *header, char *tagbuf, int tagbufsize)
	Get tag from packet.
GNURK int	handle_request (struct sip_dialog *p, struct sip_request *req, struct sockaddr_in *sin, int *recount, int *nounlock)
	Handle incoming SIP requests (methods).
GNURK int	handle_request_refer (struct sip_dialog *p, struct sip_request *req, int debug, int seqno, int *nounlock)
void	handle_response_peerpoke (struct sip_dialog *p, int resp, struct sip_request *req)
	Handle qualification responses (OPTIONS).
GNURK int	handle_response_register (struct sip_dialog *p, int resp, char *rest, struct sip_request *req, int seqno)
	Handle responses on REGISTER to services.
GNURK const char *	hangup_cause2sip (int cause)
	Convert Asterisk hangup causes to SIP codes.
GNURK int	hangup_sip2cause (int cause)
	Convert SIP hangup causes to Asterisk hangup causes.
GNURK int	init_req (struct sip_request *req, int sipmethod, const char *recip)
	Initialize SIP request.
GNURK int	init_resp (struct sip_request *resp, const char *msg)
	Initialize SIP response, based on SIP request.
GNURK void	initialize_initreq (struct sip_dialog *p, struct sip_request *req)
	Initialize the initital request packet in the pvt structure. This packet is used for creating replies and future requests in a dialog.
GNURK void	initreqprep (struct sip_request *req, struct sip_dialog *p, int sipmethod)
	Initiate new SIP request to peer/user.
void	kill_monitor (void)
	kill monitor thread (only at module unload)
GNURK void	logdebug (int level, const char *fmt,...)
	Append to SIP dialog history with arg list.
GNURK int	lws2sws (char *msgbuf, int len)
	Parse multiline SIP headers into one header This is enabled if pedanticsipchecking is enabled.
GNURK void	make_our_tag (char *tagbuf, size_t len)
	Make our SIP dialog tag.
GNURK int	manager_sip_show_device (struct mansession *s, const struct message *m)
	Show SIP peers in the manager API.
GNURK int	manager_sip_show_devices (struct mansession *s, const struct message *m)
	Show SIP peers in the manager API.
GNURK struct sip_dialog *	match_or_create_dialog (struct sip_request *req, struct sockaddr_in *sin, const int intended_method)
GNURK int	method_match (enum sipmethod id, const char *name)
	returns true if 'name' (with optional trailing whitespace) matches the sip method 'id'. Strictly speaking, SIP methods are case SENSITIVE, but we do a case-insensitive comparison to be more tolerant. following Jon Postel's rule: Be gentle in what you accept, strict with what you send
GNURK void	parse_moved_contact (struct sip_dialog *p, struct sip_request *req)
	Parse 302 Moved temporalily response.
GNURK void	parse_request (struct sip_request *req)
	Parse a SIP message.
GNURK unsigned int	parse_sip_options (struct sip_dialog *pvt, const char *supported)
	Parse supported header in incoming packet.
GNURK void	print_group (int fd, ast_group_t group, int crlf)
	Print call group and pickup group.
GNURK int	process_sdp (struct sip_dialog *p, struct sip_request *req)
	Process SIP SDP offer, select formats and activate RTP channels If offer is rejected, we will not change any properties of the call.
GNURK struct sip_device *	realtime_peer (const char *newpeername, struct sockaddr_in *sin)
	realtime_peer: Get peer from realtime storage Checks the "sippeers" realtime family from extconfig.conf
GNURK void	realtime_update_peer (const char *peername, struct sockaddr_in *sin, const char *username, const char *fullcontact, int expiry)
	Update peer object in realtime storage If the Asterisk system name is set in asterisk.conf, we will use that name and store that in the "regserver" field in the sippeers table to facilitate multi-server setups.
GNURK const char *	referstatus2str (enum referstatus rstatus) attribute_pure
	Convert transfer status to string.
GNURK void	reg_source_db (struct sip_device *peer)
GNURK void	register_peer_exten (struct sip_device *device, int onoff)
	Automatically add peer extension to dial plan.
GNURK void	register_rtp_and_udptl (void)
	Register RTP and UDPTL to the subsystems.
GNURK char *	regstate2str (enum sipregistrystate regstate) attribute_const
	Convert registration state status to string.
GNURK int	reload_config (enum channelreloadreason reason)
	Re-read SIP.conf config file.
GNURK void	replace_cid (struct sip_dialog *p, const char *rpid_num, const char *calleridname)
	helper function for check_{user|peer}_ok()
GNURK int	reply_digest (struct sip_dialog *p, struct sip_request *req, char *header, int sipmethod, char *digest, int digest_len)
	reply to authentication for outbound registrations
GNURK int	reqprep (struct sip_request *req, struct sip_dialog *p, int sipmethod, int seqno, int newbranch)
	Initialize a SIP request message (not the initial one in a dialog).
GNURK void	reset_ip_interface (struct sip_network *sipsock)
	clear IP interfaces
GNURK int	respprep (struct sip_request *resp, struct sip_dialog *p, const char *msg, struct sip_request *req)
	Prepare SIP response packet.
int	restart_monitor (void)
	Start the channel monitor thread.
GNURK int	send_request (struct sip_dialog *p, struct sip_request *req, enum xmittype reliable)
	Send SIP Request to the other part of the dialogue.
GNURK int	send_response (struct sip_dialog *p, struct sip_request *req, enum xmittype reliable)
	Transmit response on SIP request.
GNURK void	set_device_defaults (struct sip_device *device)
	Set peer defaults before configuring specific configurations.
GNURK void	set_initreq (struct sip_dialog *dialog, struct sip_request *req)
	Set packet to initreq status. Set flag to avoid de-allocation until dialog is destroyed.
GNURK struct sip_dialog *	sip_alloc (ast_string_field callid, struct sockaddr_in *sin, int useglobal_nat, const int intended_method)
	Allocate SIP_PVT structure and set defaults.
GNURK void	sip_cancel_destroy (struct sip_dialog *p)
	Cancel destruction of SIP dialog.
GNURK void	sip_cli_and_manager_commands_register (void)
	Register cli and manager commands.
GNURK void	sip_cli_and_manager_commands_unregister (void)
	Unregister cli and manager commands.
GNURK int	sip_debug_test_addr (const struct sockaddr_in *addr)
	See if we pass debug IP filter.
GNURK int	sip_debug_test_pvt (struct sip_dialog *p)
	Test PVT for debugging output.
GNURK void	sip_destroy (struct sip_dialog *p)
	Destroy SIP call structure.
GNURK void	sip_destroy_device (struct sip_device *peer)
	Destroy device object from memory.
GNURK int	sip_do_reload (void)
	Reload module.
GNURK void	sip_dump_history (struct sip_dialog *dialog)
	Dump SIP history to debug log file at end of lifespan for SIP dialog.
GNURK enum ast_rtp_get_result	sip_get_rtp_peer (struct ast_channel *chan, struct ast_rtp **rtp)
	Returns null if we can't reinvite audio (part of RTP interface).
GNURK enum ast_rtp_get_result	sip_get_vrtp_peer (struct ast_channel *chan, struct ast_rtp **rtp)
	Returns null if we can't reinvite video (part of RTP interface).
GNURK int	sip_listconfigs (int fd)
	List all configuration options in sip.conf.
GNURK char *	sip_method2txt (int method)
	return text string for sip method
GNURK int	sip_method_needrtp (int method)
	Check whether method needs RTP.
GNURK const char *	sip_nat_mode (const struct sip_dialog *p)
	Display SIP nat mode.
GNURK int	sip_notify (int fd, int argc, char *argv[])
GNURK char *	sip_option2text (int option)
	Return text representation of SIP option.
GNURK int	sip_option_lookup (const char *optionlabel)
	Check if sip option is known to us, avoid x- options (non-standard).
GNURK void	sip_options_print (int options, int fd)
	Print options to cli.
GNURK int	sip_ouraddrfor (struct in_addr *them, struct in_addr *us)
	NAT fix - decide which IP address to use for Asterisk server?
GNURK void	sip_peer_hold (struct sip_dialog *p, int hold)
	Change onhold state of a peer using a pvt structure.
void	sip_poke_all_peers (void)
	Send a poke to all known peers Space them out 100 ms apart XXX We might have a cool algorithm for this or use random - any suggestions?
int	sip_poke_noanswer (void *data)
	React to lack of answer to Qualify poke.
int	sip_poke_peer (struct sip_device *peer)
	Check availability of peer, also keep NAT open.
int	sip_poke_peer_s (void *data)
	Poke peer (send qualify to check if peer is alive and well).
GNURK int	sip_prune_realtime (int fd, int argc, char *argv[])
	Remove temporary realtime objects from memory (CLI).
GNURK struct ast_frame *	sip_read (struct ast_channel *ast)
	Read SIP RTP from channel.
GNURK const struct sockaddr_in *	sip_real_dst (const struct sip_dialog *p)
	The real destination address for a write.
GNURK int	sip_refer_allocate (struct sip_dialog *p)
	Allocate SIP refer structure.
GNURK int	sip_register (char *value, int lineno, struct sip_device *peer)
	Parse register=> line in sip.conf and add to registry.
GNURK void	sip_registry_destroy (struct sip_registry *reg)
	Destroy registry object Objects created with the register= statement in static configuration.
GNURK int	sip_reload (int fd)
	Force reload of module from cli.
GNURK int	sip_reload_check (void)
GNURK void	sip_scheddestroy (struct sip_dialog *p, int ms)
	Schedule destruction of SIP dialog.
GNURK void	sip_send_all_registers (void)
	Send all known registrations.
GNURK int	sip_send_mwi_to_peer (struct sip_device *peer)
	Send message waiting indication to alert peer that they've got voicemail.
GNURK int	sip_set_rtp_peer (struct ast_channel *chan, struct ast_rtp *rtp, struct ast_rtp *vrtp, int codecs, int nat_active)
	Set the RTP peer for this call.
GNURK int	sip_show_domains (int fd, int argc, char *argv[])
	CLI command to list local domains.
GNURK void	sipnet_lock (struct sip_network *sipnet)
	Lock netlock.
GNURK int	sipnet_ourport (struct sip_network *sipnet)
	read our port number
GNURK void	sipnet_ourport_set (struct sip_network *sipnet, int port)
	Set our port number.
GNURK void	sipnet_unlock (struct sip_network *sipnet)
	Unlock netlock.
GNURK struct sip_request *	siprequest_alloc (size_t len, struct sip_network *sipnet)
	Allocate SIP request structure.
GNURK void	siprequest_free (struct sip_request *req)
	Free SIP request.
GNURK int	sipsock_init (struct sip_network *sipsock, struct sockaddr_in *old_bindappr)
	Initialize IP socket on configured address - the bind address.
GNURK int	sipsock_read (int *id, int fd, short events, void *ignore)
	Read data from SIP socket.
GNURK int	sipsocket_initialized (struct sip_network *sipnet)
	Check if network socket is open.
GNURK int	sipsocket_open (struct sip_network *sipnet)
	Open network socket, bind to address and set options (TOS).
GNURK void	stop_media_flows (struct sip_dialog *dialog)
	Immediately stop RTP, VRTP and UDPTL as applicable.
GNURK const char *	subscription_type2str (enum subscriptiontype subtype) attribute_pure
	Show subscription type in string format.
GNURK struct sip_device *	temp_device (const char *name)
	Create temporary peer (used in autocreatepeer mode).
GNURK void	transmit_fake_auth_response (struct sip_dialog *p, struct sip_request *req, int reliable)
	Send a fake 401 Unauthorized response when the administrator wants to hide the names of local users/peers from fishers.
GNURK int	transmit_final_response (struct sip_dialog *dialog, const char *msg, struct sip_request *req, enum xmittype reliable)
	Transmit final response to a request and close dialog Set dialog state to TERMINATED to avoid problems At some point, after debugging, we can remove the reliable flag. Only responses to INVITEs are sent reliably.
GNURK int	transmit_info_with_digit (struct sip_dialog *p, const char digit, unsigned int duration)
	Send SIP INFO dtmf message, see Cisco documentation on cisco.com.
GNURK int	transmit_info_with_vidupdate (struct sip_dialog *p)
	Send SIP INFO with video update request.
GNURK int	transmit_invite (struct sip_dialog *p, int sipmethod, int sdp, int init)
	Build REFER/INVITE/OPTIONS message and transmit it.
GNURK int	transmit_message_with_text (struct sip_dialog *p, const char *text)
	Transmit text with SIP MESSAGE method.
GNURK int	transmit_notify_with_mwi (struct sip_dialog *p, int newmsgs, int oldmsgs, char *vmexten)
	Notify user of messages waiting in voicemail.
GNURK int	transmit_notify_with_sipfrag (struct sip_dialog *p, int cseq, char *message, int terminate)
	Notify a transferring party of the status of transfer.
GNURK int	transmit_refer (struct sip_dialog *p, const char *dest)
	Transmit SIP REFER message (initiated by the transfer() dialplan application.
GNURK int	transmit_register (struct sip_registry *r, int sipmethod, const char *auth, const char *authheader)
	Transmit register to SIP proxy or UA.
GNURK int	transmit_reinvite_with_sdp (struct sip_dialog *p, int t38version)
	Transmit reinvite with SDP.
GNURK int	transmit_request (struct sip_dialog *p, int sipmethod, int inc, enum xmittype reliable, int newbranch)
	Transmit generic SIP request.
GNURK int	transmit_request_with_auth (struct sip_dialog *p, int sipmethod, int seqno, enum xmittype reliable, int newbranch)
	Transmit SIP request, auth added.
GNURK int	transmit_response (struct sip_dialog *p, const char *msg, struct sip_request *req)
	Transmit response, no retransmits.
GNURK int	transmit_response_reliable (struct sip_dialog *p, const char *msg, struct sip_request *req)
	Transmit response, Make sure you get an ACK This is only used for responses to INVITEs, where we need to make sure we get an ACK.
GNURK int	transmit_response_with_attachment (enum responseattach attach, struct sip_dialog *p, const char *msg, struct sip_request *req, enum xmittype reliable)
	Transmit responses with various attachments.
GNURK int	transmit_response_with_auth (struct sip_dialog *p, const char *msg, struct sip_request *req, const char *rand, enum xmittype reliable, const char *header, int stale)
	Respond with authorization request.
GNURK int	transmit_response_with_unsupported (struct sip_dialog *p, const char *msg, struct sip_request *req, const char *unsupported)
	Transmit response, no retransmits.
GNURK int	transmit_sip_request (struct sip_dialog *p, struct sip_request *req)
	Transmit SIP request unreliably (only used in sip_notify subsystem).
GNURK int	transmit_state_notify (struct sip_dialog *p, int state, int full, int timeout)
	Used in the SUBSCRIBE notification subsystem.
GNURK void	try_suggested_sip_codec (struct sip_dialog *p)
GNURK void	unregister_rtp_and_udptl (void)
	UNRegister RTP and UDPTL to the subsystems.
GNURK int	update_call_counter (struct sip_dialog *fup, int event)
	update_call_counter: Handle call_limit for SIP users Setting a call-limit will cause calls above the limit not to be accepted.
GNURK void	update_peer (struct sip_device *device, int expiry)
	Update peer data in database (if used).
Variables
GNURK struct ast_custom_function	checksipdomain_function

---

Define Documentation

#define GNURK

Definition at line 40 of file sip3funcs.h.

---

Function Documentation

GNURK const char* __get_header (  struct sip_request *  req, const char *  name, int *  start )

Definition at line 587 of file sip3_parse.c. References ast_log(), ast_test_flag, sip_request::header, sip_request::headers, len, LOG_ERROR, parse_request(), SIP_PKT_CONNECTED, and SIP_PKT_PARSED. { int pass; if (!ast_test_flag(req, SIP_PKT_PARSED)) { /* Ok, so this req is not parse by parse_request yet. */ /* Parsing it before we have finished re-transmit may be bad. */ if (!ast_test_flag(req, SIP_PKT_CONNECTED)) parse_request(req); else { ast_log(LOG_ERROR, "Can't get header %s from request before parsing. Hang in for a jumpy ride!\n", name); return ""; } } /* * Technically you can place arbitrary whitespace both before and after the ':' in * a header, although RFC3261 clearly says you shouldn't before, and place just * one afterwards. If you shouldn't do it, what absolute idiot decided it was * a good idea to say you can do it, and if you can do it, why in the hell would. * you say you shouldn't. */ for (pass = 0; name && pass < 2;pass++) { int x, len = strlen(name); for (x=*start; x<req->headers; x++) { if (!strncasecmp(req->header[x], name, len)) { char *r = req->header[x] + len; /* skip name */ r = ast_skip_blanks(r); if (*r == ':') { *start = x+1; return ast_skip_blanks(r+1); } } } if (pass == 0) /* Try aliases */ name = find_alias(name, NULL); } /* Don't return NULL, so get_header is always a valid pointer */ return ""; }

GNURK void __sip_ack (  struct sip_dialog *  dialog, int  seqno, int  resp, int  sipmethod, int  reset )

For a reliable transmission, we need to get an reply to stop retransmission. Acknowledges receipt of a packet and stops retransmission. Note: Assume that the dialog is locked. Definition at line 261 of file sip3_dialog.c. References ast_clear_flag, ast_log(), ast_sched_del(), ast_test_flag, sip_request::dialog, dialog_lock(), FALSE, LOG_DEBUG, sip_request::method, sip_request::next, option_debug, sip_dialog::packets, parse_request(), sip_dialog::pendinginvite, sip_request::retransid, sip_request::seqno, SIP_PKT_CONNECTED, SIP_PKT_INITREQ, SIP_PKT_PARSED, SIP_PKT_RESPONSE, sipdebug, siprequest_free(), TRUE, and UNLINK. { struct sip_request *cur, *prev = NULL; int res = FALSE; if (option_debug) { if (!resp) ast_log(LOG_DEBUG, "Trying to confirm pending invite %d Call ID %s\n", dialog->pendinginvite, dialog->callid); else ast_log(LOG_DEBUG, "Trying to confirm pending response on Call ID %s\n", dialog->callid); } dialog_lock(dialog, TRUE); /* Find proper transaction */ for (cur = dialog->packets; cur; prev = cur, cur = cur->next) { if (option_debug > 2) ast_log(LOG_DEBUG, "--Checking packet with seqno %d against response with seqno %d\n", cur->seqno, seqno); /* Match on seqno AND req/resp AND method? */ if ((cur->seqno == seqno) && ((ast_test_flag(cur, SIP_PKT_RESPONSE)) == resp) && ((ast_test_flag(cur, SIP_PKT_RESPONSE)) || (cur->method == sipmethod))) { if (!resp && (seqno == dialog->pendinginvite)) { if (sipdebug && option_debug && !reset) ast_log(LOG_DEBUG, "Got reply to pending invite %d - Call Id %s\n", dialog->pendinginvite, dialog->callid); dialog->pendinginvite = 0; } else { if (sipdebug && option_debug && !reset) ast_log(LOG_DEBUG, "Got ACK on INVITE response Cseq %d Call Id %s\n", cur->seqno, dialog->callid); } /* this is our baby */ res = TRUE; UNLINK(cur, dialog->packets, prev); if (cur->retransid > -1) { if (sipdebug && option_debug > 3 && !reset) ast_log(LOG_DEBUG, "Cancelling retransmit of packet (reply received) Retransid #%d\n", cur->retransid); ast_sched_del(sched, cur->retransid); cur->retransid = -1; } if (!reset) { if (!ast_test_flag(cur, SIP_PKT_INITREQ)) siprequest_free(cur); /* We might want to keep this somewhere else */ else { if (sipdebug && option_debug > 3 && !reset) ast_log(LOG_DEBUG, "This is the initial request, keeping it in memory - Cseq %d\n", cur->seqno); ast_clear_flag(cur, SIP_PKT_CONNECTED); if (!ast_test_flag(cur, SIP_PKT_PARSED)) parse_request(cur); /* Parse initreq now, after we have answer */ } } break; } } dialog_lock(dialog, FALSE); if (option_debug && sipdebug) ast_log(LOG_DEBUG, "Stopping retransmission on '%s' of %s %d: Match %s\n", dialog->callid, resp ? "Response" : "Request", seqno, res ? "Found" : "Not Found"); }

GNURK void __sip_destroy (  struct sip_dialog *  p, int  lockowner, int  lockdialoglist )

Execute destruction of SIP dialog structure, release memory. Definition at line 366 of file sip3_dialog.c. References ast_channel_lock, ast_channel_unlock, ast_extension_state_del(), AST_LIST_REMOVE_HEAD, ast_log(), ast_rtp_destroy(), ast_sched_del(), ast_test_flag, ast_udptl_destroy(), ast_verbose(), ASTOBJ_UNREF, DEC_CALL_LIMIT, DEC_CALL_RINGING, sip_request::dialog, dialoglist, dialoglist_lock(), sip_globals::dumphistory, sip_dialog::flags, free, free_old_route(), global, LOG_DEBUG, sip_dialog::next, option_debug, sip_debug_test_pvt(), sip_dump_history(), SIP_INC_COUNT, sip_method2txt(), SIP_PAGE2_INC_RINGING, sip_registry_destroy(), UNLINK, and update_call_counter(). { struct sip_dialog *cur, *prev = NULL; struct sip_request *cp; if (ast_test_flag(&dialog->flags[0], SIP_INC_COUNT)) /* This dialog has incremented call count */ update_call_counter(dialog, DEC_CALL_LIMIT); /* Since it was forgotten, decrement call count */ if (ast_test_flag(&dialog->flags[1], SIP_PAGE2_INC_RINGING)) /* This dialog has incremented ring count */ update_call_counter(dialog, DEC_CALL_RINGING); /* Since it was forgotten, decrement ring count */ if (sip_debug_test_pvt(dialog) || option_debug > 2) ast_verbose("Really destroying SIP dialog '%s' Method: %s\n", dialog->callid, sip_method2txt(dialog->method)); /* Remove link from peer to subscription of MWI */ if (dialog->relatedpeer && dialog->relatedpeer->mailbox.mwipvt) dialog->relatedpeer->mailbox.mwipvt = NULL; if (global.dumphistory) sip_dump_history(dialog); if (dialog->stateid > -1) ast_extension_state_del(dialog->stateid, NULL); if (dialog->initid > -1) ast_sched_del(sched, dialog->initid); if (dialog->autokillid > -1) ast_sched_del(sched, dialog->autokillid); if (dialog->inviteoptions) free(dialog->inviteoptions); if (dialog->rtp) ast_rtp_destroy(dialog->rtp); if (dialog->vrtp) ast_rtp_destroy(dialog->vrtp); if (dialog->udptl) ast_udptl_destroy(dialog->udptl); if (dialog->refer) free(dialog->refer); if (dialog->route) { free_old_route(dialog->route); dialog->route = NULL; } if (dialog->registry) { if (dialog->registry->call == dialog) dialog->registry->call = NULL; ASTOBJ_UNREF(dialog->registry, sip_registry_destroy); } /* Unlink us from the owner if we have one */ if (dialog->owner) { if (lockowner) ast_channel_lock(dialog->owner); if (option_debug) ast_log(LOG_DEBUG, "Detaching from %s\n", dialog->owner->name); dialog->owner->tech_pvt = NULL; if (lockowner) ast_channel_unlock(dialog->owner); } /* Clear history */ if (dialog->history) { struct sip_history *hist; while( (hist = AST_LIST_REMOVE_HEAD(dialog->history, list)) ) free(hist); free(dialog->history); dialog->history = NULL; } /* Unlink us from the dialog list */ if (lockdialoglist) dialoglist_lock(); for (prev = NULL, cur = dialoglist; cur; prev = cur, cur = cur->next) { if (cur == dialog) { UNLINK(cur, dialoglist, prev); break; } } if (lockdialoglist) dialoglist_unlock(); if (!cur) { ast_log(LOG_WARNING, "Trying to destroy \"%s\", not found in dialog list?!?! \n", dialog->callid); return; } /* remove all current packets in this dialog */ while((cp = dialog->packets)) { /* If one of the records in the packet list is the initreq, then release it */ if (cp == dialog->initreq) dialog->initreq = NULL; dialog->packets = dialog->packets->next; if (cp->retransid > -1) ast_sched_del(sched, cp->retransid); free(cp); } if (dialog->initreq) siprequest_free(dialog->initreq); if (dialog->chanvars) { ast_variables_destroy(dialog->chanvars); dialog->chanvars = NULL; } ast_mutex_destroy(&dialog->lock); ast_string_field_free_pools(dialog); /* Finally, release the dialog */ free(dialog); sipcounters.dialog_objects--; if (option_debug > 3) ast_log(LOG_DEBUG, "--DIALOGS-- Counter %d\n", sipcounters.dialog_objects); }

GNURK void __sip_pretend_ack (  struct sip_dialog *  p  )

Pretend to ack all packets - nothing to do with SIP_ACK (the method) maybe the lock on p is not strictly necessary but there might be a race. Definition at line 320 of file sip3_dialog.c. References __sip_ack(), ast_log(), ast_test_flag, sip_request::data, sip_request::dialog, FALSE, find_sip_method(), LOG_WARNING, sip_request::method, sip_dialog::packets, sip_request::seqno, sip_method2txt(), and SIP_PKT_RESPONSE. { struct sip_request *cur = NULL; while (dialog->packets) { int method; if (cur == dialog->packets) { ast_log(LOG_WARNING, "Have a packet that doesn't want to give up! %s\n", sip_method2txt(cur->method)); return; } cur = dialog->packets; method = (cur->method) ? cur->method : find_sip_method(cur->data); __sip_ack(dialog, cur->seqno, ast_test_flag(cur, SIP_PKT_RESPONSE), method, FALSE); } }

GNURK int __sip_semi_ack (  struct sip_dialog *  dialog, int  seqno, int  resp, int  sipmethod )

Acks receipt of packet, keep it around (used for provisional responses). Note: Assume that the dialog is locked. Definition at line 339 of file sip3_dialog.c. References ast_log(), ast_sched_del(), ast_test_flag, sip_request::data, sip_request::dialog, LOG_DEBUG, method_match(), sip_request::next, option_debug, sip_dialog::packets, sip_request::retransid, sip_request::seqno, sip_method2txt(), SIP_PKT_RESPONSE, and sipdebug. { struct sip_request *cur; int res = -1; for (cur = dialog->packets; cur; cur = cur->next) { if (option_debug > 2) ast_log(LOG_DEBUG, "--Checking packet with seqno %d against response with seqno %d\n", cur->seqno, seqno); if (cur->seqno == seqno && ast_test_flag(cur, SIP_PKT_RESPONSE) == resp && (ast_test_flag(cur, SIP_PKT_RESPONSE) || method_match(sipmethod, cur->data))) { /* this is our baby */ if (cur->retransid > -1) { if (option_debug > 3 && sipdebug) ast_log(LOG_DEBUG, "Cancelling retransmission #%d - %s (got response)\n", cur->retransid, sip_method2txt(sipmethod)); ast_sched_del(sched, cur->retransid); } cur->retransid = -1; res = 0; break; } } if (option_debug) ast_log(LOG_DEBUG, "(Provisional) Stopping retransmission (but retaining packet) on '%s' %s %d: %s\n", dialog->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found"); return res; }

GNURK int __transmit_response (  struct sip_dialog *  p, const char *  msg, struct sip_request *  req, enum xmittype  reliable )

Base transmit response function. sip3_transmit.c Definition at line 113 of file sip3_transmit.c. References add_header(), add_header_contentLength(), ast_cause2str(), ast_log(), sip_request::data_size, get_header(), ast_channel::hangupcause, LOG_DEBUG, LOG_WARNING, sip_dialog::method, sip_dialog::owner, respprep(), send_response(), sip_request::seqno, SIP_INVITE, SIP_MAX_PACKET, sipnet, siprequest_alloc(), siprequest_free(), and XMIT_UNRELIABLE. { struct sip_request *resp; int seqno = 0; int res; if (reliable && (sscanf(get_header(req, "CSeq"), "%d ", &seqno) != 1)) { ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq")); return -1; } resp = siprequest_alloc(SIP_MAX_PACKET, &sipnet); ast_log(LOG_DEBUG, " :::: Response data size: %d\n", (int) resp->data_size); resp->seqno = seqno; respprep(resp, p, msg, req); add_header_contentLength(resp, 0); /* If we are cancelling an incoming invite for some reason, add information about the reason why we are doing this in clear text */ if (p->method == SIP_INVITE && msg[0] != '1' && p->owner && p->owner->hangupcause) { char buf[10]; add_header(resp, "X-Asterisk-HangupCause", ast_cause2str(p->owner->hangupcause)); snprintf(buf, sizeof(buf), "%d", p->owner->hangupcause); add_header(resp, "X-Asterisk-HangupCauseCode", buf); } res = send_response(p, resp, reliable); if (reliable == XMIT_UNRELIABLE) siprequest_free(resp); return res; }

GNURK void add_blank (  struct sip_request *  req  )

add a blank line if no body Definition at line 128 of file sip3_compose.c. References sip_request::data, sip_request::data_size, sip_request::len, and sip_request::lines. { if (!req->lines) { /* Add extra empty return. add_header() reserves 4 bytes so cannot be truncated */ snprintf(req->data + req->len, req->data_size - req->len, "\r\n"); req->len += strlen(req->data + req->len); } }

GNURK int add_digit (  struct sip_request *  req, char  digit, unsigned int  duration )

Add DTMF INFO tone to sip message. Definition at line 205 of file sip3_compose.c. References add_header(), add_header_contentLength(), and add_line(). { char tmp[256]; snprintf(tmp, sizeof(tmp), "Signal=%c\r\nDuration=%u\r\n", digit, duration); add_header(req, "Content-Type", "application/dtmf-relay"); add_header_contentLength(req, strlen(tmp)); add_line(req, tmp); return 0; }

GNURK int add_header (  struct sip_request *  req, const char *  var, const char *  value )

Add header to SIP message. sip3_compose.c : Composing new SIP messages Definition at line 89 of file sip3_compose.c. References ast_log(), sip_globals::compactheaders, sip_request::data, sip_request::data_size, find_alias(), global, sip_request::header, sip_request::headers, sip_request::len, sip_request::lines, LOG_DEBUG, LOG_WARNING, option_debug, and SIP_MAX_HEADERS. { int maxlen = req->data_size - 4 - req->len; /* 4 bytes are for two \r\n ? */ if (req->headers == SIP_MAX_HEADERS) { ast_log(LOG_WARNING, "Out of SIP header space\n"); return -1; } if (req->lines) { ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n"); return -1; } if (maxlen <= 0) { ast_log(LOG_WARNING, "Out of space, can't add anymore (%s:%s)\n", var, value); if (option_debug > 2) ast_log(LOG_DEBUG, " ==== Req->len %d, req->data size %d Maxlen %d\n", req->len, (int) req->data_size, maxlen); return -1; } req->header[req->headers] = req->data + req->len; if (global.compactheaders) var = find_alias(var, var); snprintf(req->header[req->headers], maxlen, "%s: %s\r\n", var, value); req->len += strlen(req->header[req->headers]); req->headers++; if (req->headers < SIP_MAX_HEADERS) req->headers++; else ast_log(LOG_WARNING, "Out of SIP header space... Will generate broken SIP message\n"); return 0; }

GNURK int add_header_contentLength (  struct sip_request *  req, int  len )

Add 'Content-Length' header to SIP message. Definition at line 362 of file sip3_compose.c. References add_header(). { char clen[10]; snprintf(clen, sizeof(clen), "%d", len); return add_header(req, "Content-Length", clen); }

GNURK int add_line (  struct sip_request *  req, const char *  line )

Add content (not header) to SIP message. Definition at line 399 of file sip3_compose.c. References ast_log(), sip_request::data, sip_request::data_size, sip_request::len, sip_request::line, sip_request::lines, LOG_WARNING, and SIP_MAX_LINES. { if (req->lines == SIP_MAX_LINES) { ast_log(LOG_WARNING, "Out of SIP line space\n"); return -1; } if (!req->lines) { /* Add extra empty return */ snprintf(req->data + req->len, req->data_size - req->len, "\r\n"); req->len += strlen(req->data + req->len); } if (req->len >= req->data_size - 4) { ast_log(LOG_WARNING, "Out of space, can't add anymore: Len %d Data %dd\n", req->len, (int) req->data_size); return -1; } req->line[req->lines] = req->data + req->len; snprintf(req->line[req->lines], req->data_size - req->len, "%s", line); req->len += strlen(req->line[req->lines]); req->lines++; return 0; }

GNURK struct sip_auth* add_realm_authentication (  struct sip_auth *  authlist, char *  configuration, int  lineno )

Add realm authentication in list. Definition at line 495 of file sip3_auth.c. References ast_calloc, ast_log(), ast_strlen_zero(), ast_verbose(), LOG_DEBUG, LOG_WARNING, sip_auth::md5secret, sip_auth::next, option_debug, option_verbose, sip_auth::realm, secret, strsep(), and sip_auth::username. { char authcopy[256]; char *username=NULL, *realm=NULL, *secret=NULL, *md5secret=NULL; char *stringp; struct sip_auth *a, *b, *auth; if (ast_strlen_zero(configuration)) return authlist; if (option_debug) ast_log(LOG_DEBUG, "Auth config :: %s\n", configuration); ast_copy_string(authcopy, configuration, sizeof(authcopy)); stringp = authcopy; username = stringp; realm = strrchr(stringp, '@'); if (realm) *realm++ = '\0'; if (ast_strlen_zero(username) || ast_strlen_zero(realm)) { ast_log(LOG_WARNING, "Format for authentication entry is user[:secret]@realm at line %d\n", lineno); return authlist; } stringp = username; username = strsep(&stringp, ":"); if (username) { secret = strsep(&stringp, ":"); if (!secret) { stringp = username; md5secret = strsep(&stringp,"#"); } } if (!(auth = ast_calloc(1, sizeof(*auth)))) return authlist; ast_copy_string(auth->realm, realm, sizeof(auth->realm)); ast_copy_string(auth->username, username, sizeof(auth->username)); if (secret) ast_copy_string(auth->secret, secret, sizeof(auth->secret)); if (md5secret) ast_copy_string(auth->md5secret, md5secret, sizeof(auth->md5secret)); /* find the end of the list */ for (b = NULL, a = authlist; a ; b = a, a = a->next) ; if (b) b->next = auth; /* Add structure add end of list */ else authlist = auth; if (option_verbose > 2) ast_verbose("Added authentication for realm %s\n", realm); return authlist; }

GNURK void add_route (  struct sip_request *  req, struct sip_route *  route )

Add route header into request per learned route. Definition at line 371 of file sip3_compose.c. References sip_route::hop, and sip_route::next. { char r[BUFSIZ*2], *p; int n, rem = sizeof(r); if (!route) return; p = r; for (;route ; route = route->next) { n = strlen(route->hop); if (rem < n+3) /* we need room for ",<route>" */ break; if (p != r) { /* add a separator after fist route */ *p++ = ','; --rem; } *p++ = '<'; ast_copy_string(p, route->hop, rem); /* cannot fail */ p += n; *p++ = '>'; rem -= (n+2); } *p = '\0'; add_header(req, "Route", r); }

GNURK int add_sdp (  struct sip_request *  resp, struct sip_dialog *  p )

Add Session Description Protocol message. Todo: XXX We need to select one codec, not many, since there's no transcoding Definition at line 1029 of file sip3_sdprtp.c. References add_codec_to_sdp(), ast_build_string(), ast_codec_pref_index(), AST_FORMAT_AUDIO_MASK, AST_FORMAT_VIDEO_MASK, ast_getformatname_multiple(), ast_inet_ntoa(), ast_log(), ast_test_flag, ast_verbose(), capability, FALSE, sip_dialog::flags, get_our_media_address(), sip_dialog::jointcapability, len, LOG_WARNING, sip_dialog::maxcallbitrate, option_debug, sip_dialog::ourip, sip_dialog::prefcodec, sip_dialog::prefs, sip_dialog::rtp, sip_dialog::sessionid, sip_dialog::sessionversion, sip_debug_test_pvt(), SIP_NOVIDEO, SIP_PAGE2_CALL_ONHOLD_INACTIVE, SIP_PAGE2_CALL_ONHOLD_ONEDIR, SIP_PAGE2_T38SUPPORT_RTP, sip_dialog::t38, t38properties::t38support, TRUE, and sip_dialog::vrtp. { int len = 0; int alreadysent = 0; struct sockaddr_in sin; struct sockaddr_in vsin; struct sockaddr_in dest; struct sockaddr_in vdest = { 0, }; /* SDP fields */ char *version = "v=0\r\n"; /* Protocol version */ char *subject = "s=session\r\n"; /* Subject of the session */ char owner[256]; /* Session owner/creator */ char connection[256]; /* Connection data */ char *stime = "t=0 0\r\n"; /* Time the session is active */ char bandwidth[256] = ""; /* Max bitrate */ char *hold; char m_audio[256]; /* Media declaration line for audio */ char m_video[256]; /* Media declaration line for video */ char a_audio[1024]; /* Attributes for audio */ char a_video[1024]; /* Attributes for video */ char *m_audio_next = m_audio; char *m_video_next = m_video; size_t m_audio_left = sizeof(m_audio); size_t m_video_left = sizeof(m_video); char *a_audio_next = a_audio; char *a_video_next = a_video; size_t a_audio_left = sizeof(a_audio); size_t a_video_left = sizeof(a_video); int x; int capability; int needvideo = FALSE; int debug = sip_debug_test_pvt(p); int min_audio_packet_size = 0; int min_video_packet_size = 0; m_video[0] = '\0'; /* Reset the video media string if it's not needed */ if (!p->rtp) { ast_log(LOG_WARNING, "No way to add SDP without an RTP structure\n"); return -1; } /* Set RTP Session ID and version */ if (!p->sessionid) { p->sessionid = getpid(); p->sessionversion = p->sessionid; } else p->sessionversion++; /* Ok, let's start working with codec selection here */ capability = p->jointcapability; if (option_debug > 1) { char codecbuf[BUFSIZ]; ast_log(LOG_DEBUG, "** Our capability: %s Video flag: %s\n", ast_getformatname_multiple(codecbuf, sizeof(codecbuf), capability), ast_test_flag(&p->flags[0], SIP_NOVIDEO) ? "True" : "False"); ast_log(LOG_DEBUG, "** Our prefcodec: %s \n", ast_getformatname_multiple(codecbuf, sizeof(codecbuf), p->prefcodec)); } #ifdef WHEN_WE_HAVE_T38_FOR_OTHER_TRANSPORTS if ((ast_test_flag(&p->t38.t38support, SIP_PAGE2_T38SUPPORT_RTP))) { ast_build_string(&m_audio_next, &m_audio_left, " %d", 191); ast_build_string(&a_audio_next, &a_audio_left, "a=rtpmap:%d %s/%d\r\n", 191, "t38", 8000); } #endif /* Check if we need video in this call */ if((capability & AST_FORMAT_VIDEO_MASK) && !ast_test_flag(&p->flags[0], SIP_NOVIDEO)) { if (p->vrtp) { needvideo = TRUE; if (option_debug > 1) ast_log(LOG_DEBUG, "This call needs video offers! \n"); } else if (option_debug > 1) ast_log(LOG_DEBUG, "This call needs video offers, but there's no video support enabled ! \n"); } /* Get our media IP addresses for RTP */ get_our_media_address(p, needvideo, &sin, &vsin, &dest, &vdest); /* Ok, we need video. Let's add what we need for video and set codecs. Video is handled differently than audio since we can not transcode. */ if (needvideo) { ast_build_string(&m_video_next, &m_video_left, "m=video %d RTP/AVP", ntohs(vdest.sin_port)); /* Build max bitrate string */ if (p->maxcallbitrate) snprintf(bandwidth, sizeof(bandwidth), "b=CT:%d\r\n", p->maxcallbitrate); if (debug) ast_verbose("Video is at %s port %d\n", ast_inet_ntoa(p->ourip), ntohs(vsin.sin_port)); /*! \todo XXX We need to select one codec, not many, since there's no transcoding */ } if (debug) ast_verbose("Audio is at %s port %d\n", ast_inet_ntoa(p->ourip), ntohs(sin.sin_port)); /* Start building generic SDP headers */ /* We break with the "recommendation" and send our IP, in order that our peer doesn't have to ast_gethostbyname() us */ snprintf(owner, sizeof(owner), "o=root %d %d IN IP4 %s\r\n", p->sessionid, p->sessionversion, ast_inet_ntoa(dest.sin_addr)); snprintf(connection, sizeof(connection), "c=IN IP4 %s\r\n", ast_inet_ntoa(dest.sin_addr)); ast_build_string(&m_audio_next, &m_audio_left, "m=audio %d RTP/AVP", ntohs(dest.sin_port)); if (ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD_ONEDIR)) hold = "a=recvonly\r\n"; else if (ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD_INACTIVE)) hold = "a=inactive\r\n"; else hold = "a=sendrecv\r\n"; /* Now, start adding audio codecs. These are added in this order: - First what was requested by the calling channel - Then preferences in order from sip.conf device config for this peer/user - Then other codecs in capabilities, including video */ /* Prefer the audio codec we were requested to use, first, no matter what Note that p->prefcodec can include video codecs, so mask them out */ if (capability & p->prefcodec) { add_codec_to_sdp(p, p->prefcodec & AST_FORMAT_AUDIO_MASK, 8000, &m_audio_next, &m_audio_left, &a_audio_next, &a_audio_left, debug, &min_audio_packet_size); alreadysent |= p->prefcodec & AST_FORMAT_AUDIO_MASK; } /* Start by sending our preferred audio codecs */ for (x = 0; x < 32; x++) { int pref_codec; if (!(pref_codec = ast_codec_pref_index(&p->prefs, x))) break; if (!(capability & pref_codec)) continue; if (alreadysent & pref_codec) continue; add_codec_to_sdp(p, pref_codec, 8000, &m_audio_next, &m_audio_left, &a_audio_next, &a_audio_left, debug, &min_audio_packet_size); alreadysent |= pref_codec; } /* Now send any other common audio and video codecs, and non-codec formats: */ for (x = 1; x <= (needvideo ? AST_FORMAT_MAX_VIDEO : AST_FORMAT_MAX_AUDIO); x <<= 1) { if (!(capability & x)) /* Codec not requested */ continue; if (alreadysent & x) /* Already added to SDP */ continue; if (x <= AST_FORMAT_MAX_AUDIO) add_codec_to_sdp(p, x, 8000, &m_audio_next, &m_audio_left, &a_audio_next, &a_audio_left, debug, &min_audio_packet_size); else add_codec_to_sdp(p, x, 90000, &m_video_next, &m_video_left, &a_video_next, &a_video_left, debug, &min_video_packet_size); } /* Now add DTMF RFC2833 telephony-event as a codec */ for (x = 1; x <= AST_RTP_MAX; x <<= 1) { if (!(p->jointnoncodeccapability & x)) continue; add_noncodec_to_sdp(p, x, 8000, &m_audio_next, &m_audio_left, &a_audio_next, &a_audio_left, debug); } if (option_debug > 2) ast_log(LOG_DEBUG, "-- Done with adding codecs to SDP\n"); if(!p->owner || !ast_internal_timing_enabled(p->owner)) ast_build_string(&a_audio_next, &a_audio_left, "a=silenceSupp:off - - - -\r\n"); if (min_audio_packet_size) ast_build_string(&a_audio_next, &a_audio_left, "a=ptime:%d\r\n", min_audio_packet_size); if (min_video_packet_size) ast_build_string(&a_video_next, &a_video_left, "a=ptime:%d\r\n", min_video_packet_size); if ((m_audio_left < 2) || (m_video_left < 2) || (a_audio_left == 0) || (a_video_left == 0)) ast_log(LOG_WARNING, "SIP SDP may be truncated due to undersized buffer!!\n"); ast_build_string(&m_audio_next, &m_audio_left, "\r\n"); if (needvideo) ast_build_string(&m_video_next, &m_video_left, "\r\n"); len = strlen(version) + strlen(subject) + strlen(owner) + strlen(connection) + strlen(stime) + strlen(m_audio) + strlen(a_audio) + strlen(hold); if (needvideo) /* only if video response is appropriate */ len += strlen(m_video) + strlen(a_video) + strlen(bandwidth) + strlen(hold); add_header(resp, "Content-Type", "application/sdp"); add_header_contentLength(resp, len); add_line(resp, version); add_line(resp, owner); add_line(resp, subject); add_line(resp, connection); if (needvideo) /* only if video response is appropriate */ add_line(resp, bandwidth); add_line(resp, stime); add_line(resp, m_audio); add_line(resp, a_audio); add_line(resp, hold); if (needvideo) { /* only if video response is appropriate */ add_line(resp, m_video); add_line(resp, a_video); add_line(resp, hold); /* Repeat hold for the video stream */ } /* Update lastrtprx when we send our SDP */ p->lastrtprx = p->lastrtptx = time(NULL); /* XXX why both ? */ if (option_debug > 2) { char buf[BUFSIZ]; ast_log(LOG_DEBUG, "Done building SDP. Settling with this capability: %s\n", ast_getformatname_multiple(buf, BUFSIZ, capability)); } return 0; }

GNURK int add_sip_domain (  const char *  domain, const enum domain_mode  mode, const char *  context )

Add SIP domain to list of domains we are responsible for. sip3_domain.c: Domain handling functions (sip domain hosting, not DNS lookups) Definition at line 95 of file sip3_domain.c. References ast_calloc, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log(), ast_strlen_zero(), LOG_DEBUG, LOG_WARNING, and option_debug. { struct domain *d; if (ast_strlen_zero(domain)) { ast_log(LOG_WARNING, "Zero length domain.\n"); return 1; } if (!(d = ast_calloc(1, sizeof(*d)))) return 0; ast_copy_string(d->domain, domain, sizeof(d->domain)); if (!ast_strlen_zero(context)) ast_copy_string(d->context, context, sizeof(d->context)); d->mode = mode; AST_LIST_LOCK(&domain_list); AST_LIST_INSERT_TAIL(&domain_list, d, list); AST_LIST_UNLOCK(&domain_list); if (option_debug > 2) ast_log(LOG_DEBUG, "Added local SIP domain '%s'\n", domain); return 1; }

GNURK int add_t38_sdp (  struct sip_request *  resp, struct sip_dialog *  p )

Add T.38 Session Description Protocol message. Definition at line 1749 of file chan_sip3.c. References add_header(), add_header_contentLength(), add_line(), ast_build_string(), ast_inet_ntoa(), ast_log(), ast_udptl_get_local_max_datagram(), ast_udptl_get_us(), t38properties::capability, debug(), t38properties::jointcapability, sip_dialog::lastrtprx, sip_dialog::lastrtptx, len, LOG_DEBUG, LOG_WARNING, sip_dialog::ourip, t38properties::peercapability, s, sip_dialog::sessionid, sip_dialog::sessionversion, sip_debug_test_pvt(), sip_dialog::t38, t38_get_rate(), T38FAX_FILL_BIT_REMOVAL, T38FAX_RATE_MANAGEMENT_LOCAL_TCF, T38FAX_TRANSCODING_JBIG, T38FAX_TRANSCODING_MMR, T38FAX_UDP_EC_NONE, T38FAX_UDP_EC_REDUNDANCY, T38FAX_VERSION, T38FAX_VERSION_0, T38FAX_VERSION_1, sip_dialog::udptl, and sip_dialog::udptlredirip. { int len = 0; int x = 0; struct sockaddr_in udptlsin; char v[256] = ""; char s[256] = ""; char o[256] = ""; char c[256] = ""; char t[256] = ""; char m_modem[256]; char a_modem[1024]; char *m_modem_next = m_modem; size_t m_modem_left = sizeof(m_modem); char *a_modem_next = a_modem; size_t a_modem_left = sizeof(a_modem); struct sockaddr_in udptldest = { 0, }; int debug; debug = sip_debug_test_pvt(p); len = 0; if (!p->udptl) { ast_log(LOG_WARNING, "No way to add SDP without an UDPTL structure\n"); return -1; } if (!p->sessionid) { p->sessionid = getpid(); p->sessionversion = p->sessionid; } else p->sessionversion++; /* Our T.38 end is */ ast_udptl_get_us(p->udptl, &udptlsin); /* Determine T.38 UDPTL destination */ if (p->udptlredirip.sin_addr.s_addr) { udptldest.sin_port = p->udptlredirip.sin_port; udptldest.sin_addr = p->udptlredirip.sin_addr; } else { udptldest.sin_addr = p->ourip; udptldest.sin_port = udptlsin.sin_port; } if (debug) ast_log(LOG_DEBUG, "T.38 UDPTL is at %s port %d\n", ast_inet_ntoa(p->ourip), ntohs(udptlsin.sin_port)); /* We break with the "recommendation" and send our IP, in order that our peer doesn't have to ast_gethostbyname() us */ if (debug) { ast_log(LOG_DEBUG, "Our T38 capability (%d), peer T38 capability (%d), joint capability (%d)\n", p->t38.capability, p->t38.peercapability, p->t38.jointcapability); } snprintf(v, sizeof(v), "v=0\r\n"); snprintf(o, sizeof(o), "o=root %d %d IN IP4 %s\r\n", p->sessionid, p->sessionversion, ast_inet_ntoa(udptldest.sin_addr)); snprintf(s, sizeof(s), "s=session\r\n"); snprintf(c, sizeof(c), "c=IN IP4 %s\r\n", ast_inet_ntoa(udptldest.sin_addr)); snprintf(t, sizeof(t), "t=0 0\r\n"); ast_build_string(&m_modem_next, &m_modem_left, "m=image %d udptl t38\r\n", ntohs(udptldest.sin_port)); if ((p->t38.jointcapability & T38FAX_VERSION) == T38FAX_VERSION_0) ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxVersion:0\r\n"); if ((p->t38.jointcapability & T38FAX_VERSION) == T38FAX_VERSION_1) ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxVersion:1\r\n"); if ((x = t38_get_rate(p->t38.jointcapability))) ast_build_string(&a_modem_next, &a_modem_left, "a=T38MaxBitRate:%d\r\n",x); ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxFillBitRemoval:%d\r\n", (p->t38.jointcapability & T38FAX_FILL_BIT_REMOVAL) ? 1 : 0); ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxTranscodingMMR:%d\r\n", (p->t38.jointcapability & T38FAX_TRANSCODING_MMR) ? 1 : 0); ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxTranscodingJBIG:%d\r\n", (p->t38.jointcapability & T38FAX_TRANSCODING_JBIG) ? 1 : 0); ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxRateManagement:%s\r\n", (p->t38.jointcapability & T38FAX_RATE_MANAGEMENT_LOCAL_TCF) ? "localTCF" : "transferredTCF"); x = ast_udptl_get_local_max_datagram(p->udptl); ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxMaxBuffer:%d\r\n",x); ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxMaxDatagram:%d\r\n",x); if (p->t38.jointcapability != T38FAX_UDP_EC_NONE) ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxUdpEC:%s\r\n", (p->t38.jointcapability & T38FAX_UDP_EC_REDUNDANCY) ? "t38UDPRedundancy" : "t38UDPFEC"); len = strlen(v) + strlen(s) + strlen(o) + strlen(c) + strlen(t) + strlen(m_modem) + strlen(a_modem); add_header(resp, "Content-Type", "application/sdp"); add_header_contentLength(resp, len); add_line(resp, v); add_line(resp, o); add_line(resp, s); add_line(resp, c); add_line(resp, t); add_line(resp, m_modem); add_line(resp, a_modem); /* Update lastrtprx when we send our SDP */ p->lastrtprx = p->lastrtptx = time(NULL); return 0; }

GNURK int add_text (  struct sip_request *  req, const char *  text )

Add text body to SIP message. Definition at line 195 of file sip3_compose.c. References add_header(), add_header_contentLength(), and add_line(). { /* XXX Convert \n's to \r\n's XXX */ add_header(req, "Content-Type", "text/plain"); add_header_contentLength(req, strlen(text)); add_line(req, text); return 0; }

GNURK void append_date (  struct sip_request *  req  )

Append date to SIP message. Definition at line 175 of file sip3_compose.c. References add_header(). { char tmpdat[256]; struct tm tm; time_t t = time(NULL); gmtime_r(&t, &tm); strftime(tmpdat, sizeof(tmpdat), "%a, %d %b %Y %T GMT", &tm); add_header(req, "Date", tmpdat); }

GNURK void append_history_full (  struct sip_dialog *  p, const char *  fmt,   ... )

Append to SIP dialog history with arg list. Definition at line 127 of file sip3_utils.c. References append_history_va(). { va_list ap; if (!dialog) return; va_start(ap, fmt); append_history_va(dialog, fmt, ap); va_end(ap); return; }

GNURK void append_history_va (  struct sip_dialog *  p, const char *  fmt, va_list  ap )

Append to SIP dialog history with arg list. Definition at line 107 of file sip3_utils.c. References ast_calloc, AST_LIST_INSERT_TAIL, free, and strsep(). { char buf[80], *c = buf; /* max history length */ struct sip_history *hist; int l; vsnprintf(buf, sizeof(buf), fmt, ap); strsep(&c, "\r\n"); /* Trim up everything after \r or \n */ l = strlen(buf) + 1; if (!(hist = ast_calloc(1, sizeof(*hist) + l))) return; if (!p->history && !(p->history = ast_calloc(1, sizeof(*p->history)))) { free(hist); return; } memcpy(hist->event, buf, l); AST_LIST_INSERT_TAIL(p->history, hist, list); }

GNURK void append_maxforwards (  struct sip_request *  req  )

Append Max-Forwards header to request. Definition at line 187 of file sip3_compose.c. References add_header(), global, and sip_globals::maxforwards. Referenced by reqprep(), transmit_refer(), and transmit_register(). { char buf[4]; snprintf(buf, sizeof(buf), "%d", global.maxforwards); add_header(req, "Max-Forwards", buf); }

GNURK void ast_quiet_chan (  struct ast_channel *  chan  )

Turn off generator data XXX Does this function belong in the SIP channel? Definition at line 4034 of file chan_sip3.c. References ast_channel::_state, ast_deactivate_generator(), AST_STATE_UP, and ast_channel::generatordata. { if (chan && chan->_state == AST_STATE_UP) { if (chan->generatordata) ast_deactivate_generator(chan); } }

GNURK void auth_headers (  enum sip_auth_type  code, char **  header, char **  respheader )

return the request and response heade for a 401 or 407 code sip3_auth.c Definition at line 133 of file sip3_auth.c. References ast_verbose(), PROXY_AUTH, and WWW_AUTH. { if (code == WWW_AUTH) { /* 401 */ *header = "WWW-Authenticate"; *respheader = "Authorization"; } else if (code == PROXY_AUTH) { /* 407 */ *header = "Proxy-Authenticate"; *respheader = "Proxy-Authorization"; } else { ast_verbose("-- wrong response code %d\n", code); *header = *respheader = "Invalid"; } }

GNURK void build_callid_pvt (  struct sip_dialog *  pvt  )

Build SIP Call-ID value for a non-REGISTER transaction. Definition at line 164 of file sip3_compose.c. References ast_inet_ntoa(), ast_string_field_build, generate_random_string(), sip_dialog::ourip, and S_OR. { char buf[33]; const char *host = S_OR(pvt->fromdomain, ast_inet_ntoa(pvt->ourip)); ast_string_field_build(pvt, callid, "%s@%s", generate_random_string(buf, sizeof(buf)), host); }

GNURK void build_contact (  struct sip_dialog *  p  )

Build contact header - the contact header we send out. Definition at line 217 of file sip3_compose.c. References ast_inet_ntoa(), ast_string_field_build, ast_strlen_zero(), sipnet, sipnet_ourport(), and STANDARD_SIP_PORT. { /* Construct Contact: header */ if (sipnet_ourport(&sipnet) != STANDARD_SIP_PORT) /* Needs to be 5060, according to the RFC */ ast_string_field_build(p, our_contact, "<sip:%s%s%s:%d>", p->exten, ast_strlen_zero(p->exten) ? "" : "@", ast_inet_ntoa(p->ourip), sipnet_ourport(&sipnet)); else ast_string_field_build(p, our_contact, "<sip:%s%s%s>", p->exten, ast_strlen_zero(p->exten) ? "" : "@", ast_inet_ntoa(p->ourip)); }

GNURK int build_reply_digest (  struct sip_dialog *  p, int  method, char *  digest, int  digest_len )

Build reply digest. Returns: Returns -1 if we have no auth Note: Build digest challenge for authentication of peers (for registration) and users (for calls). Also used for authentication of CANCEL and BYE Definition at line 428 of file sip3_auth.c. References ast_inet_ntoa(), ast_log(), ast_md5_hash(), ast_random(), ast_strlen_zero(), authl, find_realm_authentication(), LOG_DEBUG, LOG_WARNING, sip_auth::md5secret, sip_dialog::noncecount, sip_dialog::sa, sip_auth::secret, secret, sip_method2txt(), and sip_auth::username. { char a1[256]; char a2[256]; char a1_hash[256]; char a2_hash[256]; char resp[256]; char resp_hash[256]; char uri[256]; char cnonce[80]; const char *username; const char *secret; const char *md5secret; struct sip_auth *auth = NULL; /* Realm authentication */ if (!ast_strlen_zero(p->domain)) ast_copy_string(uri, p->domain, sizeof(uri)); else if (!ast_strlen_zero(p->uri)) ast_copy_string(uri, p->uri, sizeof(uri)); else snprintf(uri, sizeof(uri), "sip:%s@%s",p->peername, ast_inet_ntoa(p->sa.sin_addr)); snprintf(cnonce, sizeof(cnonce), "%08lx", ast_random()); /* Check if we have separate auth credentials */ if ((auth = find_realm_authentication(authl, p->realm))) { ast_log(LOG_WARNING, "use realm [%s] from peer [%s]\n", auth->username, p->peername); username = auth->username; secret = auth->secret; md5secret = auth->md5secret; if (sipdebug) ast_log(LOG_DEBUG,"Using realm %s authentication for call %s\n", p->realm, p->callid); } else { /* No authentication, use peer or register= config */ username = p->authname; secret = p->peersecret; md5secret = p->peermd5secret; } if (ast_strlen_zero(username)) /* We have no authentication */ return -1; /* Calculate SIP digest response */ snprintf(a1,sizeof(a1), "%s:%s:%s", username, p->realm, secret); snprintf(a2,sizeof(a2), "%s:%s", sip_method2txt(method), uri); if (!ast_strlen_zero(md5secret)) ast_copy_string(a1_hash, md5secret, sizeof(a1_hash)); else ast_md5_hash(a1_hash, a1); ast_md5_hash(a2_hash,a2); p->noncecount++; if (!ast_strlen_zero(p->qop)) snprintf(resp,sizeof(resp),"%s:%s:%08x:%s:%s:%s", a1_hash, p->nonce, p->noncecount, cnonce, "auth", a2_hash); else snprintf(resp,sizeof(resp),"%s:%s:%s", a1_hash, p->nonce, a2_hash); ast_md5_hash(resp_hash, resp); /* XXX We hard code our qop to "auth" for now. XXX */ if (!ast_strlen_zero(p->qop)) snprintf(digest, digest_len, "Digest username=\"%s\", realm=\"%s\", algorithm=MD5, uri=\"%s\", nonce=\"%s\", response=\"%s\", opaque=\"%s\", qop=auth, cnonce=\"%s\", nc=%08x", username, p->realm, uri, p->nonce, resp_hash, p->opaque, cnonce, p->noncecount); else snprintf(digest, digest_len, "Digest username=\"%s\", realm=\"%s\", algorithm=MD5, uri=\"%s\", nonce=\"%s\", response=\"%s\", opaque=\"%s\"", username, p->realm, uri, p->nonce, resp_hash, p->opaque); return 0; }

GNURK void build_rpid (  struct sip_dialog *  p  )

Build the Remote Party-ID & From using callingpres options. Definition at line 228 of file sip3_compose.c. References ast_inet_ntoa(), ast_log(), AST_PRES_ALLOWED, AST_PRES_ALLOWED_NETWORK_NUMBER, AST_PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN, AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED, AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN, AST_PRES_NUMBER_NOT_AVAILABLE, AST_PRES_PROHIB_NETWORK_NUMBER, AST_PRES_PROHIB_USER_NUMBER_FAILED_SCREEN, AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED, AST_PRES_PROHIB_USER_NUMBER_PASSED_SCREEN, AST_PRES_RESTRICTION, ast_string_field_build, ast_string_field_set, ast_strlen_zero(), sip_dialog::callingpres, ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, sip_globals::default_callerid, FALSE, global, LOG_WARNING, sip_dialog::ourip, sip_dialog::owner, S_OR, sip_dialog::tag, and TRUE. { int send_pres_tags = TRUE; const char *privacy=NULL; const char *screen=NULL; char buf[256]; const char *clid = global.default_callerid; const char *clin = NULL; const char *fromdomain; if (!ast_strlen_zero(p->rpid) || !ast_strlen_zero(p->rpid_from)) return; if (p->owner && p->owner->cid.cid_num) clid = p->owner->cid.cid_num; if (p->owner && p->owner->cid.cid_name) clin = p->owner->cid.cid_name; if (ast_strlen_zero(clin)) clin = clid; switch (p->callingpres) { case AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED: privacy = "off"; screen = "no"; break; case AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN: privacy = "off"; screen = "pass"; break; case AST_PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN: privacy = "off"; screen = "fail"; break; case AST_PRES_ALLOWED_NETWORK_NUMBER: privacy = "off"; screen = "yes"; break; case AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED: privacy = "full"; screen = "no"; break; case AST_PRES_PROHIB_USER_NUMBER_PASSED_SCREEN: privacy = "full"; screen = "pass"; break; case AST_PRES_PROHIB_USER_NUMBER_FAILED_SCREEN: privacy = "full"; screen = "fail"; break; case AST_PRES_PROHIB_NETWORK_NUMBER: privacy = "full"; screen = "pass"; break; case AST_PRES_NUMBER_NOT_AVAILABLE: send_pres_tags = FALSE; break; default: ast_log(LOG_WARNING, "Unsupported callingpres (%d)\n", p->callingpres); if ((p->callingpres & AST_PRES_RESTRICTION) != AST_PRES_ALLOWED) privacy = "full"; else privacy = "off"; screen = "no"; break; } fromdomain = S_OR(p->fromdomain, ast_inet_ntoa(p->ourip)); snprintf(buf, sizeof(buf), "\"%s\" <sip:%s@%s>", clin, clid, fromdomain); if (send_pres_tags) snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), ";privacy=%s;screen=%s", privacy, screen); ast_string_field_set(p, rpid, buf); ast_string_field_build(p, rpid_from, "\"%s\" <sip:%s@%s>;tag=%s", clin, S_OR(p->fromuser, clid), fromdomain, p->tag); }

GNURK void build_via (  struct sip_dialog *  p, int  forcenewbranch )

Build a Via header for a request. Definition at line 1236 of file sip3_dialog.c. References ast_inet_ntoa(), ast_string_field_build, ast_test_flag, sip_dialog::flags, ourdialogbranch(), sip_dialog::ourip, SIP_NAT, SIP_NAT_RFC3581, sipnet, and sipnet_ourport(). { /* Work around buggy UNIDEN UIP200 firmware */ const char *rport = ast_test_flag(&dialog->flags[0], SIP_NAT) & SIP_NAT_RFC3581 ? ";rport" : ""; /* z9hG4bK is a magic cookie. See RFC 3261 section 8.1.1.7 */ ast_string_field_build(dialog, via, "SIP/2.0/UDP %s:%d;branch=%s%s", ast_inet_ntoa(dialog->ourip), sipnet_ourport(&sipnet), ourdialogbranch(dialog, forcenewbranch), rport); }

GNURK enum check_auth_result check_auth (  struct sip_dialog *  p, struct sip_request *  req, const char *  username, const char *  secret, const char *  md5secret, int  sipmethod, char *  uri, enum xmittype  reliable, int  ignore )

Check user authorization from peer definition Some actions, like REGISTER and INVITEs from peers require authentication (if peer have secret set). Returns: 0 on success, non-zero on error Definition at line 152 of file sip3_auth.c. References ast_random(), ast_string_field_build, ast_strlen_zero(), AUTH_CHALLENGE_SENT, auth_headers(), AUTH_SUCCESSFUL, DEFAULT_TRANS_TIMEOUT, FALSE, get_header(), key(), keys, s, sip_scheddestroy(), strsep(), transmit_response_with_auth(), and WWW_AUTH. { const char *response = "407 Proxy Authentication Required"; char *reqheader; char *respheader; const char *authtoken; char a1_hash[256]; char resp_hash[256]=""; char tmp[BUFSIZ * 2]; /* Make a large enough buffer */ char *c; int wrongnonce = FALSE; int good_response; const char *usednonce = p->randdata; /* table of recognised keywords, and their value in the digest */ enum keys { K_RESP, K_URI, K_USER, K_NONCE, K_LAST }; struct x { const char *key; const char *s; } *i, keys[] = { [K_RESP] = { "response=", "" }, [K_URI] = { "uri=", "" }, [K_USER] = { "username=", "" }, [K_NONCE] = { "nonce=", "" }, [K_LAST] = { NULL, NULL} }; /* Always OK if no secret */ if (ast_strlen_zero(secret) && ast_strlen_zero(md5secret)) return AUTH_SUCCESSFUL; response = "401 Unauthorized"; auth_headers(WWW_AUTH, &respheader, &reqheader); authtoken = get_header(req, reqheader); if (ignore && !ast_strlen_zero(p->randdata) && ast_strlen_zero(authtoken)) { /* This is a retransmitted invite/register/etc, don't reconstruct authentication information */ if (!reliable) { /* Resend message if this was NOT a reliable delivery. Otherwise the retransmission should get it */ transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, 0); /* Schedule auto destroy in 32 seconds (according to RFC 3261) */ sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT); } return AUTH_CHALLENGE_SENT; } else if (ast_strlen_zero(p->randdata) || ast_strlen_zero(authtoken)) { /* We have no auth, so issue challenge and request authentication */ ast_string_field_build(p, randdata, "%08lx", ast_random()); /* Create nonce for challenge */ transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, 0); /* Schedule auto destroy in 32 seconds */ sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT); return AUTH_CHALLENGE_SENT; } /* --- We have auth, so check it */ /* Whoever came up with the authentication section of SIP can suck my %&#$&* for not putting an example in the spec of just what it is you're doing a hash on. */ /* Make a copy of the response and parse it */ ast_copy_string(tmp, authtoken, sizeof(tmp)); c = tmp; while(c && *(c = ast_skip_blanks(c)) ) { /* lookup for keys */ for (i = keys; i->key != NULL; i++) { const char *separator = ","; /* default */ if (strncasecmp(c, i->key, strlen(i->key)) != 0) continue; /* Found. Skip keyword, take text in quotes or up to the separator. */ c += strlen(i->key); if (*c == '"') { /* in quotes. Skip first and look for last */ c++; separator = "\""; } i->s = c; strsep(&c, separator); break; } if (i->key == NULL) /* not found, jump after space or comma */ strsep(&c, " ,"); } /* Verify that digest username matches the username we auth as */ if (strcmp(username, keys[K_USER].s)) { ast_log(LOG_WARNING, "username mismatch, have <%s>, digest has <%s>\n", username, keys[K_USER].s); /* Oops, we're trying something here */ return AUTH_USERNAME_MISMATCH; } /* Verify nonce from request matches our nonce. If not, send 401 with new nonce */ if (strcasecmp(p->randdata, keys[K_NONCE].s)) { /* XXX it was 'n'casecmp ? */ wrongnonce = TRUE; usednonce = keys[K_NONCE].s; } if (!ast_strlen_zero(md5secret)) ast_copy_string(a1_hash, md5secret, sizeof(a1_hash)); else { char a1[256]; snprintf(a1, sizeof(a1), "%s:%s:%s", username, global.realm, secret); ast_md5_hash(a1_hash, a1); } /* compute the expected response to compare with what we received */ { char a2[256]; char a2_hash[256]; char resp[256]; snprintf(a2, sizeof(a2), "%s:%s", sip_method2txt(sipmethod), S_OR(keys[K_URI].s, uri)); ast_md5_hash(a2_hash, a2); snprintf(resp, sizeof(resp), "%s:%s:%s", a1_hash, usednonce, a2_hash); ast_md5_hash(resp_hash, resp); } good_response = keys[K_RESP].s && !strncasecmp(keys[K_RESP].s, resp_hash, strlen(resp_hash)); if (wrongnonce) { ast_string_field_build(p, randdata, "%08lx", ast_random()); if (good_response) { if (sipdebug) ast_log(LOG_NOTICE, "Correct auth, but based on stale nonce received from '%s'\n", get_header(req, "To")); /* We got working auth token, based on stale nonce . */ transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, 1); } else { /* Everything was wrong, so give the device one more try with a new challenge */ if (sipdebug) ast_log(LOG_NOTICE, "Bad authentication received from '%s'\n", get_header(req, "To")); transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, 0); } /* Schedule auto destroy in 32 seconds */ sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT); return AUTH_CHALLENGE_SENT; } if (good_response) return AUTH_SUCCESSFUL; /* Ok, we have a bad username/secret pair */ /* Challenge again, and again, and again */ transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, 0); sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT); return AUTH_CHALLENGE_SENT; }

GNURK int check_sip_domain (  const char *  domain, char *  context, size_t  len )

check_sip_domain: Check if domain part of uri is local to our server Definition at line 132 of file sip3_domain.c. References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strlen_zero(), domain::context, and domain::domain. { struct domain *d; int result = 0; AST_LIST_LOCK(&domain_list); AST_LIST_TRAVERSE(&domain_list, d, list) { if (strcasecmp(d->domain, domain)) continue; if (len && !ast_strlen_zero(d->context)) ast_copy_string(context, d->context, len); result = 1; break; } AST_LIST_UNLOCK(&domain_list); return result; }

GNURK int clear_realm_authentication (  struct sip_auth *  authlist  )

Clear realm authentication list (at reload). Definition at line 554 of file sip3_auth.c. References free, and sip_auth::next. { struct sip_auth *a = authlist; struct sip_auth *b; while (a) { b = a; a = a->next; free(b); } return 1; }

GNURK void clear_sip_domains (  void   )

Clear our domain list (at reload). Definition at line 154 of file sip3_domain.c. References AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, and free. { struct domain *d; AST_LIST_LOCK(&domain_list); while ((d = AST_LIST_REMOVE_HEAD(&domain_list, list))) free(d); AST_LIST_UNLOCK(&domain_list); }

GNURK int close_sip_sockets (  void   )

Close all open network sockets. Definition at line 185 of file sip3_network.c. References sipnet, sip_network::sipsock, and TRUE. { /* Start with sipnet */ close(sipnet.sipsock); return TRUE; }

GNURK char* complete_sip_device (  const char *  word, int  state, int  flags2 )

Do completion on peer name. Definition at line 919 of file sip3_cliami.c. References ast_strdup, ast_test_flag, ASTOBJ_CONTAINER_TRAVERSE, and devicelist. Referenced by complete_sip_debug_device(), complete_sip_prune_realtime_peer(), complete_sip_show_device(), and complete_sipnotify(). { char *result = NULL; int wordlen = strlen(word); int which = 0; ASTOBJ_CONTAINER_TRAVERSE(&devicelist, !result, do { /* locking of the object is not required because only the name and flags are being compared */ if (!strncasecmp(word, iterator->name, wordlen) && (!flags2 || ast_test_flag(&iterator->flags[1], flags2)) && ++which > state) result = ast_strdup(iterator->name); } while(0) ); return result; }

GNURK char* complete_sip_show_device (  const char *  line, const char *  word, int  pos, int  state )

Support routine for 'sip show peer' CLI. Definition at line 936 of file sip3_cliami.c. References complete_sip_device(). { if (pos == 3) return complete_sip_device(word, state, 0); return NULL; }

GNURK int copy_all_header (  struct sip_request *  req, struct sip_request *  orig, const char *  field )

Copy all headers from one request to another. Definition at line 649 of file sip3_parse.c. References __get_header(), add_header(), and ast_strlen_zero(). { int start = 0; int copied = 0; int res; for (;;) { const char *tmp = __get_header(orig, field, &start); if (ast_strlen_zero(tmp)) break; /* Add what we're responding to */ res = add_header(req, field, tmp); if (res != -1) copied++; else return -1; } return copied ? 0 : -1; }

GNURK int copy_header (  struct sip_request *  req, struct sip_request *  orig, const char *  field )

Copy one header field from one request to another. Definition at line 638 of file sip3_parse.c. References add_header(), ast_log(), ast_strlen_zero(), get_header(), and LOG_NOTICE. { const char *tmp = get_header(orig, field); if (!ast_strlen_zero(tmp)) /* Add what we're responding to */ return add_header(req, field, tmp); ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field); return -1; }

GNURK void copy_request (  struct sip_request *  dst, const struct sip_request *  src )

copy SIP request (mostly used to save request for responses) Definition at line 238 of file sip3_parse.c. References ast_calloc, ast_log(), free, LOG_DEBUG, offset, and option_debug. { long offset; int x; offset = ((void *)dst) - ((void *)src); /* First copy stuff */ memcpy(dst, src, sizeof(*dst)); /* Now, fix data part */ if (dst->data) free(dst->data); dst->data = ast_calloc(1, src->data_size); dst->data_size = src->data_size; memcpy(dst->data, src->data, src->data_size); /* Now fix pointer arithmetic */ for (x=0; x < src->headers; x++) dst->header[x] += offset; for (x=0; x < src->lines; x++) dst->line[x] += offset; if (option_debug > 3) ast_log(LOG_DEBUG, "==== Copied request... \n"); }

GNURK int copy_via_headers (  struct sip_dialog *  p, struct sip_request *  req, struct sip_request *  orig, const char *  field )

Copy SIP VIA Headers from the request to the response. Note: If the client indicates that it wishes to know the port we received from, it adds ;rport without an argument to the topmost via header. We need to add the port number (from our point of view) to that parameter. We always add ;received=<ip address>=""> to the topmost via header. Received: RFC 3261, rport RFC 3581 Definition at line 677 of file sip3_parse.c. References __get_header(), add_header(), ast_inet_ntoa(), ast_strlen_zero(), ast_test_flag, sip_dialog::flags, sip_dialog::recv, SIP_NAT, SIP_NAT_ALWAYS, and SIP_NAT_RFC3581. { int copied = 0; int start = 0; for (;;) { char new[256]; const char *oh = __get_header(orig, field, &start); if (ast_strlen_zero(oh)) break; if (!copied) { /* Only check for empty rport in topmost via header */ char leftmost[256], *others, *rport; /* Only work on leftmost value */ ast_copy_string(leftmost, oh, sizeof(leftmost)); others = strchr(leftmost, ','); if (others) *others++ = '\0'; /* Find ;rport; (empty request) */ rport = strstr(leftmost, ";rport"); if (rport && *(rport+6) == '=') rport = NULL; /* We already have a parameter to rport */ if (rport && ( (ast_test_flag(&p->flags[0], SIP_NAT) == SIP_NAT_ALWAYS) || (ast_test_flag(&p->flags[0], SIP_NAT) == SIP_NAT_RFC3581) ) ) { /* We need to add received port - rport */ char *end; rport = strstr(leftmost, ";rport"); if (rport) { end = strchr(rport + 1, ';'); if (end) memmove(rport, end, strlen(end) + 1); else *rport = '\0'; } /* Add rport to first VIA header if requested */ /* Whoo hoo! Now we can indicate port address translation too! Just another RFC (RFC3581). I'll leave the original comments in for posterity. */ snprintf(new, sizeof(new), "%s;received=%s;rport=%d%s%s", leftmost, ast_inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port), others ? "," : "", others ? others : ""); } else { /* We should *always* add a received to the topmost via */ snprintf(new, sizeof(new), "%s;received=%s%s%s", leftmost, ast_inet_ntoa(p->recv.sin_addr), others ? "," : "", others ? others : ""); } oh = new; /* the header to copy */ } /* else add the following via headers untouched */ add_header(req, field, oh); copied++; } if (!copied) { ast_log(LOG_NOTICE, "No header field '%s' present to copy\n", field); return -1; } return 0; }

GNURK int create_addr (  struct sip_dialog *  dialog, const char *  username, char *  domain, const char *  device )

create address structure from peer name Or, if peer not found, find it in the global DNS returns TRUE (-1) on failure, FALSE on success Definition at line 808 of file chan_sip3.c. References ahp, ast_get_srv(), ast_gethostbyname(), ast_log(), ast_string_field_set, ast_strlen_zero(), ast_verbose(), create_addr_from_peer(), device_unref(), FALSE, find_device(), global, hp, LOG_DEBUG, LOG_WARNING, option_debug, option_verbose, sip_dialog::recv, sip_dialog::sa, sip_globals::srvlookup, STANDARD_SIP_PORT, sip_globals::t1default, sip_dialog::timer_t1, and TRUE. { struct hostent *hp; struct ast_hostent ahp; struct sip_device *p = NULL; char *port; int portno; char host[MAXHOSTNAMELEN], *hostn; char peername[256]; char todomain[256]; int srvcheck = TRUE; dialog->sa.sin_family = AF_INET; dialog->timer_t1 = global.t1default; /* Default SIP retransmission timer T1 (RFC 3261) */ if (!ast_strlen_zero(device)) { int res; p = find_device(device, NULL, 1); if (p) { res = create_addr_from_peer(dialog, p); device_unref(p); return res; } else { if (option_verbose > 1) ast_verbose("Can't find peer %s\n", device); return -1; /* Can't find peer */ } } /* See if we have a port. If we have a given port, disable SRV lookups */ if (!ast_strlen_zero(domain)) { ast_copy_string(todomain, domain, sizeof(todomain)); port = strchr(todomain, ':'); } if (port) { *port++ = '\0'; srvcheck = FALSE; } hostn = domain; portno = port ? atoi(port) : STANDARD_SIP_PORT; if (global.srvlookup && srvcheck) { char service[MAXHOSTNAMELEN]; int tportno; int ret; snprintf(service, sizeof(service), "_sip._udp.%s", domain); ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service); if (ret > 0) { hostn = host; portno = tportno; if (option_debug > 2) ast_log(LOG_DEBUG, "Resolved domain %s to host %s in SRV \n", domain, hostn); } } hp = ast_gethostbyname(hostn, &ahp); if (!hp) { ast_log(LOG_WARNING, "No such host: %s\n", peername); return -2; } ast_string_field_set(dialog, tohost, domain); memcpy(&dialog->sa.sin_addr, hp->h_addr, sizeof(dialog->sa.sin_addr)); dialog->sa.sin_port = htons(portno); dialog->recv = dialog->sa; return 0; }

GNURK void destroy_association (  struct sip_device *  peer  )

Remove registration data from realtime database or AST/DB when registration expires. Definition at line 380 of file sip3_objects.c. References ast_db_del(), ast_test_flag, ast_update_realtime(), sip_device::flags, sip_globals::flags, global, SIP_PAGE2_IGNOREREGEXPIRE, and SIP_PAGE2_RT_FROMCONTACT. { if (!ast_test_flag(&global.flags[1], SIP_PAGE2_IGNOREREGEXPIRE)) { if (ast_test_flag(&device->flags[1], SIP_PAGE2_RT_FROMCONTACT)) ast_update_realtime("sippeers", "name", device->name, "fullcontact", "", "ipaddr", "", "port", "", "regseconds", "0", "defaultuser", "", "regserver", "", NULL); else ast_db_del("SIP3-Registry", device->name); } }

GNURK int determine_firstline_parts (  struct sip_request *  req  )

Parse first line of incoming SIP request. Definition at line 865 of file sip3_parse.c. References ast_log(), sip_request::header, LOG_WARNING, sip_request::rlPart1, and sip_request::rlPart2. { char *e = ast_skip_blanks(req->header[0]); /* there shouldn't be any */ if (!*e) return -1; req->rlPart1 = e; /* method or protocol */ e = ast_skip_nonblanks(e); if (*e) *e++ = '\0'; /* Get URI or status code */ e = ast_skip_blanks(e); if ( !*e ) return -1; ast_trim_blanks(e); if (!strcasecmp(req->rlPart1, "SIP/2.0") ) { /* We have a response */ if (strlen(e) < 3) /* status code is 3 digits */ return -1; req->rlPart2 = e; } else { /* We have a request */ if ( *e == '<' ) { /* XXX the spec says it must not be in <> ! */ ast_log(LOG_WARNING, "bogus uri in <> %s\n", e); e++; if (!*e) return -1; } req->rlPart2 = e; /* URI */ e = ast_skip_nonblanks(e); if (*e) *e++ = '\0'; e = ast_skip_blanks(e); if (strcasecmp(e, "SIP/2.0") ) { ast_log(LOG_WARNING, "Bad request protocol %s\n", e); return -1; } } return 1; }

GNURK struct sip_device* device_ref (  struct sip_device *  device  )

Add reference for device. Definition at line 436 of file sip3_config.c. References ast_log(), ASTOBJ_REF, LOG_DEBUG, option_debug, and sipdebug. { ASTOBJ_REF(device); if (option_debug > 3 && sipdebug) ast_log(LOG_DEBUG, "/// Adding reference to device %s - refcount now %d\n", device->name, device->refcount); return device; }

GNURK int device_status (  struct sip_device *  device, char *  status, int  statuslen )

Report Device status in character string. Returns: 0 if peer is unreachable, 1 if peer is online, -1 if unmonitored Definition at line 183 of file sip3_cliami.c. References sip_device::lastms, and sip_device::maxms. Referenced by _sip_show_device(), _sip_show_devices(), and function_sippeer(). { int res = 0; if (device->maxms) { if (device->lastms < 0) { ast_copy_string(status, "UNREACHABLE", statuslen); } else if (device->lastms > device->maxms) { snprintf(status, statuslen, "LAGGED (%d ms)", device->lastms); res = 1; } else if (device->lastms) { snprintf(status, statuslen, "OK (%d ms)", device->lastms); res = 1; } else { ast_copy_string(status, "UNKNOWN", statuslen); } } else { ast_copy_string(status, "Unmonitored", statuslen); /* Checking if port is 0 */ res = -1; } return res; }

GNURK void device_unref (  struct sip_device *  device  )

Remove reference for device. When we reach 0, device is removed from memory. Definition at line 425 of file sip3_config.c. References ast_log(), ASTOBJ_UNREF, LOG_DEBUG, option_debug, sip_destroy_device(), and sipdebug. Referenced by __sip_autodestruct(), _sip_show_device(), check_user_full(), create_addr(), expire_register(), function_sippeer(), handle_request_subscribe(), register_verify(), sip_devicestate(), sip_do_debug_device(), and update_call_counter(). { if (!device) return; if (option_debug > 3 && sipdebug) ast_log(LOG_DEBUG, "/// Removing reference from device %s - refcount now %d\n", device->name, device->refcount - 1); ASTOBJ_UNREF(device, sip_destroy_device); }

GNURK void dialog_lock (  struct sip_dialog *  dialog, int  state )

Helper function to lock and unlock, hiding the underlying locking mechanism. Parameters: state  TRUE for lock, FALSE for unlock Definition at line 146 of file sip3_dialog.c. References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), sip_dialog::lock, LOG_DEBUG, LOG_ERROR, option_debug, and sipdebug. Referenced by __sip_ack(), auto_congest(), check_rtp_timeout(), get_sip_dialog_byid_locked(), handle_invite_replaces(), handle_request_invite(), handle_request_subscribe(), handle_response_answer(), local_attended_transfer(), process_sip_queue(), retrans_pkt(), sip_answer(), sip_dtmfmode(), sip_fixup(), sip_get_rtp_peer(), sip_get_udptl_peer(), sip_handle_t38_reinvite(), sip_hangup(), sip_indicate(), sip_new(), sip_read(), sip_senddigit_begin(), sip_senddigit_end(), sip_set_rtp_peer(), sip_transfer(), sip_write(), and write_media_frame(). { if (!dialog) { ast_log(LOG_ERROR, "-DIALOGLOCK- Trying to %s non-existing dialog. Giving up.\n", state ? "lock" : "unlock"); return; } if (sipdebug && option_debug > 4) ast_log(LOG_DEBUG, "-DIALOGLOCK- %s dialog %s\n", state ? " locking" : "unlocking", dialog->callid ? dialog->callid : "<no callid>"); if (state) ast_mutex_lock(&dialog->lock); else ast_mutex_unlock(&dialog->lock); }

GNURK void dialoglist_lock (  void   )

Lock list of active SIP dialogs. Definition at line 122 of file sip3_dialog.c. References ast_log(), ast_mutex_lock(), ast_mutex_trylock(), LOG_DEBUG, option_debug, and sipdebug. { int counter = 0; while (ast_mutex_trylock(&dialoglock) && counter < 100) { if (option_debug > 4) ast_log(LOG_DEBUG, "---Trying to lock dialoglist -- %d \n", ++counter); } if (counter == 100) ast_mutex_lock(&dialoglock); if (sipdebug && option_debug > 4) ast_log(LOG_DEBUG, "=== SIP dialog list: LOCKED\n"); }

GNURK void dialoglist_unlock (  void   )

Unlock list of active SIP dialogs. Definition at line 136 of file sip3_dialog.c. References ast_log(), ast_mutex_unlock(), LOG_DEBUG, option_debug, and sipdebug. { ast_mutex_unlock(&dialoglock); if (sipdebug && option_debug > 4) ast_log(LOG_DEBUG, "=== SIP dialog list: UNLOCKED\n"); }

GNURK const char* dialogstate2str (  const enum dialogstate  state  )

Convert SIP dialog states to string. Definition at line 162 of file sip3_dialog.c. References DIALOG_STATE_CONFIRMED, DIALOG_STATE_CONFIRMED_HOLD, DIALOG_STATE_EARLY, DIALOG_STATE_PROCEEDING, DIALOG_STATE_TERMINATED, DIALOG_STATE_TERMINATED_AUTH, and DIALOG_STATE_TRYING. Referenced by dialogstatechange(), sip_hangup(), and sip_show_channel(). { const char *reply = "<unknown>"; switch (state) { case DIALOG_STATE_TRYING: reply = "Trying"; break; case DIALOG_STATE_PROCEEDING: reply = "Proceeding"; break; case DIALOG_STATE_EARLY: reply = "Early"; break; case DIALOG_STATE_CONFIRMED: reply = "Confirmed"; break; case DIALOG_STATE_CONFIRMED_HOLD: reply = "Confirmed, on hold"; break; case DIALOG_STATE_TERMINATED: reply = "Terminated"; break; case DIALOG_STATE_TERMINATED_AUTH: reply = "Terminated, auth"; break; } return reply; }

GNURK void dialogstatechange (  struct sip_dialog *  dialog, enum dialogstate  newstate )

Change dialog state for a SIP dialog and output to debug. Definition at line 192 of file sip3_dialog.c. References append_history, ast_log(), dialogstate2str(), global, sip_dialog::icseq, LOG_DEBUG, sip_dialog::ocseq, option_debug, sip_globals::recordhistory, sipdebug, and sip_dialog::state. Referenced by handle_request(), handle_request_info(), handle_request_invite(), handle_request_subscribe(), handle_response_invite(), handle_response_notify(), handle_response_peerpoke(), sip_alloc(), sip_answer(), sip_hangup(), sip_indicate(), and transmit_final_response(). { if (dialog->state == newstate) { if (option_debug > 3) ast_log(LOG_DEBUG, "Asked to change state to dialog that already has requested state: %s State %s\n", dialog->callid, dialogstate2str(newstate)); } else { dialog->state = newstate; if (sipdebug && option_debug > 1) ast_log(LOG_DEBUG, "-- Dialog %s changed state to %s\n", dialog->callid, dialogstate2str(newstate)); if (global.recordhistory) append_history(dialog, "DialogState", "New state: %s O-Cseq %d I-Cseq %d", dialogstate2str(newstate), dialog->ocseq, dialog->icseq); } /* When state is terminated, keep it for 32 secs to allow for retransmits */ }

GNURK int do_proxy_auth (  struct sip_dialog *  p, struct sip_request *  req, enum sip_auth_type  code, int  sipmethod, int  init )

Add authentication on outbound SIP packet. Definition at line 327 of file sip3_auth.c. References ast_calloc, ast_log(), sip_invite_param::auth, auth_headers(), sip_invite_param::authheader, sip_dialog::authtries, sip_dialog::inviteoptions, LOG_DEBUG, option_debug, reply_digest(), SIP_INVITE, sip_method2txt(), and transmit_invite(). { char *header, *respheader; char digest[1024]; if (!p->inviteoptions && !(p->inviteoptions = ast_calloc(1, sizeof(*p->inviteoptions)))) return -2; p->authtries++; auth_headers(code, &header, &respheader); if (option_debug > 1) ast_log(LOG_DEBUG, "Auth attempt %d on %s\n", p->authtries, sip_method2txt(sipmethod)); memset(digest, 0, sizeof(digest)); if (reply_digest(p, req, header, sipmethod, digest, sizeof(digest) )) { /* No way to authenticate */ return -1; } /* Now we have a reply digest */ p->inviteoptions->auth = digest; p->inviteoptions->authheader = respheader; return transmit_invite(p, sipmethod, sipmethod == SIP_INVITE, init); }

GNURK int do_register_auth (  struct sip_dialog *  p, struct sip_request *  req, enum sip_auth_type  code )

Authenticate for outbound registration. Definition at line 303 of file sip3_auth.c. References append_history, ast_test_flag, ast_verbose(), auth_headers(), sip_dialog::authtries, sip_dialog::flags, reply_digest(), sip_debug_test_pvt(), SIP_NO_HISTORY, SIP_REGISTER, and transmit_register(). { char *header, *respheader; char digest[1024]; p->authtries++; auth_headers(code, &header, &respheader); memset(digest,0,sizeof(digest)); if (reply_digest(p, req, header, SIP_REGISTER, digest, sizeof(digest))) { /* There's nothing to use for authentication */ /* No digest challenge in request */ if (sip_debug_test_pvt(p) && p->registry) ast_verbose("No authentication challenge, sending blank registration to domain/host name %s\n", p->registry->hostname); /* No old challenge */ return -1; } if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY)) append_history(p, "RegistryAuth", "Try: %d", p->authtries); if (sip_debug_test_pvt(p) && p->registry) ast_verbose("Responding to challenge, registration to domain/host name %s\n", p->registry->hostname); return transmit_register(p->registry, SIP_REGISTER, digest, respheader); }

GNURK void do_setnat (  struct sip_dialog *  p, int  natflags )

Set nat mode on the various media streams. Definition at line 668 of file chan_sip3.c. References ast_log(), ast_rtp_setnat(), ast_udptl_setnat(), LOG_DEBUG, option_debug, sip_dialog::rtp, sip_dialog::udptl, and sip_dialog::vrtp. { const char *mode = natflags ? "On" : "Off"; if (dialog->rtp) { if (option_debug) ast_log(LOG_DEBUG, "Setting NAT on RTP to %s\n", mode); ast_rtp_setnat(dialog->rtp, natflags); } if (dialog->vrtp) { if (option_debug) ast_log(LOG_DEBUG, "Setting NAT on VRTP to %s\n", mode); ast_rtp_setnat(dialog->vrtp, natflags); } if (dialog->udptl) { if (option_debug) ast_log(LOG_DEBUG, "Setting NAT on UDPTL to %s\n", mode); ast_udptl_setnat(dialog->udptl, natflags); } }

void* do_sip_monitor (  void *  data  )

The SIP monitoring thread. Note: This thread monitors all the SIP sessions and peers that needs notification of mwi (and thus do not have a separate thread) indefinitely Definition at line 249 of file sip3_monitor.c. References ast_io_add(), ast_io_change(), AST_IO_IN, ast_verbose(), FALSE, io, option_verbose, sip_network::read_id, sip_do_reload(), sip_reload_check(), sipnet, sip_network::sipsock, sipsock_read(), sipsocket_initialized(), and VERBOSE_PREFIX_1. Referenced by restart_monitor(). { int res; struct sip_dialog *sip; struct sip_device *device = NULL; time_t now; int fastrestart = FALSE; int lastpeernum = -1; int curpeernum; static int nowalkmessage = 0; /* Add an I/O event to our SIP UDP socket */ if (sipsocket_initialized(&sipnet)) sipnet.read_id = ast_io_add(io, sipnet.sipsock, sipsock_read, AST_IO_IN, NULL); /* From here on out, we die whenever asked */ for(;;) { /*------ Check for a reload request */ if (sip_reload_check()) { if (option_verbose > 0) ast_verbose(VERBOSE_PREFIX_1 "Reloading SIP\n"); sip_do_reload(); /* Change the I/O fd of our UDP socket */ if (sipsocket_initialized(&sipnet)) sipnet.read_id = ast_io_change(io, sipnet.read_id, sipnet.sipsock, NULL, 0, NULL); } /*----- Check for interfaces needing to be killed */ if (dialoglist != NULL && !fastrestart) { struct sip_dialog *nextdialog; if (option_debug > 4) ast_log(LOG_DEBUG, ":: MONITOR :: Walking dialog list.\n"); dialoglist_lock(); restartsearch: now = time(NULL); /* don't scan the interface list if it hasn't been a reasonable period of time since the last time we did it (when MWI is being sent, we can get back to this point every millisecond or less) */ for (sip = dialoglist; sip; sip = nextdialog) { nextdialog = sip->next; /* Check RTP timeouts and kill calls if we have a timeout set and do not get RTP or RTCP */ check_rtp_timeout(sip, now); /* If we have sessions that needs to be destroyed, do it now */ if (ast_test_flag(&sip->flags[0], SIP_NEEDDESTROY) && !sip->packets && !sip->owner) { __sip_destroy(sip, TRUE, FALSE); //goto restartsearch; } } dialoglist_unlock(); nowalkmessage = 0; } else if (!fastrestart && sipdebug && option_debug > 4) { if (!nowalkmessage) ast_log(LOG_DEBUG, ":: MONITOR :: Empty dialog list. Pausing channel walks\n"); nowalkmessage = 1; } pthread_testcancel(); /*------ Wait for sched or io */ res = ast_sched_wait(sched); if ((res < 0) || (res > 1000)) res = 1000; /* If we might need to send more mailboxes, don't wait long at all.*/ if (fastrestart) res = 1; res = ast_io_wait(io, res); if (option_debug && res > 20) ast_log(LOG_DEBUG, "chan_sip: ast_io_wait ran %d all at once\n", res); ast_mutex_lock(&monlock); if (res >= 0) { res = ast_sched_runq(sched); /* Check for scheduled items, like retransmits */ if (option_debug && res >= 20) ast_log(LOG_DEBUG, "chan_sip: ast_sched_runq ran %d all at once\n", res); } /*----- Send MWI notifications to devices - static and cached realtime peers */ if (sipcounters.peers_with_mwi > 0 ) { fastrestart = FALSE; curpeernum = 0; device= NULL; /* Find next device that needs mwi */ ASTOBJ_CONTAINER_TRAVERSE(&devicelist, !device, do { if ((curpeernum > lastpeernum) && does_peer_need_mwi(iterator)) { fastrestart = TRUE; lastpeernum = curpeernum; device = device_ref(iterator); }; curpeernum++; } while (0) ); /* Send MWI to the peer */ if (device) { ASTOBJ_WRLOCK(device); sip_send_mwi_to_peer(device); ASTOBJ_UNLOCK(device); device_unref(device); } else { /* Reset where we come from */ lastpeernum = -1; } } ast_mutex_unlock(&monlock); } /* Never reached */ return NULL; }

GNURK const char* domain_mode_to_text (  const enum domain_mode  mode  )

Print domain mode to cli. Definition at line 191 of file sip3_domain.c. References SIP_DOMAIN_AUTO, and SIP_DOMAIN_CONFIG. { switch (mode) { case SIP_DOMAIN_AUTO: return "[Automatic]"; case SIP_DOMAIN_CONFIG: return "[Configured]"; } return ""; }

GNURK int domains_configured (  void   )

return TRUE if any domains are configured for this server Definition at line 125 of file sip3_domain.c. References AST_LIST_EMPTY. Referenced by get_destination(), handle_request_refer(), register_verify(), sip_show_domains(), and sip_show_settings(). { return (!AST_LIST_EMPTY(&domain_list)); }

GNURK int expire_register (  void *  data  )

Expire registration of SIP peer. Definition at line 391 of file sip3_objects.c. References sip_device::addr, ast_device_state_changed(), ast_test_flag, ASTOBJ_CONTAINER_UNLINK, destroy_association(), device_unref(), devicelist, EVENT_FLAG_SYSTEM, sip_device::expire, FALSE, sip_device::flags, manager_event, register_peer_exten(), SIP_PAGE2_RTAUTOCLEAR, and SIP_PAGE2_SELFDESTRUCT. { struct sip_device *device = data; if (!device) /* Hmmm. We have no peer. Weird. */ return 0; memset(&device->addr, 0, sizeof(device->addr)); destroy_association(device); /* remove registration data from storage */ manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "Peer: SIP/%s\r\nPeerStatus: Unregistered\r\nCause: Expired\r\n", device->name); register_peer_exten(device, FALSE); /* Remove regexten */ device->expire = -1; ast_device_state_changed("SIP/%s", device->name); /* Do we need to release this peer from memory? Only for realtime peers and autocreated peers */ if (ast_test_flag(&device->flags[1], SIP_PAGE2_SELFDESTRUCT) || ast_test_flag(&device->flags[1], SIP_PAGE2_RTAUTOCLEAR)) { device = ASTOBJ_CONTAINER_UNLINK(&devicelist, device); /* Remove from peer list */ device_unref(device); } return 0; }

GNURK void extract_uri (  struct sip_dialog *  p, struct sip_request *  req )

Check Contact: URI of SIP message. Definition at line 906 of file sip3_parse.c. References ast_string_field_set, ast_strlen_zero(), get_header(), get_in_brackets(), and strsep(). { char stripped[256]; char *c; ast_copy_string(stripped, get_header(req, "Contact"), sizeof(stripped)); c = get_in_brackets(stripped); c = strsep(&c, ";"); /* trim ; and beyond */ if (!ast_strlen_zero(c)) ast_string_field_set(p, uri, c); }

GNURK const char* find_alias (  const char *  name, const char *  _default )

Find compressed SIP alias Structure for conversion between compressed SIP and "normal" SIP. Definition at line 320 of file sip3_parse.c. References aliases. { /*! \brief Structure for conversion between compressed SIP and "normal" SIP */ static const struct cfalias { char * const fullname; char * const shortname; } aliases[] = { { "Content-Type", "c" }, { "Content-Encoding", "e" }, { "From", "f" }, { "Call-ID", "i" }, { "Contact", "m" }, { "Content-Length", "l" }, { "Subject", "s" }, { "To", "t" }, { "Supported", "k" }, { "Refer-To", "r" }, { "Referred-By", "b" }, { "Allow-Events", "u" }, { "Event", "o" }, { "Via", "v" }, { "Accept-Contact", "a" }, { "Reject-Contact", "j" }, { "Request-Disposition", "d" }, { "Session-Expires", "x" }, { "Identity", "y" }, { "Identity-Info", "n" }, }; int x; for (x=0; x<sizeof(aliases) / sizeof(aliases[0]); x++) if (!strcasecmp(aliases[x].fullname, name)) return aliases[x].shortname; return _default; }

GNURK struct sip_device* find_device (  const char *  peer, struct sockaddr_in *  sin, int  realtime )

Locate peer by name or ip address This is used on incoming SIP message to find matching peer on ip or outgoing message to find matching peer on name. sip3_objects.c Definition at line 242 of file sip3_objects.c. References ASTOBJ_CONTAINER_FIND, ASTOBJ_CONTAINER_FIND_FULL, devicelist, name, realtime_peer(), and sip_addrcmp(). Referenced by _sip_show_device(), check_user_full(), create_addr(), function_sippeer(), register_verify(), sip_devicestate(), sip_do_debug_device(), sip_peer_hold(), and update_call_counter(). { struct sip_device *peer = NULL; if (device) peer = ASTOBJ_CONTAINER_FIND(&devicelist, device); else peer = ASTOBJ_CONTAINER_FIND_FULL(&devicelist, sin, name, sip_addr_hashfunc, 1, sip_addrcmp); if (!peer && realtime) peer = realtime_peer(device, sin); return peer; }

GNURK struct sip_auth* find_realm_authentication (  struct sip_auth *  authlist, const char *  realm )

Find authentication for a specific realm. Definition at line 569 of file sip3_auth.c. References sip_auth::next, and sip_auth::realm. { struct sip_auth *a; for (a = authlist; a; a = a->next) { if (!strcasecmp(a->realm, realm)) break; } return a; }

GNURK int find_sdp (  struct sip_request *  req  )

Determine whether a SIP message contains an SDP in its body. Parameters: req  the SIP request to process Returns: TRUE if SDP found, FALSE if not found Also updates req->sdp_start and req->sdp_end to indicate where the SDP lives in the message body. Definition at line 880 of file sip3_sdprtp.c. References ast_strdupa, ast_strlen_zero(), FALSE, get_header(), sip_request::line, sip_request::lines, sip_request::sdp_end, sip_request::sdp_start, strcasestr(), and TRUE. { const char *content_type; const char *search; char *boundary; unsigned int x; content_type = get_header(req, "Content-Type"); /* if the body contains only SDP, this is easy */ if (!strcasecmp(content_type, "application/sdp")) { req->sdp_start = 0; req->sdp_end = req->lines; return TRUE; } /* if it's not multipart/mixed, there cannot be an SDP */ if (strncasecmp(content_type, "multipart/mixed", 15)) return FALSE; /* if there is no boundary marker, it's invalid */ if (!(search = strcasestr(content_type, ";boundary="))) return FALSE; search += 10; if (ast_strlen_zero(search)) return FALSE; /* make a duplicate of the string, with two extra characters at the beginning */ boundary = ast_strdupa(search - 2); boundary[0] = boundary[1] = '-'; /* search for the boundary marker, but stop when there are not enough lines left for it, the Content-Type header and at least one line of body */ for (x = 0; x < (req->lines - 2); x++) { if (!strncasecmp(req->line[x], boundary, strlen(boundary)) && !strcasecmp(req->line[x + 1], "Content-Type: application/sdp")) { x += 2; req->sdp_start = x; /* search for the end of the body part */ for ( ; x < req->lines; x++) { if (!strncasecmp(req->line[x], boundary, strlen(boundary))) break; } req->sdp_end = x; return TRUE; } } return FALSE; }

GNURK int find_sip_method (  const char *  msg  )

find_sip_method: Find SIP method from header Definition at line 163 of file sip3_parse.c. References ast_strlen_zero(), method_match(), and sip_methods. { int i, res = 0; if (ast_strlen_zero(msg)) return 0; for (i = 1; i < (sizeof(sip_methods) / sizeof(sip_methods[0])) && !res; i++) { if (method_match(i, msg)) res = sip_methods[i].id; } return res; }

GNURK const struct cfsubscription_types* find_subscription_type (  enum subscriptiontype  subtype  )

Find subscription type in array. Definition at line 119 of file sip3_subscribe.c. References subscription_types, and type. { int i; for (i = 1; (i < (sizeof(subscription_types) / sizeof(subscription_types[0]))); i++) { if (subscription_types[i].type == subtype) { return &subscription_types[i]; } } return &subscription_types[0]; }

GNURK void find_via_branch (  struct sip_request *  req, char *  viabuf, size_t  vialen )

Find via branch parameter. Definition at line 1196 of file sip3_dialog.c. References ast_log(), ast_strdupa, ast_strlen_zero(), ast_test_flag, LOG_DEBUG, option_debug, SIP_PKT_DEBUG, strcasestr(), and sip_request::via. Referenced by match_or_create_dialog(). { char *dupvia; char *viabranch; char *sep; if (ast_strlen_zero(req->via)) return; dupvia = ast_strdupa(req->via); if (!(viabranch = strcasestr(dupvia, ";branch="))) return; viabranch += 8; if ((sep = strchr(viabranch, ';'))) *sep = '\0'; if (ast_test_flag(req, SIP_PKT