Mon Apr 30 07:39:56 2007

Asterisk developer's documentation

---

chan_sip.c File Reference

Implementation of Session Initiation Protocol. More...

#include "asterisk.h"
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <errno.h>
#include <stdlib.h>
#include <fcntl.h>
#include <netdb.h>
#include <signal.h>
#include <sys/signal.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <arpa/inet.h>
#include <netinet/ip.h>
#include <regex.h>
#include "asterisk/lock.h"
#include "asterisk/channel.h"
#include "asterisk/config.h"
#include "asterisk/logger.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/options.h"
#include "asterisk/sched.h"
#include "asterisk/io.h"
#include "asterisk/rtp.h"
#include "asterisk/udptl.h"
#include "asterisk/acl.h"
#include "asterisk/manager.h"
#include "asterisk/callerid.h"
#include "asterisk/cli.h"
#include "asterisk/app.h"
#include "asterisk/musiconhold.h"
#include "asterisk/dsp.h"
#include "asterisk/features.h"
#include "asterisk/srv.h"
#include "asterisk/astdb.h"
#include "asterisk/causes.h"
#include "asterisk/utils.h"
#include "asterisk/file.h"
#include "asterisk/astobj.h"
#include "asterisk/devicestate.h"
#include "asterisk/linkedlists.h"
#include "asterisk/stringfields.h"
#include "asterisk/monitor.h"
#include "asterisk/localtime.h"
#include "asterisk/abstract_jb.h"
#include "asterisk/compiler.h"
#include "asterisk/threadstorage.h"
#include "asterisk/translate.h"

Include dependency graph for chan_sip.c:

Go to the source code of this file.

Data Structures
struct	ast_peer_list
	The peer list: Peers and Friends. More...
struct	ast_register_list
	The register list: Other SIP proxys we register with and place calls to. More...
struct	ast_user_list
	The user list: Users and friends. More...
struct	c_referstatusstring
struct	cfsip_methods
struct	cfsip_options
	List of well-known SIP options. If we get this in a require, we should check the list and answer accordingly. More...
struct	cfsubscription_types
struct	domain
	Domain data structure. More...
struct	sip_auth
	sip_auth: Credentials for authentication to other SIP services More...
struct	sip_dual
	structure used in transfers More...
struct	sip_history
	sip_history: Structure for saving transactions within a SIP dialog More...
struct	sip_invite_param
	Parameters to the transmit_invite function. More...
struct	sip_peer
	Structure for SIP peer data, we place calls to peers if registered or fixed IP address (host). More...
struct	sip_pkt
	sip packet - raw format for outbound packets that are sent or scheduled for transmission More...
struct	sip_pvt
	sip_pvt: PVT structures are used for each SIP dialog, ie. a call, a registration, a subscribe More...
struct	sip_refer
	Structure to handle SIP transfers. Dynamically allocated when needed. More...
struct	sip_registry
	Registrations with other SIP proxies. More...
struct	sip_request
	sip_request: The data grabbed from the UDP socket More...
struct	sip_route
	Structure to save routing information for a SIP session. More...
struct	sip_user
	Structure for SIP user data. User's place calls to us. More...
struct	t38properties
	T.38 channel settings (at some point we need to make this alloc'ed. More...
Defines
#define	ALLOWED_METHODS   "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, SUBSCRIBE, NOTIFY"
	SIP Methods we support.
#define	append_history(p, event, fmt, args...)   append_history_full(p, "%-15s " fmt, event, ## args)
	Append to SIP dialog history.
#define	CALLERID_UNKNOWN   "Unknown"
#define	CAN_CREATE_DIALOG   1
#define	CAN_CREATE_DIALOG_UNSUPPORTED_METHOD   2
#define	CAN_NOT_CREATE_DIALOG   0
#define	DEC_CALL_LIMIT   0
#define	DEC_CALL_RINGING   2
#define	DEFAULT_ALLOW_EXT_DOM   TRUE
#define	DEFAULT_ALLOWGUEST   TRUE
#define	DEFAULT_AUTOCREATEPEER   FALSE
#define	DEFAULT_CALLERID   "asterisk"
#define	DEFAULT_COMPACTHEADERS   FALSE
#define	DEFAULT_CONTEXT   "default"
#define	DEFAULT_DEFAULT_EXPIRY   120
#define	DEFAULT_EXPIRY   900
#define	DEFAULT_FREQ_NOTOK   10 * 1000
#define	DEFAULT_FREQ_OK   60 * 1000
#define	DEFAULT_MAX_CALL_BITRATE   (384)
#define	DEFAULT_MAX_EXPIRY   3600
#define	DEFAULT_MAX_FORWARDS   "70"
#define	DEFAULT_MAXMS   2000
#define	DEFAULT_MIN_EXPIRY   60
#define	DEFAULT_MOHINTERPRET   "default"
#define	DEFAULT_MOHSUGGEST   ""
#define	DEFAULT_MWITIME   10
#define	DEFAULT_NOTIFYMIME   "application/simple-message-summary"
#define	DEFAULT_NOTIFYRINGING   TRUE
#define	DEFAULT_PEDANTIC   FALSE
#define	DEFAULT_QUALIFY   FALSE
#define	DEFAULT_REALM   "asterisk"
#define	DEFAULT_REGISTRATION_TIMEOUT   20
#define	DEFAULT_RETRANS   1000
#define	DEFAULT_SRVLOOKUP   FALSE
#define	DEFAULT_T1MIN   100
#define	DEFAULT_TOS_AUDIO   0
#define	DEFAULT_TOS_SIP   0
#define	DEFAULT_TOS_VIDEO   0
#define	DEFAULT_TRANS_TIMEOUT   -1
#define	DEFAULT_USERAGENT   "Asterisk PBX"
#define	DEFAULT_VMEXTEN   "asterisk"
#define	EXPIRY_GUARD_LIMIT   30
#define	EXPIRY_GUARD_MIN   500
#define	EXPIRY_GUARD_PCT   0.20
#define	EXPIRY_GUARD_SECS   15
#define	FALSE   0
#define	FLAG_FATAL   (1 << 1)
#define	FLAG_RESPONSE   (1 << 0)
#define	FORMAT   "%-15.15s %-10.10s %-11.11s %5.5d/%5.5d %-4.4s %-3.3s %-3.3s %-15.15s %-10.10s\n"
#define	FORMAT   "%-30.30s %-12.12s %8d %-20.20s %-25.25s\n"
#define	FORMAT   "%-40.40s %-20.20s %-16.16s\n"
#define	FORMAT   "%-25.25s %-15.15s %-3.3s %-3.3s %-3.3s %-8d %-10s %-10s\n"
#define	FORMAT   "%-25.25s %-15.15s %-15.15s %-15.15s %-5.5s%-10.10s\n"
#define	FORMAT   "%-25.25s %-15.15s %-15.15s \n"
#define	FORMAT2   "%-15.15s %-10.10s %-11.11s %-11.11s %-4.4s %-7.7s %-15.15s\n"
#define	FORMAT2   "%-30.30s %-12.12s %8.8s %-20.20s %-25.25s\n"
#define	FORMAT2   "%-25.25s %-15.15s %-3.3s %-3.3s %-3.3s %-8s %-10s %-10s\n"
#define	FORMAT2   "%-25.25s %-15.15s %-15.15s \n"
#define	FORMAT3   "%-15.15s %-10.10s %-11.11s %-15.15s %-13.13s %-15.15s %-10.10s\n"
#define	INC_CALL_LIMIT   1
#define	INC_CALL_RINGING   3
#define	INITIAL_CSEQ   101
#define	IPTOS_MINCOST   0x02
#define	MAX(a, b)   ((a) > (b) ? (a) : (b))
#define	MAX_AUTHTRIES   3
#define	MAX_RETRANS   6
#define	NO_RTP   0
#define	NOT_SUPPORTED   0
#define	RTP   1
#define	SDP_SAMPLE_RATE(x)   (x == AST_FORMAT_G722) ? 16000 : 8000
#define	SIP_ALREADYGONE   (1 << 0)
#define	SIP_CALL_LIMIT   (1 << 28)
#define	SIP_CAN_REINVITE   (1 << 20)
#define	SIP_CAN_REINVITE_NAT   (2 << 20)
#define	SIP_DEFER_BYE_ON_TRANSFER   (1 << 15)
#define	SIP_DTMF   (3 << 16)
#define	SIP_DTMF_AUTO   (3 << 16)
#define	SIP_DTMF_INBAND   (1 << 16)
#define	SIP_DTMF_INFO   (2 << 16)
#define	SIP_DTMF_RFC2833   (0 << 16)
#define	SIP_FLAGS_TO_COPY
#define	SIP_FREE_BIT   (1 << 14)
#define	SIP_G726_NONSTANDARD   (1 << 31)
#define	SIP_GOTREFER   (1 << 7)
#define	SIP_INC_COUNT   (1 << 30)
#define	SIP_INSECURE_INVITE   (1 << 24)
#define	SIP_INSECURE_PORT   (1 << 23)
#define	SIP_MAX_HEADERS   64
#define	SIP_MAX_LINES   64
#define	SIP_MAX_PACKET   4096
#define	SIP_NAT   (3 << 18)
#define	SIP_NAT_ALWAYS   (3 << 18)
#define	SIP_NAT_NEVER   (0 << 18)
#define	SIP_NAT_RFC3581   (1 << 18)
#define	SIP_NAT_ROUTE   (2 << 18)
#define	SIP_NEEDDESTROY   (1 << 1)
#define	SIP_NEEDREINVITE   (1 << 5)
#define	SIP_NO_HISTORY   (1 << 27)
#define	SIP_NOVIDEO   (1 << 2)
#define	SIP_OPT_100REL   (1 << 1)
#define	SIP_OPT_EARLY_SESSION   (1 << 3)
#define	SIP_OPT_EVENTLIST   (1 << 11)
#define	SIP_OPT_GRUU   (1 << 12)
#define	SIP_OPT_HISTINFO   (1 << 15)
#define	SIP_OPT_JOIN   (1 << 4)
#define	SIP_OPT_NOREFERSUB   (1 << 14)
#define	SIP_OPT_PATH   (1 << 5)
#define	SIP_OPT_PRECONDITION   (1 << 7)
#define	SIP_OPT_PREF   (1 << 6)
#define	SIP_OPT_PRIVACY   (1 << 8)
#define	SIP_OPT_REPLACES   (1 << 0)
#define	SIP_OPT_RESPRIORITY   (1 << 16)
#define	SIP_OPT_SDP_ANAT   (1 << 9)
#define	SIP_OPT_SEC_AGREE   (1 << 10)
#define	SIP_OPT_TARGET_DIALOG   (1 << 13)
#define	SIP_OPT_TIMER   (1 << 2)
#define	SIP_OUTGOING   (1 << 13)
#define	SIP_PAGE2_ALLOWOVERLAP   (1 << 17)
#define	SIP_PAGE2_ALLOWSUBSCRIBE   (1 << 16)
#define	SIP_PAGE2_BUGGY_MWI   (1 << 26)
#define	SIP_PAGE2_CALL_ONHOLD   (3 << 23)
#define	SIP_PAGE2_CALL_ONHOLD_INACTIVE   (1 << 24)
#define	SIP_PAGE2_CALL_ONHOLD_ONEDIR   (1 << 23)
#define	SIP_PAGE2_DEBUG   (3 << 11)
#define	SIP_PAGE2_DEBUG_CONFIG   (1 << 11)
#define	SIP_PAGE2_DEBUG_CONSOLE   (1 << 12)
#define	SIP_PAGE2_DYNAMIC   (1 << 13)
#define	SIP_PAGE2_FLAGS_TO_COPY
#define	SIP_PAGE2_IGNOREREGEXPIRE   (1 << 10)
#define	SIP_PAGE2_INC_RINGING   (1 << 19)
#define	SIP_PAGE2_OUTGOING_CALL   (1 << 27)
#define	SIP_PAGE2_RFC2833_COMPENSATE   (1 << 25)
#define	SIP_PAGE2_RT_FROMCONTACT   (1 << 4)
#define	SIP_PAGE2_RTAUTOCLEAR   (1 << 2)
#define	SIP_PAGE2_RTCACHEFRIENDS   (1 << 0)
#define	SIP_PAGE2_RTSAVE_SYSNAME   (1 << 5)
#define	SIP_PAGE2_RTUPDATE   (1 << 1)
#define	SIP_PAGE2_SELFDESTRUCT   (1 << 14)
#define	SIP_PAGE2_SUBSCRIBEMWIONLY   (1 << 18)
#define	SIP_PAGE2_T38SUPPORT   (7 << 20)
#define	SIP_PAGE2_T38SUPPORT_RTP   (2 << 20)
#define	SIP_PAGE2_T38SUPPORT_TCP   (4 << 20)
#define	SIP_PAGE2_T38SUPPORT_UDPTL   (1 << 20)
#define	SIP_PAGE2_VIDEOSUPPORT   (1 << 15)
#define	SIP_PENDINGBYE   (1 << 6)
#define	SIP_PKT_DEBUG   (1 << 0)
#define	SIP_PKT_IGNORE   (1 << 2)
#define	SIP_PKT_IGNORE_REQ   (1 << 4)
#define	SIP_PKT_IGNORE_RESP   (1 << 3)
#define	SIP_PKT_WITH_TOTAG   (1 << 1)
#define	SIP_PROG_INBAND   (3 << 25)
#define	SIP_PROG_INBAND_NEVER   (0 << 25)
#define	SIP_PROG_INBAND_NO   (1 << 25)
#define	SIP_PROG_INBAND_YES   (2 << 25)
#define	SIP_PROGRESS_SENT   (1 << 4)
#define	SIP_PROMISCREDIR   (1 << 8)
#define	SIP_REALTIME   (1 << 11)
#define	SIP_REINVITE   (7 << 20)
#define	SIP_REINVITE_UPDATE   (4 << 20)
#define	SIP_RINGING   (1 << 3)
#define	SIP_SENDRPID   (1 << 29)
#define	SIP_TRANS_TIMEOUT   32000
#define	SIP_TRUSTRPID   (1 << 9)
#define	SIP_USECLIENTCODE   (1 << 12)
#define	SIP_USEREQPHONE   (1 << 10)
#define	sipdebug   ast_test_flag(&global_flags[1], SIP_PAGE2_DEBUG)
#define	sipdebug_config   ast_test_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONFIG)
#define	sipdebug_console   ast_test_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE)
#define	STANDARD_SIP_PORT   5060
	Standard SIP port from RFC 3261. DO NOT CHANGE THIS.
#define	SUPPORTED   1
#define	SUPPORTED_EXTENSIONS   "replaces"
	SIP Extensions we support.
#define	T38FAX_FILL_BIT_REMOVAL   (1 << 0)
#define	T38FAX_RATE_12000   (1 << 12)
#define	T38FAX_RATE_14400   (1 << 13)
#define	T38FAX_RATE_2400   (1 << 8)
#define	T38FAX_RATE_4800   (1 << 9)
#define	T38FAX_RATE_7200   (1 << 10)
#define	T38FAX_RATE_9600   (1 << 11)
#define	T38FAX_RATE_MANAGEMENT_LOCAL_TCF   (1 << 3)
#define	T38FAX_RATE_MANAGEMENT_TRANSFERED_TCF   (0 << 3)
#define	T38FAX_TRANSCODING_JBIG   (1 << 2)
#define	T38FAX_TRANSCODING_MMR   (1 << 1)
#define	T38FAX_UDP_EC_FEC   (1 << 4)
#define	T38FAX_UDP_EC_NONE   (0 << 4)
#define	T38FAX_UDP_EC_REDUNDANCY   (2 << 4)
#define	T38FAX_VERSION   (3 << 6)
#define	T38FAX_VERSION_0   (0 << 6)
#define	T38FAX_VERSION_1   (1 << 6)
#define	TRUE   1
#define	UNLINK(element, head, prev)
#define	VIDEO_CODEC_MASK   0x1fc0000
Enumerations
enum	check_auth_result {   AUTH_SUCCESSFUL = 0, AUTH_CHALLENGE_SENT = 1, AUTH_SECRET_FAILED = -1, AUTH_USERNAME_MISMATCH = -2,   AUTH_NOT_FOUND = -3, AUTH_FAKE_AUTH = -4, AUTH_UNKNOWN_DOMAIN = -5 }
	Authentication result from check_auth* functions. More...
enum	domain_mode { SIP_DOMAIN_AUTO, SIP_DOMAIN_CONFIG }
	Modes for SIP domain handling in the PBX. More...
enum	invitestates {   INV_NONE = 0, INV_CALLING = 1, INV_PROCEEDING = 2, INV_EARLY_MEDIA = 3,   INV_COMPLETED = 4, INV_CONFIRMED = 5, INV_TERMINATED = 6, INV_CANCELLED = 7 }
	States for the INVITE transaction, not the dialog. More...
enum	parse_register_result { PARSE_REGISTER_FAILED, PARSE_REGISTER_UPDATE, PARSE_REGISTER_QUERY }
enum	referstatus {   REFER_IDLE, REFER_SENT, REFER_RECEIVED, REFER_CONFIRMED,   REFER_ACCEPTED, REFER_RINGING, REFER_200OK, REFER_FAILED,   REFER_NOAUTH }
	Parameters to know status of transfer. More...
enum	sip_auth_type { PROXY_AUTH, WWW_AUTH }
	Authentication types - proxy or www authentication. More...
enum	sip_result { AST_SUCCESS = 0, AST_FAILURE = -1 }
enum	sipmethod {   SIP_UNKNOWN, SIP_RESPONSE, SIP_REGISTER, SIP_OPTIONS,   SIP_NOTIFY, SIP_INVITE, SIP_ACK, SIP_PRACK,   SIP_BYE, SIP_REFER, SIP_SUBSCRIBE, SIP_MESSAGE,   SIP_UPDATE, SIP_INFO, SIP_CANCEL, SIP_PUBLISH,   SIP_PING }
	SIP Request methods known by Asterisk. More...
enum	sipregistrystate {   REG_STATE_UNREGISTERED = 0, REG_STATE_REGSENT, REG_STATE_AUTHSENT, REG_STATE_REGISTERED,   REG_STATE_REJECTED, REG_STATE_TIMEOUT, REG_STATE_NOAUTH, REG_STATE_FAILED }
	States for outbound registrations (with register= lines in sip.conf. More...
enum	subscriptiontype {   NONE = 0, XPIDF_XML, DIALOG_INFO_XML, CPIM_PIDF_XML,   PIDF_XML, MWI_NOTIFICATION }
enum	t38state {   T38_DISABLED = 0, T38_LOCAL_DIRECT, T38_LOCAL_REINVITE, T38_PEER_DIRECT,   T38_PEER_REINVITE, T38_ENABLED }
	T38 States for a call. More...
enum	transfermodes { TRANSFER_OPENFORALL, TRANSFER_CLOSED }
	Authorization scheme for call transfers. More...
enum	xmittype { XMIT_CRITICAL = 2, XMIT_RELIABLE = 1, XMIT_UNRELIABLE = 0 }
Functions
static const char *	__get_header (const struct sip_request *req, const char *name, int *start)
static void	__sip_ack (struct sip_pvt *p, int seqno, int resp, int sipmethod)
	Acknowledges receipt of a packet and stops retransmission.
static int	__sip_autodestruct (void *data)
	Kill a SIP dialog (called by scheduler).
static void	__sip_destroy (struct sip_pvt *p, int lockowner)
	Execute destruction of SIP dialog structure, release memory.
static int	__sip_do_register (struct sip_registry *r)
	Register with SIP proxy.
static void	__sip_pretend_ack (struct sip_pvt *p)
	Pretend to ack all packets maybe the lock on p is not strictly necessary but there might be a race.
static int	__sip_reliable_xmit (struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal, int sipmethod)
	Transmit packet with retransmits.
static int	__sip_semi_ack (struct sip_pvt *p, int seqno, int resp, int sipmethod)
	Acks receipt of packet, keep it around (used for provisional responses).
static int	__sip_show_channels (int fd, int argc, char *argv[], int subscriptions)
	SIP show channels CLI (main function).
static int	__sip_xmit (struct sip_pvt *p, char *data, int len)
	Transmit SIP message.
static int	__transmit_response (struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable)
	Base transmit response function.
static int	_sip_show_peer (int type, int fd, struct mansession *s, const struct message *m, int argc, const char *argv[])
	Show one peer in detail (main function).
static int	_sip_show_peers (int fd, int *total, struct mansession *s, const struct message *m, int argc, const char *argv[])
	_sip_show_peers: Execute sip show peers command
static int	acf_channel_read (struct ast_channel *chan, char *funcname, char *preparse, char *buf, size_t buflen)
static void	add_blank (struct sip_request *req)
	add a blank line if no body
static void	add_codec_to_sdp (const struct sip_pvt *p, int codec, int sample_rate, char **m_buf, size_t *m_size, char **a_buf, size_t *a_size, int debug, int *min_packet_size)
	Add codec offer to SDP offer/answer body in INVITE or 200 OK.
static int	add_digit (struct sip_request *req, char digit, unsigned int duration)
	Add DTMF INFO tone to sip message.
static int	add_header (struct sip_request *req, const char *var, const char *value)
	Add header to SIP message.
static int	add_header_contentLength (struct sip_request *req, int len)
	Add 'Content-Length' header to SIP message.
static int	add_line (struct sip_request *req, const char *line)
	Add content (not header) to SIP message.
static void	add_noncodec_to_sdp (const struct sip_pvt *p, int format, int sample_rate, char **m_buf, size_t *m_size, char **a_buf, size_t *a_size, int debug)
	Add RFC 2833 DTMF offer to SDP.
static struct sip_auth *	add_realm_authentication (struct sip_auth *authlist, char *configuration, int lineno)
	Add realm authentication in list.
static void	add_route (struct sip_request *req, struct sip_route *route)
	Add route header into request per learned route.
static enum sip_result	add_sdp (struct sip_request *resp, struct sip_pvt *p)
	Add Session Description Protocol message.
static 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.
static int	add_t38_sdp (struct sip_request *resp, struct sip_pvt *p)
	Add T.38 Session Description Protocol message.
static int	add_text (struct sip_request *req, const char *text)
	Add text body to SIP message.
static int	add_vidupdate (struct sip_request *req)
	add XML encoded media control with update
static void	append_date (struct sip_request *req)
	Append date to SIP message.
static void	append_history_full (struct sip_pvt *p, const char *fmt,...)
	Append to SIP dialog history with arg list.
static void static void	append_history_va (struct sip_pvt *p, const char *fmt, va_list ap)
	Append to SIP dialog history with arg list.
	AST_LIST_HEAD_NOLOCK (sip_history_head, sip_history)
static	AST_LIST_HEAD_STATIC (domain_list, domain)
	AST_MODULE_INFO (ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT,"Session Initiation Protocol (SIP)",.load=load_module,.unload=unload_module,.reload=reload,)
	AST_MUTEX_DEFINE_STATIC (sip_reload_lock)
	AST_MUTEX_DEFINE_STATIC (monlock)
	AST_MUTEX_DEFINE_STATIC (netlock)
	Protect the monitoring thread, so only one process can kill or start it, and not when it's doing something critical.
	AST_MUTEX_DEFINE_STATIC (iflock)
	Protect the SIP dialog list (of sip_pvt's).
static void	ast_quiet_chan (struct ast_channel *chan)
	Turn off generator data XXX Does this function belong in the SIP channel?
static int	ast_sip_ouraddrfor (struct in_addr *them, struct in_addr *us)
	NAT fix - decide which IP address to use for ASterisk server?
	AST_THREADSTORAGE_CUSTOM (ts_temp_pvt, temp_pvt_init, temp_pvt_cleanup)
	A per-thread temporary pvt structure.
static int	attempt_transfer (struct sip_dual *transferer, struct sip_dual *target)
	Attempt transfer of SIP call This fix for attended transfers on a local PBX.
static int	auto_congest (void *nothing)
	Scheduled congestion on a call.
static void	build_callid_pvt (struct sip_pvt *pvt)
	Build SIP Call-ID value for a non-REGISTER transaction.
static void	build_callid_registry (struct sip_registry *reg, struct in_addr ourip, const char *fromdomain)
	Build SIP Call-ID value for a REGISTER transaction.
static void	build_contact (struct sip_pvt *p)
	Build contact header - the contact header we send out.
static struct sip_peer *	build_peer (const char *name, struct ast_variable *v, struct ast_variable *alt, int realtime)
	Build peer from configuration (file or realtime static/dynamic).
static int	build_reply_digest (struct sip_pvt *p, int method, char *digest, int digest_len)
	Build reply digest.
static void	build_route (struct sip_pvt *p, struct sip_request *req, int backwards)
	Build route list from Record-Route header.
static void	build_rpid (struct sip_pvt *p)
	Build the Remote Party-ID & From using callingpres options.
static struct sip_user *	build_user (const char *name, struct ast_variable *v, int realtime)
	Initiate a SIP user structure from configuration (configuration or realtime).
static void	build_via (struct sip_pvt *p)
	Build a Via header for a request.
static int	cb_extensionstate (char *context, char *exten, int state, void *data)
	Callback for the devicestate notification (SUBSCRIBE) support subsystem.
static enum check_auth_result	check_auth (struct sip_pvt *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).
static void	check_pendings (struct sip_pvt *p)
	Check pending actions on SIP call.
static 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
static int	check_user (struct sip_pvt *p, struct sip_request *req, int sipmethod, char *uri, enum xmittype reliable, struct sockaddr_in *sin)
	Find user If we get a match, this will add a reference pointer to the user object in ASTOBJ, that needs to be unreferenced.
static enum check_auth_result	check_user_full (struct sip_pvt *p, struct sip_request *req, int sipmethod, char *uri, enum xmittype reliable, struct sockaddr_in *sin, struct sip_peer **authpeer)
	Check if matching user or peer is defined Match user on From: user name and peer on IP/port This is used on first invite (not re-invites) and subscribe requests.
static void	check_via (struct sip_pvt *p, struct sip_request *req)
	check Via: header for hostname, port and rport request/answer
static void	cleanup_stale_contexts (char *new, char *old)
	Destroy disused contexts between reloads Only used in reload_config so the code for regcontext doesn't get ugly.
static int	clear_realm_authentication (struct sip_auth *authlist)
	Clear realm authentication list (at reload).
static void	clear_sip_domains (void)
	Clear our domain list (at reload).
static char *	complete_sip_debug_peer (const char *line, const char *word, int pos, int state)
	Support routine for 'sip debug peer' CLI.
static char *	complete_sip_peer (const char *word, int state, int flags2)
	Do completion on peer name.
static char *	complete_sip_prune_realtime_peer (const char *line, const char *word, int pos, int state)
	Support routine for 'sip prune realtime peer' CLI.
static char *	complete_sip_prune_realtime_user (const char *line, const char *word, int pos, int state)
	Support routine for 'sip prune realtime user' CLI.
static char *	complete_sip_show_peer (const char *line, const char *word, int pos, int state)
	Support routine for 'sip show peer' CLI.
static char *	complete_sip_show_user (const char *line, const char *word, int pos, int state)
	Support routine for 'sip show user' CLI.
static char *	complete_sip_user (const char *word, int state, int flags2)
	Do completion on user name.
static char *	complete_sipch (const char *line, const char *word, int pos, int state)
	Support routine for 'sip show channel' CLI.
static char *	complete_sipnotify (const char *line, const char *word, int pos, int state)
	Support routine for 'sip notify' CLI.
static int	copy_all_header (struct sip_request *req, const struct sip_request *orig, const char *field)
	Copy all headers from one request to another.
static int	copy_header (struct sip_request *req, const struct sip_request *orig, const char *field)
	Copy one header field from one request to another.
static void	copy_request (struct sip_request *dst, const struct sip_request *src)
	copy SIP request (mostly used to save request for responses)
static int	copy_via_headers (struct sip_pvt *p, struct sip_request *req, const struct sip_request *orig, const char *field)
	Copy SIP VIA Headers from the request to the response.
static int	create_addr (struct sip_pvt *dialog, const char *opeer)
	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
static int	create_addr_from_peer (struct sip_pvt *dialog, struct sip_peer *peer)
	Create address structure from peer reference. return -1 on error, 0 on success.
static void	destroy_association (struct sip_peer *peer)
	Remove registration data from realtime database or AST/DB when registration expires.
static int	determine_firstline_parts (struct sip_request *req)
	Parse first line of incoming SIP request.
static void *	do_monitor (void *data)
	The SIP monitoring thread.
static int	do_proxy_auth (struct sip_pvt *p, struct sip_request *req, char *header, char *respheader, int sipmethod, int init)
	Add authentication on outbound SIP packet.
static int	do_register_auth (struct sip_pvt *p, struct sip_request *req, char *header, char *respheader)
	Authenticate for outbound registration.
static void	do_setnat (struct sip_pvt *p, int natflags)
	Set nat mode on the various data sockets.
static int	does_peer_need_mwi (struct sip_peer *peer)
	Check whether peer needs a new MWI notification check.
static const char *	domain_mode_to_text (const enum domain_mode mode)
	Print domain mode to cli.
static const char *	dtmfmode2str (int mode)
	Convert DTMF mode to printable string.
static int	expire_register (void *data)
	Expire registration of SIP peer.
static void	extract_uri (struct sip_pvt *p, struct sip_request *req)
	Check Contact: URI of SIP message.
static const char *	find_alias (const char *name, const char *_default)
	Find compressed SIP alias.
static struct sip_pvt *	find_call (struct sip_request *req, struct sockaddr_in *sin, const int intended_method)
	Connect incoming SIP message to current dialog or create new dialog structure Called by handle_request, sipsock_read.
static const char *	find_closing_quote (const char *start, const char *lim)
	Locate closing quote in a string, skipping escaped quotes. optionally with a limit on the search. start must be past the first quote.
static struct sip_peer *	find_peer (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.
static struct sip_auth *	find_realm_authentication (struct sip_auth *authlist, const char *realm)
	Find authentication for a specific realm.
static int	find_sdp (struct sip_request *req)
	Determine whether a SIP message contains an SDP in its body.
static int	find_sip_method (const char *msg)
	find_sip_method: Find SIP method from header
static struct cfsubscription_types *	find_subscription_type (enum subscriptiontype subtype)
	Find subscription type in array.
static struct sip_user *	find_user (const char *name, int realtime)
	Locate user by name Locates user by name (From: sip uri user name part) first from in-memory list (static configuration) then from realtime storage (defined in extconfig.conf).
static void	free_old_route (struct sip_route *route)
	Remove route from route list.
static 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.
static int	func_header_read (struct ast_channel *chan, char *function, char *data, char *buf, size_t len)
	Read SIP header (dialplan function).
static int	function_sipchaninfo_read (struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
	${SIPCHANINFO()} Dialplan function - reads sip channel data
static int	function_sippeer (struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
	${SIPPEER()} Dialplan function - reads peer data
static char *	generate_random_string (char *buf, size_t size)
	Generate 32 byte random string for callid's etc.
static int	get_also_info (struct sip_pvt *p, struct sip_request *oreq)
	Call transfer support (old way, deprecated by the IETF)--.
static char *	get_body (struct sip_request *req, char *name)
	Get a specific line from the message body.
static char *	get_body_by_line (const char *line, const char *name, int nameLen)
	Reads one line of SIP message body.
static char *	get_calleridname (const char *input, char *output, size_t outputsize)
	Get caller id name from SIP headers.
static int	get_destination (struct sip_pvt *p, struct sip_request *oreq)
	Find out who the call is for We use the INVITE uri to find out.
static const char *	get_header (const struct sip_request *req, const char *name)
	Get header from SIP request.
static char *	get_in_brackets (char *tmp)
	Pick out text in brackets from character string.
static int	get_msg_text (char *buf, int len, struct sip_request *req)
	Get text out of a SIP MESSAGE packet.
static int	get_rdnis (struct sip_pvt *p, struct sip_request *oreq)
	Get referring dnis.
static int	get_refer_info (struct sip_pvt *transferer, struct sip_request *outgoing_req)
	Call transfer support (the REFER method) Extracts Refer headers into pvt dialog structure.
static 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.
static const char *	get_sdp (struct sip_request *req, const char *name)
	Get a line from an SDP message body.
static const char *	get_sdp_iterate (int *start, struct sip_request *req, const char *name)
	Lookup 'name' in the SDP starting at the 'start' line. Returns the matching line, and 'start' is updated with the next line number.
static struct sip_pvt *	get_sip_pvt_byid_locked (const char *callid, const char *totag, const char *fromtag)
	Lock interface 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.
static const char *	gettag (const struct sip_request *req, const char *header, char *tagbuf, int tagbufsize)
	Get tag from packet.
static int	handle_common_options (struct ast_flags *flags, struct ast_flags *mask, struct ast_variable *v)
	Handle flag-type options common to configuration of devices - users and peers.
static int	handle_invite_replaces (struct sip_pvt *p, struct sip_request *req, int debug, int ignore, int seqno, struct sockaddr_in *sin)
	Handle the transfer part of INVITE with a replaces: header, meaning a target pickup or an attended transfer.
static int	handle_request (struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int *recount, int *nounlock)
	Handle incoming SIP requests (methods).
static int	handle_request_bye (struct sip_pvt *p, struct sip_request *req)
	Handle incoming BYE request.
static int	handle_request_cancel (struct sip_pvt *p, struct sip_request *req)
	Handle incoming CANCEL request.
static void	handle_request_info (struct sip_pvt *p, struct sip_request *req)
	Receive SIP INFO Message.
static int	handle_request_invite (struct sip_pvt *p, struct sip_request *req, int debug, int seqno, struct sockaddr_in *sin, int *recount, char *e)
	Handle incoming INVITE request.
static int	handle_request_message (struct sip_pvt *p, struct sip_request *req)
	Handle incoming MESSAGE request.
static int	handle_request_notify (struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int seqno, char *e)
	Handle incoming notifications.
static int	handle_request_options (struct sip_pvt *p, struct sip_request *req)
	Handle incoming OPTIONS request.
static int	handle_request_refer (struct sip_pvt *p, struct sip_request *req, int debug, int ignore, int seqno, int *nounlock)
static int	handle_request_register (struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, char *e)
	Handle incoming REGISTER request.
static int	handle_request_subscribe (struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int seqno, char *e)
	Handle incoming SUBSCRIBE request.
static void	handle_response (struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int ignore, int seqno)
	Handle SIP response in dialogue.
static void	handle_response_invite (struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int seqno)
	Handle SIP response to INVITE dialogue.
static void	handle_response_peerpoke (struct sip_pvt *p, int resp, struct sip_request *req)
	Handle qualification responses (OPTIONS).
static void	handle_response_refer (struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int seqno)
static int	handle_response_register (struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int ignore, int seqno)
	Handle responses on REGISTER to services.
static const char *	hangup_cause2sip (int cause)
	Convert Asterisk hangup causes to SIP codes.
static int	hangup_sip2cause (int cause)
	Convert SIP hangup causes to Asterisk hangup causes.
static int	init_req (struct sip_request *req, int sipmethod, const char *recip)
	Initialize SIP request.
static int	init_resp (struct sip_request *resp, const char *msg)
	Initialize SIP response, based on SIP request.
static void	initialize_initreq (struct sip_pvt *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.
static void	initreqprep (struct sip_request *req, struct sip_pvt *p, int sipmethod)
	Initiate new SIP request to peer/user.
static const char *	insecure2str (int port, int invite)
	Convert Insecure setting to printable string.
static void	list_route (struct sip_route *route)
	List all routes - mostly for debugging.
static int	load_module (void)
	PBX load module - initialization.
static int	local_attended_transfer (struct sip_pvt *transferer, struct sip_dual *current, struct sip_request *req, int seqno)
	Find all call legs and bridge transferee with target called from handle_request_refer.
static int	lws2sws (char *msgbuf, int len)
	Parse multiline SIP headers into one header This is enabled if pedanticsipchecking is enabled.
static void	make_our_tag (char *tagbuf, size_t len)
	Make our SIP dialog tag.
static int	manager_sip_show_peer (struct mansession *s, const struct message *m)
	Show SIP peers in the manager API.
static int	manager_sip_show_peers (struct mansession *s, const struct message *m)
	Show SIP peers in the manager API.
static 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
static char *	nat2str (int nat)
	Convert NAT setting to text string.
static void	parse_copy (struct sip_request *dst, const struct sip_request *src)
	Copy SIP request, parse it.
static void	parse_moved_contact (struct sip_pvt *p, struct sip_request *req)
	Parse 302 Moved temporalily response.
static int	parse_ok_contact (struct sip_pvt *pvt, struct sip_request *req)
	Save contact header for 200 OK on INVITE.
static enum parse_register_result	parse_register_contact (struct sip_pvt *pvt, struct sip_peer *peer, struct sip_request *req)
	Parse contact header and save registration (peer registration).
static void	parse_request (struct sip_request *req)
	Parse a SIP message.
static unsigned int	parse_sip_options (struct sip_pvt *pvt, const char *supported)
	Parse supported header in incoming packet.
static int	peer_status (struct sip_peer *peer, char *status, int statuslen)
	Report Peer status in character string.
static void	print_codec_to_cli (int fd, struct ast_codec_pref *pref)
	Print codec list from preference to CLI/manager.
static void	print_group (int fd, ast_group_t group, int crlf)
	Print call group and pickup group.
static int	process_sdp (struct sip_pvt *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 Return 0 on success, a negative value on errors. Must be called after find_sdp().
static struct sip_peer *	realtime_peer (const char *newpeername, struct sockaddr_in *sin)
	realtime_peer: Get peer from realtime storage Checks the "sippeers" realtime family from extconfig.conf
static void	realtime_update_peer (const char *peername, struct sockaddr_in *sin, const char *username, const char *fullcontact, int expirey)
	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.
static struct sip_user *	realtime_user (const char *username)
	Load user from realtime storage Loads user from "sipusers" category in realtime (extconfig.conf) Users are matched on From: user name (the domain in skipped).
static void	receive_message (struct sip_pvt *p, struct sip_request *req)
	Receive SIP MESSAGE method messages.
static char *	referstatus2str (enum referstatus rstatus)
	Convert transfer status to string.
static void	reg_source_db (struct sip_peer *peer)
	Get registration details from Asterisk DB.
static void	register_peer_exten (struct sip_peer *peer, int onoff)
	Automatically add peer extension to dial plan.
static enum check_auth_result	register_verify (struct sip_pvt *p, struct sockaddr_in *sin, struct sip_request *req, char *uri)
	Verify registration of user Registration is done in several steps, first a REGISTER without auth to get a challenge (nonce) then a second one with auth Registration requests are only matched with peers that are marked as "dynamic".
static char *	regstate2str (enum sipregistrystate regstate)
	Convert registration state status to string.
static int	reload (void)
	Part of Asterisk module interface.
static int	reload_config (enum channelreloadreason reason)
	Re-read SIP.conf config file.
static int	reply_digest (struct sip_pvt *p, struct sip_request *req, char *header, int sipmethod, char *digest, int digest_len)
	reply to authentication for outbound registrations
static int	reqprep (struct sip_request *req, struct sip_pvt *p, int sipmethod, int seqno, int newbranch)
	Initialize a SIP request message (not the initial one in a dialog).
static int	respprep (struct sip_request *resp, struct sip_pvt *p, const char *msg, const struct sip_request *req)
	Prepare SIP response packet.
static int	restart_monitor (void)
	Start the channel monitor thread.
static int	retrans_pkt (void *data)
	Retransmit SIP message if no answer (Called from scheduler).
static int	send_request (struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno)
	Send SIP Request to the other part of the dialogue.
static int	send_response (struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno)
	Transmit response on SIP request.
static int	set_address_from_contact (struct sip_pvt *pvt)
	Change the other partys IP address based on given contact.
static void	set_destination (struct sip_pvt *p, char *uri)
	Set destination from SIP URI.
static void	set_peer_defaults (struct sip_peer *peer)
	Set peer defaults before configuring specific configurations.
static int	sip_addheader (struct ast_channel *chan, void *data)
	Add a SIP header to an outbound INVITE.
static int	sip_addrcmp (char *name, struct sockaddr_in *sin)
	Support routine for find_peer.
static struct sip_pvt *	sip_alloc (ast_string_field callid, struct sockaddr_in *sin, int useglobal_nat, const int intended_method)
	Allocate SIP_PVT structure and set defaults.
static void	sip_alreadygone (struct sip_pvt *dialog)
static int	sip_answer (struct ast_channel *ast)
	sip_answer: Answer SIP call , send 200 OK on Invite Part of PBX interface
static int	sip_call (struct ast_channel *ast, char *dest, int timeout)
	Initiate SIP call from PBX used from the dial() application.
static void	sip_cancel_destroy (struct sip_pvt *p)
	Cancel destruction of SIP dialog.
static int	sip_debug_test_addr (const struct sockaddr_in *addr)
	See if we pass debug IP filter.
static int	sip_debug_test_pvt (struct sip_pvt *p)
	Test PVT for debugging output.
static void	sip_destroy (struct sip_pvt *p)
	Destroy SIP call structure.
static void	sip_destroy_peer (struct sip_peer *peer)
	Destroy peer object from memory.
static void	sip_destroy_user (struct sip_user *user)
	Remove user object from in-memory storage.
static int	sip_devicestate (void *data)
	Part of PBX channel interface.
static int	sip_do_debug (int fd, int argc, char *argv[])
	Turn on SIP debugging (CLI command).
static int	sip_do_debug_deprecated (int fd, int argc, char *argv[])
static int	sip_do_debug_ip (int fd, int argc, char *argv[])
	Enable SIP Debugging in CLI.
static int	sip_do_debug_peer (int fd, int argc, char *argv[])
	sip_do_debug_peer: Turn on SIP debugging with peer mask
static int	sip_do_history (int fd, int argc, char *argv[])
	Enable SIP History logging (CLI).
static int	sip_do_reload (enum channelreloadreason reason)
	Reload module.
static int	sip_dtmfmode (struct ast_channel *chan, void *data)
	Set the DTMFmode for an outbound SIP call (application).
static void	sip_dump_history (struct sip_pvt *dialog)
	Dump SIP history to debug log file at end of lifespan for SIP dialog.
static int	sip_fixup (struct ast_channel *oldchan, struct ast_channel *newchan)
	sip_fixup: Fix up a channel: If a channel is consumed, this is called. Basically update any ->owner links
static int	sip_get_codec (struct ast_channel *chan)
	Return SIP UA's codec (part of the RTP interface).
static 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).
static struct ast_udptl *	sip_get_udptl_peer (struct ast_channel *chan)
static 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).
static int	sip_handle_t38_reinvite (struct ast_channel *chan, struct sip_pvt *pvt, int reinvite)
	Handle T38 reinvite.
static int	sip_hangup (struct ast_channel *ast)
	sip_hangup: Hangup SIP call Part of PBX interface, called from ast_hangup
static int	sip_indicate (struct ast_channel *ast, int condition, const void *data, size_t datalen)
	Play indication to user With SIP a lot of indications is sent as messages, letting the device play the indication - busy signal, congestion etc.
static const char *	sip_nat_mode (const struct sip_pvt *p)
	Display SIP nat mode.
static struct ast_channel *	sip_new (struct sip_pvt *i, int state, const char *title)
	Initiate a call in the SIP channel called from sip_request_call (calls from the pbx ) for outbound channels and from handle_request_invite for inbound channels.
static int	sip_no_debug (int fd, int argc, char *argv[])
	Disable SIP Debugging in CLI.
static int	sip_no_debug_deprecated (int fd, int argc, char *argv[])
static int	sip_no_history (int fd, int argc, char *argv[])
	Disable SIP History logging (CLI).
static int	sip_notify (int fd, int argc, char *argv[])
	Cli command to send SIP notify to peer.
static int	sip_park (struct ast_channel *chan1, struct ast_channel *chan2, struct sip_request *req, int seqno)
	Park a call using the subsystem in res_features.c This is executed in a separate thread.
static void *	sip_park_thread (void *stuff)
	Park SIP call support function Starts in a new thread, then parks the call XXX Should we add a wait period after streaming audio and before hangup?? Sometimes the audio can't be heard before hangup.
static void	sip_peer_hold (struct sip_pvt *p, int hold)
	Change onhold state of a peer using a pvt structure.
static 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?
static int	sip_poke_noanswer (void *data)
	React to lack of answer to Qualify poke.
static int	sip_poke_peer (struct sip_peer *peer)
	Check availability of peer, also keep NAT open.
static int	sip_poke_peer_s (void *data)
	Poke peer (send qualify to check if peer is alive and well).
static int	sip_prune_realtime (int fd, int argc, char *argv[])
	Remove temporary realtime objects from memory (CLI).
static struct ast_frame *	sip_read (struct ast_channel *ast)
	Read SIP RTP from channel.
static struct sockaddr_in *	sip_real_dst (const struct sip_pvt *p)
	The real destination address for a write.
static int	sip_refer_allocate (struct sip_pvt *p)
	Allocate SIP refer structure.
static int	sip_reg_timeout (void *data)
	Registration timeout, register again.
static int	sip_register (char *value, int lineno)
	Parse register=> line in sip.conf and add to registry.
static void	sip_registry_destroy (struct sip_registry *reg)
	Destroy registry object Objects created with the register= statement in static configuration.
static int	sip_reload (int fd, int argc, char *argv[])
	Force reload of module from cli.
static struct ast_channel *	sip_request_call (const char *type, int format, void *data, int *cause)
	PBX interface function -build SIP pvt structure SIP calls initiated by the PBX arrive here.
static int	sip_reregister (void *data)
	Update registration with SIP Proxy.
static struct ast_frame *	sip_rtp_read (struct ast_channel *ast, struct sip_pvt *p, int *faxdetect)
	Read RTP from network.
static void	sip_scheddestroy (struct sip_pvt *p, int ms)
	Schedule destruction of SIP dialog.
static void	sip_send_all_registers (void)
	Send all known registrations.
static int	sip_send_mwi_to_peer (struct sip_peer *peer)
	Send message waiting indication to alert peer that they've got voicemail.
static int	sip_senddigit_begin (struct ast_channel *ast, char digit)
static int	sip_senddigit_end (struct ast_channel *ast, char digit, unsigned int duration)
	Send DTMF character on SIP channel within one call, we're able to transmit in many methods simultaneously.
static int	sip_sendtext (struct ast_channel *ast, const char *text)
	Send SIP MESSAGE text within a call Called from PBX core sendtext() application.
static 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.
static int	sip_set_udptl_peer (struct ast_channel *chan, struct ast_udptl *udptl)
static int	sip_show_channel (int fd, int argc, char *argv[])
	Show details of one active dialog.
static int	sip_show_channels (int fd, int argc, char *argv[])
	Show active SIP channels.
static int	sip_show_domains (int fd, int argc, char *argv[])
	CLI command to list local domains.
static int	sip_show_history (int fd, int argc, char *argv[])
	Show history details of one dialog.
static int	sip_show_inuse (int fd, int argc, char *argv[])
	CLI Command to show calls within limits set by call_limit.
static int	sip_show_objects (int fd, int argc, char *argv[])
	List all allocated SIP Objects (realtime or static).
static int	sip_show_peer (int fd, int argc, char *argv[])
	Show one peer in detail.
static int	sip_show_peers (int fd, int argc, char *argv[])
	CLI Show Peers command.
static int	sip_show_registry (int fd, int argc, char *argv[])
	Show SIP Registry (registrations with other SIP proxies.
static int	sip_show_settings (int fd, int argc, char *argv[])
	List global settings for the SIP channel.
static int	sip_show_subscriptions (int fd, int argc, char *argv[])
	Show active SIP subscriptions.
static int	sip_show_user (int fd, int argc, char *argv[])
	Show one user in detail.
static int	sip_show_users (int fd, int argc, char *argv[])
	CLI Command 'SIP Show Users'.
static int	sip_sipredirect (struct sip_pvt *p, const char *dest)
	Transfer call before connect with a 302 redirect.
static int	sip_transfer (struct ast_channel *ast, const char *dest)
	Transfer SIP call.
static int	sip_write (struct ast_channel *ast, struct ast_frame *frame)
	Send frame to media channel (rtp).
static int	sipsock_read (int *id, int fd, short events, void *ignore)
	Read data from SIP socket.
static void	stop_media_flows (struct sip_pvt *p)
	Immediately stop RTP, VRTP and UDPTL as applicable.
static const char *	subscription_type2str (enum subscriptiontype subtype)
	Show subscription type in string format.
static int	t38_get_rate (int t38cap)
	Get Max T.38 Transmission rate from T38 capabilities.
static struct sip_peer *	temp_peer (const char *name)
	Create temporary peer (used in autocreatepeer mode).
static void	temp_pvt_cleanup (void *)
static char *	transfermode2str (enum transfermodes mode)
	Convert transfer mode to text string.
static void	transmit_fake_auth_response (struct sip_pvt *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.
static int	transmit_info_with_digit (struct sip_pvt *p, const char digit, unsigned int duration)
	Send SIP INFO dtmf message, see Cisco documentation on cisco.com.
static int	transmit_info_with_vidupdate (struct sip_pvt *p)
	Send SIP INFO with video update request.
static int	transmit_invite (struct sip_pvt *p, int sipmethod, int sdp, int init)
	Build REFER/INVITE/OPTIONS message and transmit it.
static int	transmit_message_with_text (struct sip_pvt *p, const char *text)
	Transmit text with SIP MESSAGE method.
static int	transmit_notify_with_mwi (struct sip_pvt *p, int newmsgs, int oldmsgs, char *vmexten)
	Notify user of messages waiting in voicemail.
static int	transmit_notify_with_sipfrag (struct sip_pvt *p, int cseq, char *message, int terminate)
	Notify a transferring party of the status of transfer.
static int	transmit_refer (struct sip_pvt *p, const char *dest)
	Transmit SIP REFER message (initiated by the transfer() dialplan application.
static int	transmit_register (struct sip_registry *r, int sipmethod, const char *auth, const char *authheader)
	Transmit register to SIP proxy or UA.
static int	transmit_reinvite_with_sdp (struct sip_pvt *p)
	Transmit reinvite with SDP.
static int	transmit_reinvite_with_t38_sdp (struct sip_pvt *p)
	Transmit reinvite with T38 SDP We reinvite so that the T38 processing can take place. SIP Signalling stays with * in the path.
static int	transmit_request (struct sip_pvt *p, int sipmethod, int seqno, enum xmittype reliable, int newbranch)
	Transmit generic SIP request.
static int	transmit_request_with_auth (struct sip_pvt *p, int sipmethod, int seqno, enum xmittype reliable, int newbranch)
	Transmit SIP request, auth added.
static int	transmit_response (struct sip_pvt *p, const char *msg, const struct sip_request *req)
	Transmit response, no retransmits.
static int	transmit_response_reliable (struct sip_pvt *p, const char *msg, const 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.
static int	transmit_response_using_temp (ast_string_field callid, struct sockaddr_in *sin, int useglobal_nat, const int intended_method, const struct sip_request *req, const char *msg)
	Transmit response, no retransmits, using a temporary pvt structure.
static int	transmit_response_with_allow (struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable)
	Append Accept header, content length before transmitting response.
static int	transmit_response_with_auth (struct sip_pvt *p, const char *msg, const struct sip_request *req, const char *randdata, enum xmittype reliable, const char *header, int stale)
	Respond with authorization request.
static int	transmit_response_with_date (struct sip_pvt *p, const char *msg, const struct sip_request *req)
	Append date and content length before transmitting response.
static int	transmit_response_with_sdp (struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable)
	Used for 200 OK and 183 early media.
static int	transmit_response_with_t38_sdp (struct sip_pvt *p, char *msg, struct sip_request *req, int retrans)
	Used for 200 OK and 183 early media.
static int	transmit_response_with_unsupported (struct sip_pvt *p, const char *msg, const struct sip_request *req, const char *unsupported)
	Transmit response, no retransmits.
static int	transmit_sip_request (struct sip_pvt *p, struct sip_request *req)
	Transmit SIP request unreliably (only used in sip_notify subsystem).
static int	transmit_state_notify (struct sip_pvt *p, int state, int full, int timeout)
	Used in the SUBSCRIBE notification subsystem.
static void	try_suggested_sip_codec (struct sip_pvt *p)
	Try setting codec suggested by the SIP_CODEC channel variable.
static int	unload_module (void)
	PBX unload module API.
static int	update_call_counter (struct sip_pvt *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.
static void	update_peer (struct sip_peer *p, int expiry)
	Update peer data in database (if used).
Variables
static struct in_addr	__ourip
static int	allow_external_domains
static int	apeerobjs = 0
static char *	app_dtmfmode = "SIPDtmfMode"
static char *	app_sipaddheader = "SIPAddHeader"
static struct sip_auth *	authl = NULL
static int	autocreatepeer
static struct sockaddr_in	bindaddr = { 0, }
static struct ast_custom_function	checksipdomain_function
static struct ast_cli_entry	cli_sip []
static struct ast_cli_entry	cli_sip_debug_deprecated
static struct ast_cli_entry	cli_sip_no_debug_deprecated
static int	compactheaders
static const char	config [] = "sip.conf"
static char	debug_usage []
static struct sockaddr_in	debugaddr
static char	default_callerid [AST_MAX_EXTENSION]
static char	default_context [AST_MAX_CONTEXT]
static int	default_expiry = DEFAULT_DEFAULT_EXPIRY
static char	default_fromdomain [AST_MAX_EXTENSION]
static struct ast_jb_conf	default_jbconf
	Global jitterbuffer configuration - by default, jb is disabled.
static char	default_language [MAX_LANGUAGE]
static int	default_maxcallbitrate
static char	default_mohinterpret [MAX_MUSICCLASS]
static char	default_mohsuggest [MAX_MUSICCLASS]
static char	default_notifymime [AST_MAX_EXTENSION]
static struct ast_codec_pref	default_prefs
static int	default_qualify
static char	default_subscribecontext [AST_MAX_CONTEXT]
static char	default_vmexten [AST_MAX_EXTENSION]
static char *	descrip_dtmfmode = "SIPDtmfMode(inband|info|rfc2833): Changes the dtmfmode for a SIP call\n"
static char *	descrip_sipaddheader
static int	dumphistory
static int	expiry = DEFAULT_EXPIRY
static time_t	externexpire = 0
static char	externhost [MAXHOSTNAMELEN]
static struct sockaddr_in	externip
static int	externrefresh = 10
static int	global_allowguest
static int	global_allowsubscribe
static enum transfermodes	global_allowtransfer
static int	global_alwaysauthreject
static int	global_autoframing
static int	global_callevents
static int	global_capability = AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_GSM | AST_FORMAT_H263
	Codecs that we support by default:.
static int	global_directrtpsetup
static struct ast_flags	global_flags [2] = {{0}}
static struct ast_jb_conf	global_jbconf
static int	global_limitonpeers
static int	global_matchexterniplocally
static int	global_mwitime
static int	global_notifyhold
static int	global_notifyringing
static char	global_realm [MAXHOSTNAMELEN]
static int	global_reg_timeout
static int	global_regattempts_max
static char	global_regcontext [AST_MAX_CONTEXT]
static int	global_relaxdtmf
static int	global_rtautoclear
static int	global_rtpholdtimeout
static int	global_rtpkeepalive
static int	global_rtptimeout
static int	global_t1min
static int	global_t38_capability = T38FAX_VERSION_0 | T38FAX_RATE_2400 | T38FAX_RATE_4800 | T38FAX_RATE_7200 | T38FAX_RATE_9600
static unsigned int	global_tos_audio
static unsigned int	global_tos_sip
static unsigned int	global_tos_video
static char	global_useragent [AST_MAX_EXTENSION]
static char	history_usage []
static struct sip_pvt *	iflist
	sip_pvt: PVT structures are used for each SIP dialog, ie. a call, a registration, a subscribe
static struct io_context *	io
static struct ast_ha *	localaddr
static char	mandescr_show_peer []
static char	mandescr_show_peers []
static int	max_expiry = DEFAULT_MAX_EXPIRY
static int	min_expiry = DEFAULT_MIN_EXPIRY
static pthread_t	monitor_thread = AST_PTHREADT_NULL
	This is the thread for the monitor which checks for input on the channels which are not currently in use.
static char	no_debug_usage []
static char	no_history_usage []
static const char	notify_config [] = "sip_notify.conf"
static struct ast_config *	notify_types
static char	notify_usage []
static int	ourport
static struct sockaddr_in	outboundproxyip
static int	pedanticsipchecking
static struct ast_peer_list	peerl
	The peer list: Peers and Friends.
static char	prune_realtime_usage []
static int	recordhistory
static struct c_referstatusstring	referstatusstrings []
static struct ast_register_list	regl
	The register list: Other SIP proxys we register with and place calls to.
static int	regobjs = 0
static int	rpeerobjs = 0
static int	ruserobjs = 0
static struct sched_context *	sched
static char	show_channel_usage []
static char	show_channels_usage []
static char	show_domains_usage []
static char	show_history_usage []
static char	show_inuse_usage []
static char	show_objects_usage []
static char	show_peer_usage []
static char	show_peers_usage []
static char	show_reg_usage []
static char	show_settings_usage []
static char	show_subscriptions_usage []
static char	show_user_usage []
static char	show_users_usage []
static struct ast_custom_function	sip_header_function
static struct cfsip_methods	sip_methods []
static struct cfsip_options	sip_options []
	List of well-known SIP options. If we get this in a require, we should check the list and answer accordingly.
static char	sip_reload_usage []
static int	sip_reloading = FALSE
static enum channelreloadreason	sip_reloadreason
static struct ast_rtp_protocol	sip_rtp
	Interface structure with callbacks used to connect to RTP module.
static struct ast_channel_tech	sip_tech
	Definition of this channel for PBX channel registration.
static struct ast_channel_tech	sip_tech_info
	This version of the sip channel tech has no send_digit_begin callback. This is for use with channels using SIP INFO DTMF so that the core knows that the channel doesn't want DTMF BEGIN frames.
static struct ast_udptl_protocol	sip_udptl
	Interface structure with callbacks used to connect to UDPTL module.
static struct ast_custom_function	sipchaninfo_function
	Structure to declare a dialplan function: SIPCHANINFO.
ast_custom_function	sippeer_function
	Structure to declare a dialplan function: SIPPEER.
static int	sipsock = -1
static int *	sipsock_read_id
static int	speerobjs = 0
static int	srvlookup
static struct cfsubscription_types	subscription_types []
static int	suserobjs = 0
static char *	synopsis_dtmfmode = "Change the dtmfmode for a SIP call"
static char *	synopsis_sipaddheader = "Add a SIP header to the outbound call"
static struct ast_user_list	userl
	The user list: Users and friends.

---

Detailed Description

Implementation of Session Initiation Protocol.

Author:

Mark Spencer <markster@digium.com>

See Also:

• CREDITS

Implementation of RFC 3261 - without S/MIME, TCP and TLS support Configuration file sip.conf

Todo:

SIP over TCP

Todo:

SIP over TLS

Todo:

Better support of forking

Todo:

VIA branch tag transaction checking

Todo:

Transaction support

Overview of the handling of SIP sessions

The SIP channel handles several types of SIP sessions, or dialogs, not all of them being "telephone calls".

• Incoming calls that will be sent to the PBX core
• Outgoing calls, generated by the PBX
• SIP subscriptions and notifications of states and voicemail messages
• SIP registrations, both inbound and outbound
• SIP peer management (peerpoke, OPTIONS)
• SIP text messages

In the SIP channel, there's a list of active SIP dialogs, which includes all of these when they are active. "sip show channels" in the CLI will show most of these, excluding subscriptions which are shown by "sip show subscriptions"

incoming packets

Incoming packets are received in the monitoring thread, then handled by sipsock_read(). This function parses the packet and matches an existing dialog or starts a new SIP dialog.

sipsock_read sends the packet to handle_request(), that parses a bit more. if it's a response to an outbound request, it's sent to handle_response(). If it is a request, handle_request sends it to one of a list of functions depending on the request type - INVITE, OPTIONS, REFER, BYE, CANCEL etc sipsock_read locks the ast_channel if it exists (an active call) and unlocks it after we have processed the SIP message.

A new INVITE is sent to handle_request_invite(), that will end up starting a new channel in the PBX, the new channel after that executing in a separate channel thread. This is an incoming "call". When the call is answered, either by a bridged channel or the PBX itself the sip_answer() function is called.

The actual media - Video or Audio - is mostly handled by the RTP subsystem in rtp.c

Outbound calls

Outbound calls are set up by the PBX through the sip_request_call() function. After that, they are activated by sip_call().

Hanging up

The PBX issues a hangup on both incoming and outgoing calls through the sip_hangup() function

Deprecated stuff

This is deprecated and will be removed after the 1.4 release

• the SIPUSERAGENT dialplan variable
• the ALERT_INFO dialplan variable

Definition in file chan_sip.c.

---

Define Documentation

#define ALLOWED_METHODS   "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, SUBSCRIBE, NOTIFY"

SIP Methods we support.

Definition at line 464 of file chan_sip.c.

Referenced by respprep(), transmit_invite(), transmit_notify_with_sipfrag(), transmit_refer(), transmit_reinvite_with_sdp(), and transmit_reinvite_with_t38_sdp().

#define append_history	(	p,
		event,
		fmt,
		args...		)	append_history_full(p, "%-15s " fmt, event, ## args)

Append to SIP dialog history.

Returns:

Always returns 0

Definition at line 1810 of file chan_sip.c.

Referenced by __sip_autodestruct(), auto_congest(), build_reply_digest(), cb_extensionstate(), check_auth(), do_register_auth(), handle_invite_replaces(), handle_request(), handle_request_bye(), handle_request_invite(), handle_request_refer(), handle_request_register(), handle_request_subscribe(), local_attended_transfer(), process_sdp(), retrans_pkt(), send_request(), send_response(), sip_cancel_destroy(), sip_fixup(), sip_hangup(), sip_new(), sip_park_thread(), sip_reregister(), sip_scheddestroy(), sip_set_rtp_peer(), sipsock_read(), transmit_register(), transmit_reinvite_with_sdp(), and transmit_response_with_auth().

#define CALLERID_UNKNOWN   "Unknown"

Definition at line 192 of file chan_sip.c.

Referenced by initreqprep().

#define CAN_CREATE_DIALOG   1

Definition at line 357 of file chan_sip.c.

#define CAN_CREATE_DIALOG_UNSUPPORTED_METHOD   2

Definition at line 358 of file chan_sip.c.

#define CAN_NOT_CREATE_DIALOG   0

Definition at line 356 of file chan_sip.c.

#define DEC_CALL_LIMIT   0

Definition at line 597 of file chan_sip.c.

Referenced by __sip_destroy(), handle_request_invite(), handle_response_invite(), sip_hangup(), and update_call_counter().

#define DEC_CALL_RINGING   2

Definition at line 599 of file chan_sip.c.

Referenced by handle_response_invite(), and update_call_counter().

#define DEFAULT_ALLOW_EXT_DOM   TRUE

Definition at line 496 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_ALLOWGUEST   TRUE

Definition at line 490 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_AUTOCREATEPEER   FALSE

Definition at line 500 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_CALLERID   "asterisk"

Definition at line 487 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_COMPACTHEADERS   FALSE

Definition at line 492 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_CONTEXT   "default"

Definition at line 483 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_DEFAULT_EXPIRY   120

Definition at line 164 of file chan_sip.c.

#define DEFAULT_EXPIRY   900

Expire slowly

Definition at line 181 of file chan_sip.c.

#define DEFAULT_FREQ_NOTOK   10 * 1000

Qualification: How often to check, if the host is down...

Definition at line 196 of file chan_sip.c.

#define DEFAULT_FREQ_OK   60 * 1000

Qualification: How often to check for the host to be up

Definition at line 195 of file chan_sip.c.

#define DEFAULT_MAX_CALL_BITRATE   (384)

Max bitrate for video

Definition at line 503 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_MAX_EXPIRY   3600

Definition at line 166 of file chan_sip.c.

#define DEFAULT_MAX_FORWARDS   "70"

Definition at line 168 of file chan_sip.c.

Referenced by initreqprep(), reqprep(), transmit_refer(), and transmit_register().

#define DEFAULT_MAXMS   2000

Qualification: Must be faster than 2 seconds by default

Definition at line 194 of file chan_sip.c.

#define DEFAULT_MIN_EXPIRY   60

Definition at line 165 of file chan_sip.c.

#define DEFAULT_MOHINTERPRET   "default"

Definition at line 484 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_MOHSUGGEST   ""

Definition at line 485 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_MWITIME   10

Definition at line 489 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_NOTIFYMIME   "application/simple-message-summary"

Definition at line 488 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_NOTIFYRINGING   TRUE

Definition at line 498 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_PEDANTIC   FALSE

Definition at line 499 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_QUALIFY   FALSE

Definition at line 501 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_REALM   "asterisk"

Definition at line 497 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_REGISTRATION_TIMEOUT   20

Definition at line 167 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_RETRANS   1000

How frequently to retransmit Default: 2 * 500 ms in RFC 3261

Definition at line 198 of file chan_sip.c.

#define DEFAULT_SRVLOOKUP   FALSE

Recommended setting is ON

Definition at line 491 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_T1MIN   100

100 MS for minimal roundtrip time

Definition at line 502 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_TOS_AUDIO   0

Audio packets should be marked as DSCP EF (Expedited Forwarding), but the default is 0 to be compatible with previous versions.

Definition at line 494 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_TOS_SIP   0

Call signalling packets should be marked as DSCP CS3, but the default is 0 to be compatible with previous versions.

Definition at line 493 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_TOS_VIDEO   0

Video packets should be marked as DSCP AF41, but the default is 0 to be compatible with previous versions.

Definition at line 495 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_TRANS_TIMEOUT   -1

Definition at line 203 of file chan_sip.c.

Referenced by __sip_autodestruct(), cb_extensionstate(), check_auth(), check_pendings(), handle_invite_replaces(), handle_request(), handle_request_bye(), handle_request_cancel(), handle_request_info(), handle_request_invite(), handle_request_notify(), handle_request_options(), handle_request_register(), handle_response_invite(), handle_response_register(), receive_message(), sip_hangup(), sip_notify(), and sip_send_mwi_to_peer().

#define DEFAULT_USERAGENT   "Asterisk PBX"

Default Useragent: header unless re-defined in sip.conf

Definition at line 505 of file chan_sip.c.

Referenced by reload_config().

#define DEFAULT_VMEXTEN   "asterisk"

Definition at line 486 of file chan_sip.c.

Referenced by reload_config().

#define EXPIRY_GUARD_LIMIT   30

Below here, we use EXPIRY_GUARD_PCT instead of EXPIRY_GUARD_SECS

Definition at line 173 of file chan_sip.c.

Referenced by handle_response_register().

#define EXPIRY_GUARD_MIN   500

This is the minimum guard time applied. If GUARD_PCT turns out to be lower than this, it will use this time instead. This is in milliseconds.

Definition at line 175 of file chan_sip.c.

Referenced by handle_response_register().

#define EXPIRY_GUARD_PCT   0.20

Percentage of expires timeout to use when below EXPIRY_GUARD_LIMIT

Definition at line 179 of file chan_sip.c.

Referenced by handle_response_register().

#define EXPIRY_GUARD_SECS   15

How long before expiry do we reregister

Definition at line 172 of file chan_sip.c.

Referenced by handle_response_register().

#define FALSE   0

Definition at line 150 of file chan_sip.c.

#define FLAG_FATAL   (1 << 1)

Definition at line 1007 of file chan_sip.c.

Referenced by __sip_reliable_xmit(), and retrans_pkt().

#define FLAG_RESPONSE   (1 << 0)

Definition at line 1006 of file chan_sip.c.

Referenced by __sip_ack(), __sip_pretend_ack(), __sip_reliable_xmit(), __sip_semi_ack(), handle_request(), and retrans_pkt().

#define FORMAT   "%-15.15s %-10.10s %-11.11s %5.5d/%5.5d %-4.4s %-3.3s %-3.3s %-15.15s %-10.10s\n"

#define FORMAT   "%-30.30s %-12.12s %8d %-20.20s %-25.25s\n"

#define FORMAT   "%-40.40s %-20.20s %-16.16s\n"

#define FORMAT   "%-25.25s %-15.15s %-3.3s %-3.3s %-3.3s %-8d %-10s %-10s\n"

#define FORMAT   "%-25.25s %-15.15s %-15.15s %-15.15s %-5.5s%-10.10s\n"

#define FORMAT   "%-25.25s %-15.15s %-15.15s \n"

#define FORMAT2   "%-15.15s %-10.10s %-11.11s %-11.11s %-4.4s %-7.7s %-15.15s\n"

#define FORMAT2   "%-30.30s %-12.12s %8.8s %-20.20s %-25.25s\n"

#define FORMAT2   "%-25.25s %-15.15s %-3.3s %-3.3s %-3.3s %-8s %-10s %-10s\n"

#define FORMAT2   "%-25.25s %-15.15s %-15.15s \n"

#define FORMAT3   "%-15.15s %-10.10s %-11.11s %-15.15s %-13.13s %-15.15s %-10.10s\n"

Referenced by __sip_show_channels().

#define INC_CALL_LIMIT   1

Definition at line 598 of file chan_sip.c.

Referenced by handle_request_invite(), sip_hangup(), and update_call_counter().

#define INC_CALL_RINGING   3

Definition at line 600 of file chan_sip.c.

Referenced by sip_call(), and update_call_counter().

#define INITIAL_CSEQ   101

our initial sip sequence number

Definition at line 210 of file chan_sip.c.

Referenced by sip_alloc(), sip_register(), and transmit_response_using_temp().

#define IPTOS_MINCOST   0x02

Definition at line 159 of file chan_sip.c.

#define MAX	(	a,
		b		)	((a) > (b) ? (a) : (b))

Definition at line 189 of file chan_sip.c.

#define MAX_AUTHTRIES   3

Try authentication three times, then fail

Definition at line 204 of file chan_sip.c.

Referenced by handle_response(), handle_response_invite(), and handle_response_register().

#define MAX_RETRANS   6

Try only 6 times for retransmissions, a total of 7 transmissions

Definition at line 199 of file chan_sip.c.

#define NO_RTP   0

Definition at line 226 of file chan_sip.c.

#define NOT_SUPPORTED   0

Definition at line 397 of file chan_sip.c.

#define RTP   1

Definition at line 225 of file chan_sip.c.

#define SDP_SAMPLE_RATE

(

x

)

(x == AST_FORMAT_G722) ? 16000 : 8000

Definition at line 6134 of file chan_sip.c.

Referenced by add_sdp().

#define SIP_ALREADYGONE   (1 << 0)

Whether or not we've already been destroyed by our peer

Definition at line 704 of file chan_sip.c.

Referenced by handle_request(), handle_response_invite(), sip_alreadygone(), sip_hangup(), and sip_set_rtp_peer().

#define SIP_CALL_LIMIT   (1 << 28)

Call limit enforced for this call

Definition at line 745 of file chan_sip.c.

Referenced by check_user_full(), create_addr_from_peer(), and update_call_counter().

#define SIP_CAN_REINVITE   (1 << 20)

allow peers to be reinvited to send media directly p2p

Definition at line 733 of file chan_sip.c.

Referenced by _sip_show_peer(), handle_common_options(), reload_config(), sip_get_rtp_peer(), sip_get_udptl_peer(), sip_get_vrtp_peer(), and sip_handle_t38_reinvite().

#define SIP_CAN_REINVITE_NAT   (2 << 20)

allow media reinvite when new peer is behind NAT

Definition at line 734 of file chan_sip.c.

Referenced by handle_common_options(), sip_get_rtp_peer(), and sip_set_rtp_peer().

#define SIP_DEFER_BYE_ON_TRANSFER   (1 << 15)

Do not hangup at first ast_hangup

Definition at line 719 of file chan_sip.c.

Referenced by handle_invite_replaces(), handle_request_refer(), local_attended_transfer(), and sip_hangup().

#define SIP_DTMF   (3 << 16)

DTMF Support: four settings, uses two bits

Definition at line 720 of file chan_sip.c.

Referenced by _sip_show_peer(), check_user_full(), create_addr_from_peer(), handle_common_options(), handle_request_invite(), process_sdp(), sip_alloc(), sip_dtmfmode(), sip_new(), sip_rtp_read(), sip_senddigit_begin(), sip_senddigit_end(), sip_show_channel(), and sip_show_settings().

#define SIP_DTMF_AUTO   (3 << 16)

DTMF Support: AUTO switch between rfc2833 and in-band DTMF

Definition at line 724 of file chan_sip.c.

Referenced by check_user_full(), create_addr_from_peer(), dtmfmode2str(), handle_common_options(), process_sdp(), and sip_alloc().

#define SIP_DTMF_INBAND   (1 << 16)

DTMF Support: Inband audio, only for ULAW/ALAW - "inband"

Definition at line 722 of file chan_sip.c.

Referenced by dtmfmode2str(), handle_common_options(), process_sdp(), sip_dtmfmode(), sip_new(), sip_rtp_read(), sip_senddigit_begin(), and sip_senddigit_end().

#define SIP_DTMF_INFO   (2 << 16)

DTMF Support: SIP Info messages - "info"

Definition at line 723 of file chan_sip.c.

Referenced by dtmfmode2str(), handle_common_options(), sip_dtmfmode(), sip_new(), and sip_senddigit_end().

#define SIP_DTMF_RFC2833   (0 << 16)

DTMF Support: RTP DTMF - "rfc2833"

Definition at line 721 of file chan_sip.c.

Referenced by check_user_full(), create_addr_from_peer(), dtmfmode2str(), handle_common_options(), handle_request_invite(), process_sdp(), reload_config(), sip_alloc(), sip_dtmfmode(), sip_rtp_read(), sip_senddigit_begin(), and sip_senddigit_end().

#define SIP_FLAGS_TO_COPY

Value:

(SIP_PROMISCREDIR | SIP_TRUSTRPID | SIP_SENDRPID | SIP_DTMF | SIP_REINVITE | \
    SIP_PROG_INBAND | SIP_USECLIENTCODE | SIP_NAT | SIP_G726_NONSTANDARD | \
    SIP_USEREQPHONE | SIP_INSECURE_PORT | SIP_INSECURE_INVITE)

Definition at line 750 of file chan_sip.c.

Referenced by build_user(), check_user_full(), create_addr_from_peer(), set_peer_defaults(), sip_alloc(), and sip_poke_peer().

#define SIP_FREE_BIT   (1 << 14)

----

Definition at line 718 of file chan_sip.c.

#define SIP_G726_NONSTANDARD   (1 << 31)

Use non-standard packing for G726-32 data

Definition at line 748 of file chan_sip.c.

Referenced by add_codec_to_sdp(), handle_common_options(), and process_sdp().

#define SIP_GOTREFER   (1 << 7)

Got a refer?

Definition at line 711 of file chan_sip.c.

Referenced by handle_request_refer(), local_attended_transfer(), sip_handle_t38_reinvite(), sip_read(), sip_set_rtp_peer(), and sip_set_udptl_peer().

#define SIP_INC_COUNT   (1 << 30)

Did this connection increment the counter of in-use calls?

Definition at line 747 of file chan_sip.c.

Referenced by __sip_destroy(), sip_hangup(), and update_call_counter().

#define SIP_INSECURE_INVITE   (1 << 24)

don't require authentication for incoming INVITEs

Definition at line 738 of file chan_sip.c.

Referenced by _sip_show_peer(), check_user_full(), and handle_common_options().

#define SIP_INSECURE_PORT   (1 << 23)

don't require matching port for incoming requests

Definition at line 737 of file chan_sip.c.

Referenced by _sip_show_peer(), handle_common_options(), and sip_addrcmp().

#define SIP_MAX_HEADERS   64

Max amount of SIP headers to read

Definition at line 206 of file chan_sip.c.

Referenced by add_header(), and parse_request().

#define SIP_MAX_LINES   64

Max amount of lines in SIP attachment (like SDP)

Definition at line 207 of file chan_sip.c.

Referenced by add_line(), and parse_request().

#define SIP_MAX_PACKET   4096

Also from RFC 3261 (2543), should sub headers tho

Definition at line 208 of file chan_sip.c.

#define SIP_NAT   (3 << 18)

four settings, uses two bits

Definition at line 726 of file chan_sip.c.

Referenced by _sip_show_peer(), build_via(), copy_via_headers(), create_addr_from_peer(), handle_common_options(), register_verify(), sip_alloc(), sip_nat_mode(), sip_real_dst(), sip_show_channel(), sip_show_settings(), sip_show_users(), and transmit_response_using_temp().

#define SIP_NAT_ALWAYS   (3 << 18)

NAT Both ROUTE and RFC3581

Definition at line 730 of file chan_sip.c.

Referenced by copy_via_headers(), handle_common_options(), and nat2str().

#define SIP_NAT_NEVER   (0 << 18)

No nat support

Definition at line 727 of file chan_sip.c.

Referenced by handle_common_options(), and nat2str().

#define SIP_NAT_RFC3581   (1 << 18)

NAT RFC3581

Definition at line 728 of file chan_sip.c.

Referenced by build_via(), copy_via_headers(), handle_common_options(), nat2str(), and reload_config().

#define SIP_NAT_ROUTE   (2 << 18)

NAT Only ROUTE

Definition at line 729 of file chan_sip.c.

Referenced by _sip_show_peers(), check_user_full(), check_via(), create_addr_from_peer(), handle_common_options(), nat2str(), parse_register_contact(), send_request(), set_address_from_contact(), sip_alloc(), sip_nat_mode(), sip_real_dst(), and transmit_response_using_temp().

#define SIP_NEEDDESTROY   (1 << 1)

if we need to be destroyed by the monitor thread

Definition at line 705 of file chan_sip.c.

Referenced by __sip_show_channels(), do_monitor(), handle_request(), handle_request_refer(), handle_request_subscribe(), handle_response(), handle_response_invite(), handle_response_peerpoke(), handle_response_refer(), handle_response_register(), retrans_pkt(), sip_hangup(), sip_reg_timeout(), and sip_show_channel().

#define SIP_NEEDREINVITE   (1 << 5)

Do we need to send another reinvite?

Definition at line 709 of file chan_sip.c.

Referenced by check_pendings(), sip_handle_t38_reinvite(), sip_hangup(), sip_read(), sip_set_rtp_peer(), and sip_set_udptl_peer().

#define SIP_NO_HISTORY   (1 << 27)

Suppress recording request/response history

Definition at line 744 of file chan_sip.c.

Referenced by do_register_auth(), handle_request_bye(), handle_request_invite(), send_request(), send_response(), sip_alloc(), sip_hangup(), sip_new(), sip_reregister(), sip_scheddestroy(), sip_set_rtp_peer(), sipsock_read(), transmit_register(), transmit_reinvite_with_sdp(), and transmit_response_using_temp().

#define SIP_NOVIDEO   (1 << 2)

Didn't get video in invite, don't offer

Definition at line 706 of file chan_sip.c.

Referenced by add_sdp(), process_sdp(), and sip_indicate().

#define SIP_OPT_100REL   (1 << 1)

Definition at line 400 of file chan_sip.c.

#define SIP_OPT_EARLY_SESSION   (1 << 3)

Definition at line 402 of file chan_sip.c.

#define SIP_OPT_EVENTLIST   (1 << 11)

Definition at line 410 of file chan_sip.c.

#define SIP_OPT_GRUU   (1 << 12)

Definition at line 411 of file chan_sip.c.

#define SIP_OPT_HISTINFO   (1 << 15)

Definition at line 414 of file chan_sip.c.

#define SIP_OPT_JOIN   (1 << 4)

Definition at line 403 of file chan_sip.c.

#define SIP_OPT_NOREFERSUB   (1 << 14)

Definition at line 413 of file chan_sip.c.

#define SIP_OPT_PATH   (1 << 5)

Definition at line 404 of file chan_sip.c.

#define SIP_OPT_PRECONDITION   (1 << 7)

Definition at line 406 of file chan_sip.c.

#define SIP_OPT_PREF   (1 << 6)

Definition at line 405 of file chan_sip.c.

#define SIP_OPT_PRIVACY   (1 << 8)

Definition at line 407 of file chan_sip.c.

#define SIP_OPT_REPLACES   (1 << 0)

Definition at line 399 of file chan_sip.c.

Referenced by handle_request_invite().

#define SIP_OPT_RESPRIORITY   (1 << 16)

Definition at line 415 of file chan_sip.c.

#define SIP_OPT_SDP_ANAT   (1 << 9)

Definition at line 408 of file chan_sip.c.

#define SIP_OPT_SEC_AGREE   (1 << 10)

Definition at line 409 of file chan_sip.c.

#define SIP_OPT_TARGET_DIALOG   (1 << 13)

Definition at line 412 of file chan_sip.c.

#define SIP_OPT_TIMER   (1 << 2)

Definition at line 401 of file chan_sip.c.

#define SIP_OUTGOING   (1 << 13)

Direction of the last transaction in this dialog

Definition at line 717 of file chan_sip.c.

Referenced by get_sip_pvt_byid_locked(), handle_request_bye(), handle_request_invite(), handle_request_refer(), handle_response(), handle_response_invite(), reqprep(), respprep(), sip_call(), sip_hangup(), sip_indicate(), sip_poke_peer(), sip_send_mwi_to_peer(), sip_show_channel(), sip_write(), transmit_refer(), transmit_register(), transmit_reinvite_with_sdp(), transmit_reinvite_with_t38_sdp(), and transmit_response_with_sdp().

#define SIP_PAGE2_ALLOWOVERLAP   (1 << 17)

Allow overlap dialing ?

Definition at line 771 of file chan_sip.c.

Referenced by _sip_show_peer(), get_destination(), handle_common_options(), handle_request_invite(), reload_config(), and sip_show_settings().

#define SIP_PAGE2_ALLOWSUBSCRIBE   (1 << 16)

Allow subscriptions from this peer?

Definition at line 770 of file chan_sip.c.

Referenced by _sip_show_peer(), build_peer(), handle_common_options(), handle_request_subscribe(), reload_config(), and sip_show_settings().

#define SIP_PAGE2_BUGGY_MWI   (1 << 26)

26: Buggy CISCO MWI fix

Definition at line 782 of file chan_sip.c.

Referenced by handle_common_options(), and transmit_notify_with_mwi().

#define SIP_PAGE2_CALL_ONHOLD   (3 << 23)

Call states

Definition at line 778 of file chan_sip.c.

Referenced by __sip_show_channels(), process_sdp(), and update_call_counter().

#define SIP_PAGE2_CALL_ONHOLD_INACTIVE   (1 << 24)

24: Inactive

Definition at line 780 of file chan_sip.c.

Referenced by add_sdp(), and process_sdp().

#define SIP_PAGE2_CALL_ONHOLD_ONEDIR   (1 << 23)

23: One directional hold

Definition at line 779 of file chan_sip.c.

Referenced by add_sdp(), and process_sdp().

#define SIP_PAGE2_DEBUG   (3 << 11)

Definition at line 764 of file chan_sip.c.

#define SIP_PAGE2_DEBUG_CONFIG   (1 << 11)

Definition at line 765 of file chan_sip.c.

Referenced by reload_config().

#define SIP_PAGE2_DEBUG_CONSOLE   (1 << 12)

Definition at line 766 of file chan_sip.c.

Referenced by reload_config(), sip_do_debug(), sip_do_debug_deprecated(), sip_do_debug_ip(), sip_do_debug_peer(), sip_no_debug(), and sip_no_debug_deprecated().

#define SIP_PAGE2_DYNAMIC   (1 << 13)

Dynamic Peers register with Asterisk

Definition at line 767 of file chan_sip.c.

Referenced by _sip_show_peer(), _sip_show_peers(), build_peer(), function_sippeer(), register_verify(), and temp_peer().

#define SIP_PAGE2_FLAGS_TO_COPY

Value:

(SIP_PAGE2_ALLOWSUBSCRIBE | SIP_PAGE2_ALLOWOVERLAP | SIP_PAGE2_VIDEOSUPPORT | \
   SIP_PAGE2_T38SUPPORT | SIP_PAGE2_RFC2833_COMPENSATE | SIP_PAGE2_BUGGY_MWI)

Definition at line 785 of file chan_sip.c.

Referenced by build_user(), check_user_full(), create_addr_from_peer(), set_peer_defaults(), sip_alloc(), and sip_poke_peer().

#define SIP_PAGE2_IGNOREREGEXPIRE   (1 << 10)

Definition at line 763 of file chan_sip.c.

Referenced by build_peer(), destroy_association(), and sip_show_settings().

#define SIP_PAGE2_INC_RINGING   (1 << 19)

Did this connection increment the counter of in-use calls?

Definition at line 773 of file chan_sip.c.

Referenced by update_call_counter().

#define SIP_PAGE2_OUTGOING_CALL   (1 << 27)

27: Is this an outgoing call?

Definition at line 783 of file chan_sip.c.

Referenced by sip_request_call(), and update_call_counter().

#define SIP_PAGE2_RFC2833_COMPENSATE   (1 << 25)

25: ????

Definition at line 781 of file chan_sip.c.

Referenced by create_addr_from_peer(), handle_common_options(), handle_request_invite(), process_sdp(), sip_alloc(), and sip_show_settings().

#define SIP_PAGE2_RT_FROMCONTACT   (1 << 4)

Definition at line 760 of file chan_sip.c.

Referenced by build_peer(), destroy_association(), parse_register_contact(), and reg_source_db().

#define SIP_PAGE2_RTAUTOCLEAR   (1 << 2)

Definition at line 759 of file chan_sip.c.

Referenced by expire_register().

#define SIP_PAGE2_RTCACHEFRIENDS   (1 << 0)

Definition at line 757 of file chan_sip.c.

Referenced by complete_sip_prune_realtime_peer(), complete_sip_prune_realtime_user(), sip_prune_realtime(), sip_show_settings(), and update_peer().

#define SIP_PAGE2_RTSAVE_SYSNAME   (1 << 5)

Definition at line 761 of file chan_sip.c.

Referenced by realtime_update_peer(), and sip_show_settings().

#define SIP_PAGE2_RTUPDATE   (1 << 1)

Definition at line 758 of file chan_sip.c.

Referenced by reload_config(), sip_show_settings(), and update_peer().

#define SIP_PAGE2_SELFDESTRUCT   (1 << 14)

Automatic peers need to destruct themselves

Definition at line 768 of file chan_sip.c.

Referenced by expire_register(), sip_destroy_peer(), and temp_peer().

#define SIP_PAGE2_SUBSCRIBEMWIONLY   (1 << 18)

Only issue MWI notification if subscribed to

Definition at line 772 of file chan_sip.c.

Referenced by build_peer(), does_peer_need_mwi(), and register_verify().

#define SIP_PAGE2_T38SUPPORT   (7 << 20)

T38 Fax Passthrough Support

Definition at line 774 of file chan_sip.c.

Referenced by create_addr_from_peer(), and sip_alloc().

#define SIP_PAGE2_T38SUPPORT_RTP   (2 << 20)

21: T38 Fax Passthrough Support (not implemented)

Definition at line 776 of file chan_sip.c.

Referenced by _sip_show_peer(), add_sdp(), handle_common_options(), and sip_show_settings().

#define SIP_PAGE2_T38SUPPORT_TCP   (4 << 20)

22: T38 Fax Passthrough Support (not implemented)

Definition at line 777 of file chan_sip.c.

Referenced by _sip_show_peer(), handle_common_options(), and sip_show_settings().

#define SIP_PAGE2_T38SUPPORT_UDPTL   (1 << 20)

20: T38 Fax Passthrough Support

Definition at line 775 of file chan_sip.c.

Referenced by _sip_show_peer(), handle_common_options(), sip_read(), sip_rtp_read(), and sip_show_settings().

#define SIP_PAGE2_VIDEOSUPPORT   (1 << 15)

Definition at line 769 of file chan_sip.c.

Referenced by _sip_show_peer(), _sip_show_peers(), check_user_full(), create_addr_from_peer(), handle_common_options(), reload_config(), sip_alloc(), and sip_show_settings().

#define SIP_PENDINGBYE   (1 << 6)

Need to send bye after we ack?

Definition at line 710 of file chan_sip.c.

Referenced by check_pendings(), handle_response_invite(), sip_handle_t38_reinvite(), sip_hangup(), sip_read(), sip_set_rtp_peer(), and sip_set_udptl_peer().

#define SIP_PKT_DEBUG   (1 << 0)

Debug this packet

Definition at line 790 of file chan_sip.c.

Referenced by handle_request(), handle_request_message(), handle_request_refer(), handle_request_register(), handle_request_subscribe(), handle_response(), initialize_initreq(), and sipsock_read().

#define SIP_PKT_IGNORE   (1 << 2)

This is a re-transmit, ignore it

Definition at line 792 of file chan_sip.c.

Referenced by check_user_full(), handle_request(), handle_request_bye(), handle_request_invite(), handle_request_message(), handle_request_refer(), handle_request_subscribe(), handle_response(), handle_response_invite(), and register_verify().

#define SIP_PKT_IGNORE_REQ   (1 << 4)

Req ignore - ???

Definition at line 794 of file chan_sip.c.

Referenced by handle_request().

#define SIP_PKT_IGNORE_RESP   (1 << 3)

Resp ignore - ???

Definition at line 793 of file chan_sip.c.

Referenced by handle_request().

#define SIP_PKT_WITH_TOTAG   (1 << 1)

This packet has a to-tag

Definition at line 791 of file chan_sip.c.

Referenced by find_call(), and handle_request().

#define SIP_PROG_INBAND   (3 << 25)

three settings, uses two bits

Definition at line 740 of file chan_sip.c.

Referenced by handle_common_options(), sip_indicate(), and sip_show_settings().

#define SIP_PROG_INBAND_NEVER   (0 << 25)

Definition at line 741 of file chan_sip.c.

Referenced by sip_indicate(), and sip_show_settings().

#define SIP_PROG_INBAND_NO   (1 << 25)

Definition at line 742 of file chan_sip.c.

Referenced by handle_common_options(), and sip_show_settings().

#define SIP_PROG_INBAND_YES   (2 << 25)

Definition at line 743 of file chan_sip.c.

Referenced by handle_common_options(), and sip_indicate().

#define SIP_PROGRESS_SENT   (1 << 4)

Have sent 183 message progress

Definition at line 708 of file chan_sip.c.

Referenced by sip_indicate(), and sip_write().

#define SIP_PROMISCREDIR   (1 << 8)

Promiscuous redirection

Definition at line 712 of file chan_sip.c.

Referenced by _sip_show_peer(), handle_common_options(), parse_moved_contact(), sip_show_channel(), and sip_show_settings().

#define SIP_REALTIME   (1 << 11)

Flag for realtime users

Definition at line 715 of file chan_sip.c.

Referenced by _sip_show_peer(), _sip_show_peers(), build_peer(), parse_register_contact(), sip_destroy_peer(), sip_destroy_user(), and update_peer().

#define SIP_REINVITE   (7 << 20)

three bits used

Definition at line 732 of file chan_sip.c.

Referenced by handle_common_options().

#define SIP_REINVITE_UPDATE   (4 << 20)

use UPDATE (RFC3311) when reinviting this peer

Definition at line 735 of file chan_sip.c.

Referenced by handle_common_options(), transmit_reinvite_with_sdp(), and transmit_reinvite_with_t38_sdp().

#define SIP_RINGING   (1 << 3)

Have sent 180 ringing

Definition at line 707 of file chan_sip.c.

Referenced by sip_indicate().

#define SIP_SENDRPID   (1 << 29)

Remote Party-ID Support

Definition at line 746 of file chan_sip.c.

Referenced by _sip_show_peer(), handle_common_options(), and initreqprep().

#define SIP_TRANS_TIMEOUT   32000

SIP request timeout (rfc 3261) 64*T1

Todo:

Use known T1 for timeout (peerpoke)

Definition at line 200 of file chan_sip.c.

Referenced by sip_call().

#define SIP_TRUSTRPID   (1 << 9)

Trust RPID headers?

Definition at line 713 of file chan_sip.c.

Referenced by _sip_show_peer(), check_user_full(), and handle_common_options().

#define SIP_USECLIENTCODE   (1 << 12)

Trust X-ClientCode info message

Definition at line 716 of file chan_sip.c.

Referenced by handle_common_options(), handle_request_info(), and sip_show_settings().

#define SIP_USEREQPHONE   (1 << 10)

Add user=phone to numeric URI. Default off

Definition at line 714 of file chan_sip.c.

Referenced by _sip_show_peer(), build_peer(), initreqprep(), and sip_show_settings().

#define sipdebug   ast_test_flag(&global_flags[1], SIP_PAGE2_DEBUG)

Definition at line 822 of file chan_sip.c.

Referenced by __sip_ack(), __sip_reliable_xmit(), __sip_semi_ack(), add_sip_domain(), build_reply_digest(), check_auth(), handle_request_info(), handle_request_invite(), handle_request_notify(), handle_request_refer(), handle_request_subscribe(), handle_response(), handle_response_register(), local_attended_transfer(), parse_request(), parse_sip_options(), reqprep(), retrans_pkt(), sip_addheader(), sip_call(), sip_debug_test_addr(), sip_debug_test_pvt(), sip_dump_history(), sip_hangup(), sip_poke_peer(), sip_reregister(), transmit_invite(), transmit_refer(), transmit_register(), transmit_reinvite_with_sdp(), transmit_reinvite_with_t38_sdp(), and update_call_counter().

#define sipdebug_config   ast_test_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONFIG)

Definition at line 823 of file chan_sip.c.

#define sipdebug_console   ast_test_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE)

Definition at line 824 of file chan_sip.c.

Referenced by sip_do_debug(), and sip_do_debug_deprecated().

#define STANDARD_SIP_PORT   5060

Standard SIP port from RFC 3261. DO NOT CHANGE THIS.

Definition at line 470 of file chan_sip.c.

Referenced by build_contact(), build_peer(), check_via(), create_addr(), initreqprep(), parse_register_contact(), reload_config(), set_address_from_contact(), set_destination(), set_peer_defaults(), sip_show_registry(), and transmit_register().

#define SUPPORTED   1

Define SIP option tags, used in Require: and Supported: headers We need to be aware of these properties in the phones to use the replace: header. We should not do that without knowing that the other end supports it... This is nothing we can configure, we learn by the dialog Supported: header on the REGISTER (peer) or the INVITE (other devices) We are not using many of these today, but will in the future. This is documented in RFC 3261

Definition at line 396 of file chan_sip.c.

#define SUPPORTED_EXTENSIONS   "replaces"

SIP Extensions we support.

Definition at line 467 of file chan_sip.c.

Referenced by respprep(), transmit_invite(), transmit_notify_with_sipfrag(), transmit_refer(), transmit_reinvite_with_sdp(), and transmit_reinvite_with_t38_sdp().

#define T38FAX_FILL_BIT_REMOVAL   (1 << 0)

Default: 0 (unset)

Definition at line 797 of file chan_sip.c.

Referenced by add_t38_sdp(), and process_sdp().

#define T38FAX_RATE_12000   (1 << 12)

12000 bps t38FaxRate

Definition at line 816 of file chan_sip.c.

Referenced by process_sdp(), and t38_get_rate().

#define T38FAX_RATE_14400   (1 << 13)

14400 bps t38FaxRate This is default: NO MMR and JBIG trancoding, NO fill bit removal, transferredTCF TCF, UDP FEC, Version 0 and 9600 max fax rate

Definition at line 817 of file chan_sip.c.

Referenced by process_sdp(), and t38_get_rate().

#define T38FAX_RATE_2400   (1 << 8)

2400 bps t38FaxRate

Definition at line 812 of file chan_sip.c.

Referenced by process_sdp(), and t38_get_rate().

#define T38FAX_RATE_4800   (1 << 9)

4800 bps t38FaxRate

Definition at line 813 of file chan_sip.c.

Referenced by process_sdp(), and t38_get_rate().

#define T38FAX_RATE_7200   (1 << 10)

7200 bps t38FaxRate

Definition at line 814 of file chan_sip.c.

Referenced by process_sdp(), and t38_get_rate().

#define T38FAX_RATE_9600   (1 << 11)

9600 bps t38FaxRate

Definition at line 815 of file chan_sip.c.

Referenced by process_sdp(), and t38_get_rate().

#define T38FAX_RATE_MANAGEMENT_LOCAL_TCF   (1 << 3)

Unset for transferredTCF (UDPTL), set for localTCF (TPKT)

Definition at line 802 of file chan_sip.c.

Referenced by add_t38_sdp(), and process_sdp().

#define T38FAX_RATE_MANAGEMENT_TRANSFERED_TCF   (0 << 3)

Definition at line 801 of file chan_sip.c.

Referenced by create_addr_from_peer(), process_sdp(), and sip_alloc().

#define T38FAX_TRANSCODING_JBIG   (1 << 2)

Default: 0 (unset)

Definition at line 799 of file chan_sip.c.

Referenced by add_t38_sdp(), and process_sdp().

#define T38FAX_TRANSCODING_MMR   (1 << 1)

Default: 0 (unset)

Definition at line 798 of file chan_sip.c.

Referenced by add_t38_sdp(), and process_sdp().

#define T38FAX_UDP_EC_FEC   (1 << 4)

Set for t38UDPFEC

Definition at line 805 of file chan_sip.c.

Referenced by create_addr_from_peer(), process_sdp(), and sip_alloc().

#define T38FAX_UDP_EC_NONE   (0 << 4)

two bits, if unset NO t38UDPEC field in T38 SDP

Definition at line 804 of file chan_sip.c.

Referenced by add_t38_sdp(), create_addr_from_peer(), process_sdp(), and sip_alloc().

#define T38FAX_UDP_EC_REDUNDANCY   (2 << 4)

Set for t38UDPRedundancy

Definition at line 806 of file chan_sip.c.

Referenced by add_t38_sdp(), create_addr_from_peer(), process_sdp(), and sip_alloc().

#define T38FAX_VERSION   (3 << 6)

two bits, 2 values so far, up to 4 values max

Definition at line 808 of file chan_sip.c.

Referenced by add_t38_sdp().

#define T38FAX_VERSION_0   (0 << 6)

Version 0

Definition at line 809 of file chan_sip.c.

Referenced by add_t38_sdp(), and process_sdp().

#define T38FAX_VERSION_1   (1 << 6)

Version 1

Definition at line 810 of file chan_sip.c.

Referenced by add_t38_sdp(), and process_sdp().

#define TRUE   1

Definition at line 154 of file chan_sip.c.

#define UNLINK	(	element,
		head,
		prev		)

--- some list management macros.

Definition at line 1580 of file chan_sip.c.

Referenced by __sip_ack(), and __sip_destroy().

#define VIDEO_CODEC_MASK   0x1fc0000

Video codecs from H.261 thru AST_FORMAT_MAX_VIDEO

Definition at line 157 of file chan_sip.c.

---

Enumeration Type Documentation

enum check_auth_result

Authentication result from check_auth* functions.

Enumerator:

AUTH_SUCCESSFUL
AUTH_CHALLENGE_SENT
AUTH_SECRET_FAILED
AUTH_USERNAME_MISMATCH
AUTH_NOT_FOUND
AUTH_FAKE_AUTH
AUTH_UNKNOWN_DOMAIN

Definition at line 334 of file chan_sip.c.

                       {
   AUTH_SUCCESSFUL = 0,
   AUTH_CHALLENGE_SENT = 1,
   AUTH_SECRET_FAILED = -1,
   AUTH_USERNAME_MISMATCH = -2,
   AUTH_NOT_FOUND = -3,
   AUTH_FAKE_AUTH = -4,
   AUTH_UNKNOWN_DOMAIN = -5,
};

enum domain_mode

Modes for SIP domain handling in the PBX.

Enumerator:

SIP_DOMAIN_AUTO	This domain is auto-configured
SIP_DOMAIN_CONFIG	This domain is from configuration

Definition at line 667 of file chan_sip.c.

                 {
   SIP_DOMAIN_AUTO,     /*!< This domain is auto-configured */
   SIP_DOMAIN_CONFIG,      /*!< This domain is from configuration */
};

enum invitestates

States for the INVITE transaction, not the dialog.

Note:

this is for the INVITE that sets up the dialog

Enumerator:

INV_NONE	No state at all, maybe not an INVITE dialog
INV_CALLING	Invite sent, no answer
INV_PROCEEDING	We got/sent 1xx message
INV_EARLY_MEDIA	We got 18x message with to-tag back
INV_COMPLETED	Got final response with error. Wait for ACK, then CONFIRMED
INV_CONFIRMED	Confirmed response - we've got an ack (Incoming calls only)
INV_TERMINATED	Transaction done - either successful (AST_STATE_UP) or failed, but done The only way out of this is a BYE from one side
INV_CANCELLED	Transaction cancelled by client or server in non-terminated state

Definition at line 245 of file chan_sip.c.

                  {
   INV_NONE = 0,          /*!< No state at all, maybe not an INVITE dialog */
   INV_CALLING = 1,  /*!< Invite sent, no answer */
   INV_PROCEEDING = 2,  /*!< We got/sent 1xx message */
   INV_EARLY_MEDIA = 3,    /*!< We got 18x message with to-tag back */
   INV_COMPLETED = 4,   /*!< Got final response with error. Wait for ACK, then CONFIRMED */
   INV_CONFIRMED = 5,   /*!< Confirmed response - we've got an ack (Incoming calls only) */
   INV_TERMINATED = 6,  /*!< Transaction done - either successful (AST_STATE_UP) or failed, but done 
                    The only way out of this is a BYE from one side */
   INV_CANCELLED = 7,   /*!< Transaction cancelled by client or server in non-terminated state */
};

enum parse_register_result

Enumerator:

PARSE_REGISTER_FAILED
PARSE_REGISTER_UPDATE
PARSE_REGISTER_QUERY

Definition at line 272 of file chan_sip.c.

                           {
   PARSE_REGISTER_FAILED,
   PARSE_REGISTER_UPDATE,
   PARSE_REGISTER_QUERY,
};

enum referstatus

Parameters to know status of transfer.

Enumerator:

REFER_IDLE	No REFER is in progress
REFER_SENT	Sent REFER to transferee
REFER_RECEIVED	Received REFER from transferer
REFER_CONFIRMED	Refer confirmed with a 100 TRYING
REFER_ACCEPTED	Accepted by transferee
REFER_RINGING	Target Ringing
REFER_200OK	Answered by transfer target
REFER_FAILED	REFER declined - go on
REFER_NOAUTH	We had no auth for REFER

Definition at line 846 of file chan_sip.c.

                 {
        REFER_IDLE,                    /*!< No REFER is in progress */
        REFER_SENT,                    /*!< Sent REFER to transferee */
        REFER_RECEIVED,                /*!< Received REFER from transferer */
        REFER_CONFIRMED,               /*!< Refer confirmed with a 100 TRYING */
        REFER_ACCEPTED,                /*!< Accepted by transferee */
        REFER_RINGING,                 /*!< Target Ringing */
        REFER_200OK,                   /*!< Answered by transfer target */
        REFER_FAILED,                  /*!< REFER declined - go on */
        REFER_NOAUTH                   /*!< We had no auth for REFER */
};

enum sip_auth_type

Authentication types - proxy or www authentication.

Note:

Endpoints, like Asterisk, should always use WWW authentication to allow multiple authentications in the same call - to the proxy and to the end point.

Enumerator:

PROXY_AUTH
WWW_AUTH

Definition at line 328 of file chan_sip.c.

                   {
   PROXY_AUTH,
   WWW_AUTH,
};

enum sip_result

Enumerator:

AST_SUCCESS
AST_FAILURE

Definition at line 237 of file chan_sip.c.

                {
   AST_SUCCESS = 0,
   AST_FAILURE = -1,
};

enum sipmethod

SIP Request methods known by Asterisk.

Enumerator:

SIP_UNKNOWN
SIP_RESPONSE
SIP_REGISTER
SIP_OPTIONS
SIP_NOTIFY
SIP_INVITE
SIP_ACK
SIP_PRACK
SIP_BYE
SIP_REFER
SIP_SUBSCRIBE
SIP_MESSAGE
SIP_UPDATE
SIP_INFO
SIP_CANCEL
SIP_PUBLISH
SIP_PING

Definition at line 303 of file chan_sip.c.

               {
   SIP_UNKNOWN,      /* Unknown response */
   SIP_RESPONSE,     /* Not request, response to outbound request */
   SIP_REGISTER,
   SIP_OPTIONS,
   SIP_NOTIFY,
   SIP_INVITE,
   SIP_ACK,
   SIP_PRACK,     /* Not supported at all */
   SIP_BYE,
   SIP_REFER,
   SIP_SUBSCRIBE,
   SIP_MESSAGE,
   SIP_UPDATE,    /* We can send UPDATE; but not accept it */
   SIP_INFO,
   SIP_CANCEL,
   SIP_PUBLISH,      /* Not supported at all */
   SIP_PING,      /* Not supported at all, no standard but still implemented out there */
};

enum sipregistrystate

States for outbound registrations (with register= lines in sip.conf.

Enumerator:

REG_STATE_UNREGISTERED	We are not registred
REG_STATE_REGSENT	Registration request sent
REG_STATE_AUTHSENT	We have tried to authenticate
REG_STATE_REGISTERED	Registred and done
REG_STATE_REJECTED	Registration rejected
REG_STATE_TIMEOUT	Registration timed out
REG_STATE_NOAUTH	We have no accepted credentials
REG_STATE_FAILED	Registration failed after several tries

Definition at line 345 of file chan_sip.c.

                      {
   REG_STATE_UNREGISTERED = 0,   /*!< We are not registred */
   REG_STATE_REGSENT,   /*!< Registration request sent */
   REG_STATE_AUTHSENT,  /*!< We have tried to authenticate */
   REG_STATE_REGISTERED,   /*!< Registred and done */
   REG_STATE_REJECTED,  /*!< Registration rejected */
   REG_STATE_TIMEOUT,   /*!< Registration timed out */
   REG_STATE_NOAUTH, /*!< We have no accepted credentials */
   REG_STATE_FAILED, /*!< Registration failed after several tries */
};

enum subscriptiontype

Enumerator:

NONE
XPIDF_XML
DIALOG_INFO_XML
CPIM_PIDF_XML
PIDF_XML
MWI_NOTIFICATION

Definition at line 278 of file chan_sip.c.

                      { 
   NONE = 0,
   XPIDF_XML,
   DIALOG_INFO_XML,
   CPIM_PIDF_XML,
   PIDF_XML,
   MWI_NOTIFICATION
};

enum t38state

T38 States for a call.

Enumerator:

T38_DISABLED	Not enabled
T38_LOCAL_DIRECT	Offered from local
T38_LOCAL_REINVITE	Offered from local - REINVITE
T38_PEER_DIRECT	Offered from peer
T38_PEER_REINVITE	Offered from peer - REINVITE
T38_ENABLED	Negotiated (enabled)

Definition at line 827 of file chan_sip.c.

              {
        T38_DISABLED = 0,                /*!< Not enabled */
        T38_LOCAL_DIRECT,                /*!< Offered from local */
        T38_LOCAL_REINVITE,              /*!< Offered from local - REINVITE */
        T38_PEER_DIRECT,                 /*!< Offered from peer */
        T38_PEER_REINVITE,               /*!< Offered from peer - REINVITE */
        T38_ENABLED                      /*!< Negotiated (enabled) */
};

enum transfermodes

Authorization scheme for call transfers.

Note:

Not a bitfield flag, since there are plans for other modes, like "only allow transfers for authenticated devices"

Enumerator:

TRANSFER_OPENFORALL	Allow all SIP transfers
TRANSFER_CLOSED	Allow no SIP transfers

Definition at line 231 of file chan_sip.c.

                   {
   TRANSFER_OPENFORALL,            /*!< Allow all SIP transfers */
   TRANSFER_CLOSED,                /*!< Allow no SIP transfers */
};

enum xmittype

Enumerator:

XMIT_CRITICAL	Transmit critical SIP message reliably, with re-transmits. If it fails, it's critical and will cause a teardown of the session
XMIT_RELIABLE	Transmit SIP message reliably, with re-transmits
XMIT_UNRELIABLE	Transmit SIP message without bothering with re-transmits

Definition at line 265 of file chan_sip.c.

              {
   XMIT_CRITICAL = 2,              /*!< Transmit critical SIP message reliably, with re-transmits.
                                              If it fails, it's critical and will cause a teardown of the session */
   XMIT_RELIABLE = 1,              /*!< Transmit SIP message reliably, with re-transmits */
   XMIT_UNRELIABLE = 0,            /*!< Transmit SIP message without bothering with re-transmits */
};

---

Function Documentation

static const char * __get_header	(	const struct sip_request *	req,
		const char *	name,
		int *	start
	)			[static]

Definition at line 4006 of file chan_sip.c.

References find_alias(), sip_request::header, sip_request::headers, and len.

{
   int pass;

   /*
    * 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.
    * Anyways, pedanticsipchecking controls whether we allow spaces before ':',
    * and we always allow spaces after that for compatibility.
    */
   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 */
            if (pedanticsipchecking)
               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 "";
}

static void __sip_ack	(	struct sip_pvt *	p,
		int	seqno,
		int	resp,
		int	sipmethod
	)			[static]

Acknowledges receipt of a packet and stops retransmission.

Definition at line 2055 of file chan_sip.c.

References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_sched_del(), ast_test_flag, sip_pkt::data, FALSE, FLAG_RESPONSE, free, sip_pvt::lock, LOG_DEBUG, sip_pkt::next, option_debug, sip_pvt::packets, sip_pvt::pendinginvite, sip_pkt::retransid, sched, sip_pkt::seqno, sip_methods, sipdebug, cfsip_methods::text, TRUE, and UNLINK.

Referenced by __sip_pretend_ack(), handle_request(), and handle_response().

{
   struct sip_pkt *cur, *prev = NULL;

   /* Just in case... */
   char *msg;
   int res = FALSE;

   msg = sip_methods[sipmethod].text;

   ast_mutex_lock(&p->lock);
   for (cur = p->packets; cur; prev = cur, cur = cur->next) {
      if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
         ((ast_test_flag(cur, FLAG_RESPONSE)) || 
          (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
         if (!resp && (seqno == p->pendinginvite)) {
            if (option_debug)
               ast_log(LOG_DEBUG, "Acked pending invite %d\n", p->pendinginvite);
            p->pendinginvite = 0;
         }
         /* this is our baby */
         res = TRUE;
         UNLINK(cur, p->packets, prev);
         if (cur->retransid > -1) {
            if (sipdebug && option_debug > 3)
               ast_log(LOG_DEBUG, "** SIP TIMER: Cancelling retransmit of packet (reply received) Retransid #%d\n", cur->retransid);
            ast_sched_del(sched, cur->retransid);
            cur->retransid = -1;
         }
         free(cur);
         break;
      }
   }
   ast_mutex_unlock(&p->lock);
   if (option_debug)
      ast_log(LOG_DEBUG, "Stopping retransmission on '%s' of %s %d: Match %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
}

static int __sip_autodestruct

(

void *

data

)

[static]

Kill a SIP dialog (called by scheduler).

Definition at line 1989 of file chan_sip.c.

References append_history, AST_EXTENSION_DEACTIVATED, ast_log(), ast_queue_hangup(), ASTOBJ_UNREF, sip_pvt::autokillid, DEFAULT_TRANS_TIMEOUT, LOG_DEBUG, LOG_WARNING, sip_pvt::method, NONE, option_debug, sip_pvt::owner, sip_pvt::refer, sip_pvt::relatedpeer, SIP_BYE, sip_destroy(), sip_destroy_peer(), sip_methods, sip_scheddestroy(), sip_pvt::subscribed, cfsip_methods::text, transmit_request_with_auth(), transmit_state_notify(), TRUE, and XMIT_RELIABLE.

Referenced by sip_scheddestroy().

{
   struct sip_pvt *p = data;

   /* If this is a subscription, tell the phone that we got a timeout */
   if (p->subscribed) {
      transmit_state_notify(p, AST_EXTENSION_DEACTIVATED, 1, TRUE);  /* Send last notification */
      p->subscribed = NONE;
      append_history(p, "Subscribestatus", "timeout");
      if (option_debug > 2)
         ast_log(LOG_DEBUG, "Re-scheduled destruction of SIP subsription %s\n", p->callid ? p->callid : "<unknown>");
      return 10000;  /* Reschedule this destruction so that we know that it's gone */
   }

   /* If we're destroying a subscription, dereference peer object too */
   if (p->subscribed == MWI_NOTIFICATION && p->relatedpeer)
      ASTOBJ_UNREF(p->relatedpeer,sip_destroy_peer);

   /* Reset schedule ID */
   p->autokillid = -1;

   if (option_debug)
      ast_log(LOG_DEBUG, "Auto destroying SIP dialog '%s'\n", p->callid);
   append_history(p, "AutoDestroy", "%s", p->callid);
   if (p->owner) {
      ast_log(LOG_WARNING, "Autodestruct on dialog '%s' with owner in place (Method: %s)\n", p->callid, sip_methods[p->method].text);
      ast_queue_hangup(p->owner);
   } else if (p->refer) {
      if (option_debug > 2)
         ast_log(LOG_DEBUG, "Finally hanging up channel after transfer: %s\n", p->callid);
      transmit_request_with_auth(p, SIP_BYE, 0, XMIT_RELIABLE, 1);
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
   } else
      sip_destroy(p);
   return 0;
}

static void __sip_destroy	(	struct sip_pvt *	p,
		int	lockowner
	)			[static]

Execute destruction of SIP dialog structure, release memory.

Definition at line 2884 of file chan_sip.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, sip_pvt::flags, free, free_old_route(), iflist, LOG_DEBUG, LOG_WARNING, sip_pvt::method, sip_peer::mwipvt, sip_pvt::next, option_debug, sip_pvt::relatedpeer, sip_pkt::retransid, sched, sip_debug_test_pvt(), sip_dump_history(), SIP_INC_COUNT, sip_methods, sip_registry_destroy(), cfsip_methods::text, UNLINK, and update_call_counter().

Referenced by do_monitor(), sip_destroy(), and unload_module().

{
   struct sip_pvt *cur, *prev = NULL;
   struct sip_pkt *cp;

   if (sip_debug_test_pvt(p) || option_debug > 2)
      ast_verbose("Really destroying SIP dialog '%s' Method: %s\n", p->callid, sip_methods[p->method].text);

   if (ast_test_flag(&p->flags[0], SIP_INC_COUNT)) {
      update_call_counter(p, DEC_CALL_LIMIT);
      if (option_debug > 1)
         ast_log(LOG_DEBUG, "This call did not properly clean up call limits. Call ID %s\n", p->callid);
   }

   /* Remove link from peer to subscription of MWI */
   if (p->relatedpeer && p->relatedpeer->mwipvt)
      p->relatedpeer->mwipvt = NULL;

   if (dumphistory)
      sip_dump_history(p);

   if (p->options)
      free(p->options);

   if (p->stateid > -1)
      ast_extension_state_del(p->stateid, NULL);
   if (p->initid > -1)
      ast_sched_del(sched, p->initid);
   if (p->autokillid > -1)
      ast_sched_del(sched, p->autokillid);

   if (p->rtp)
      ast_rtp_destroy(p->rtp);
   if (p->vrtp)
      ast_rtp_destroy(p->vrtp);
   if (p->udptl)
      ast_udptl_destroy(p->udptl);
   if (p->refer)
      free(p->refer);
   if (p->route) {
      free_old_route(p->route);
      p->route = NULL;
   }
   if (p->registry) {
      if (p->registry->call == p)
         p->registry->call = NULL;
      ASTOBJ_UNREF(p->registry, sip_registry_destroy);
   }

   /* Unlink us from the owner if we have one */
   if (p->owner) {
      if (lockowner)
         ast_channel_lock(p->owner);
      if (option_debug)
         ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
      p->owner->tech_pvt = NULL;
      if (lockowner)
         ast_channel_unlock(p->owner);
   }
   /* Clear history */
   if (p->history) {
      struct sip_history *hist;
      while( (hist = AST_LIST_REMOVE_HEAD(p->history, list)) )
         free(hist);
      free(p->history);
      p->history = NULL;
   }

   for (prev = NULL, cur = iflist; cur; prev = cur, cur = cur->next) {
      if (cur == p) {
         UNLINK(cur, iflist, prev);
         break;
      }
   }
   if (!cur) {
      ast_log(LOG_WARNING, "Trying to destroy \"%s\", not found in dialog list?!?! \n", p->callid);
      return;
   } 

   /* remove all current packets in this dialog */
   while((cp = p->packets)) {
      p->packets = p->packets->next;
      if (cp->retransid > -1)
         ast_sched_del(sched, cp->retransid);
      free(cp);
   }
   if (p->chanvars) {
      ast_variables_destroy(p->chanvars);
      p->chanvars = NULL;
   }
   ast_mutex_destroy(&p->lock);

   ast_string_field_free_pools(p);

   free(p);
}

static int __sip_do_register

(

struct sip_registry *

r

)

[static]

Register with SIP proxy.

Definition at line 7166 of file chan_sip.c.

References SIP_REGISTER, and transmit_register().

Referenced by sip_reregister().

{
   int res;

   res = transmit_register(r, SIP_REGISTER, NULL, NULL);
   return res;
}

static void __sip_pretend_ack

(

struct sip_pvt *

p

)

[static]

Pretend to ack all packets maybe the lock on p is not strictly necessary but there might be a race.

Definition at line 2095 of file chan_sip.c.

References __sip_ack(), ast_log(), ast_test_flag, sip_pkt::data, find_sip_method(), FLAG_RESPONSE, LOG_WARNING, sip_pkt::method, sip_pvt::packets, sip_pkt::seqno, sip_methods, and cfsip_methods::text.

Referenced by sip_hangup(), and sip_reg_timeout().

{
   struct sip_pkt *cur = NULL;

   while (p->packets) {
      int method;
      if (cur == p->packets) {
         ast_log(LOG_WARNING, "Have a packet that doesn't want to give up! %s\n", sip_methods[cur->method].text);
         return;
      }
      cur = p->packets;
      method = (cur->method) ? cur->method : find_sip_method(cur->data);
      __sip_ack(p, cur->seqno, ast_test_flag(cur, FLAG_RESPONSE), method);
   }
}

static enum sip_result __sip_reliable_xmit	(	struct sip_pvt *	p,
		int	seqno,
		int	resp,
		char *	data,
		int	len,
		int	fatal,
		int	sipmethod
	)			[static]

Transmit packet with retransmits.

Returns:

0 on success, -1 on failure to allocate packet

Definition at line 1951 of file chan_sip.c.

References __sip_xmit(), ast_calloc, AST_FAILURE, ast_log(), ast_sched_add_variable(), ast_set_flag, AST_SUCCESS, DEFAULT_RETRANS, FLAG_FATAL, FLAG_RESPONSE, LOG_DEBUG, option_debug, sip_pkt::owner, sip_pvt::packets, sip_pvt::pendinginvite, retrans_pkt(), sched, SIP_INVITE, sipdebug, and sip_pvt::timer_t1.

Referenced by send_request(), and send_response().

{
   struct sip_pkt *pkt;
   int siptimer_a = DEFAULT_RETRANS;

   if (!(pkt = ast_calloc(1, sizeof(*pkt) + len + 1)))
      return AST_FAILURE;
   memcpy(pkt->data, data, len);
   pkt->method = sipmethod;
   pkt->packetlen = len;
   pkt->next = p->packets;
   pkt->owner = p;
   pkt->seqno = seqno;
   if (resp)
      ast_set_flag(pkt, FLAG_RESPONSE);
   pkt->data[len] = '\0';
   pkt->timer_t1 = p->timer_t1;  /* Set SIP timer T1 */
   if (fatal)
      ast_set_flag(pkt, FLAG_FATAL);
   if (pkt->timer_t1)
      siptimer_a = pkt->timer_t1 * 2;

   /* Schedule retransmission */
   pkt->retransid = ast_sched_add_variable(sched, siptimer_a, retrans_pkt, pkt, 1);
   if (option_debug > 3 && sipdebug)
      ast_log(LOG_DEBUG, "*** SIP TIMER: Initalizing retransmit timer on packet: Id  #%d\n", pkt->retransid);
   pkt->next = p->packets;
   p->packets = pkt;

   __sip_xmit(pkt->owner, pkt->data, pkt->packetlen); /* Send packet */
   if (sipmethod == SIP_INVITE) {
      /* Note this is a pending invite */
      p->pendinginvite = seqno;
   }
   return AST_SUCCESS;
}

static int __sip_semi_ack	(	struct sip_pvt *	p,
		int	seqno,
		int	resp,
		int	sipmethod
	)			[static]

Acks receipt of packet, keep it around (used for provisional responses).

Definition at line 2112 of file chan_sip.c.

References ast_log(), ast_sched_del(), ast_test_flag, sip_pkt::data, FLAG_RESPONSE, LOG_DEBUG, method_match(), sip_pkt::next, option_debug, sip_pvt::packets, sip_pkt::retransid, sched, sip_pkt::seqno, sip_methods, sipdebug, and cfsip_methods::text.

Referenced by handle_response().

{
   struct sip_pkt *cur;
   int res = -1;

   for (cur = p->packets; cur; cur = cur->next) {
      if (cur->seqno == seqno && ast_test_flag(cur, FLAG_RESPONSE) == resp &&
         (ast_test_flag(cur, FLAG_RESPONSE) || method_match(sipmethod, cur->data))) {
         /* this is our baby */
         if (cur->retransid > -1) {
            if (option_debug > 3 && sipdebug)
               ast_log(LOG_DEBUG, "*** SIP TIMER: Cancelling retransmission #%d - %s (got response)\n", cur->retransid, sip_methods[sipmethod].text);
            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", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
   return res;
}

static int __sip_show_channels	(	int	fd,
		int	argc,
		char *	argv[],
		int	subscriptions
	)			[static]

SIP show channels CLI (main function).

Definition at line 10447 of file chan_sip.c.

References ast_cli(), ast_getformatname(), ast_inet_ntoa(), ast_mutex_lock(), ast_test_flag, sip_pvt::flags, FORMAT, FORMAT2, FORMAT3, sip_pvt::icseq, iflist, sip_pvt::lastmsg, ast_channel::nativeformats, sip_pvt::next, NONE, sip_pvt::ocseq, sip_pvt::owner, sip_pvt::refer, referstatus2str(), RESULT_SHOWUSAGE, S_OR, sip_pvt::sa, SIP_NEEDDESTROY, SIP_PAGE2_CALL_ONHOLD, sip_refer::status, and sip_pvt::subscribed.

Referenced by sip_show_channels(), and sip_show_subscriptions().

{
#define FORMAT3 "%-15.15s  %-10.10s  %-11.11s  %-15.15s  %-13.13s  %-15.15s %-10.10s\n"
#define FORMAT2 "%-15.15s  %-10.10s  %-11.11s  %-11.11s  %-4.4s  %-7.7s  %-15.15s\n"
#define FORMAT  "%-15.15s  %-10.10s  %-11.11s  %5.5d/%5.5d  %-4.4s  %-3.3s %-3.3s  %-15.15s %-10.10s\n"
   struct sip_pvt *cur;
   int numchans = 0;
   char *referstatus = NULL;

   if (argc != 3)
      return RESULT_SHOWUSAGE;
   ast_mutex_lock(&iflock);
   cur = iflist;
   if (!subscriptions)
      ast_cli(fd, FORMAT2, "Peer", "User/ANR", "Call ID", "Seq (Tx/Rx)", "Format", "Hold", "Last Message");
   else 
      ast_cli(fd, FORMAT3, "Peer", "User", "Call ID", "Extension", "Last state", "Type", "Mailbox");
   for (; cur; cur = cur->next) {
      referstatus = "";
      if (cur->refer) { /* SIP transfer in progress */
         referstatus = referstatus2str(cur->refer->status);
      }
      if (cur->subscribed == NONE && !subscriptions) {
         ast_cli(fd, FORMAT, ast_inet_ntoa(cur->sa.sin_addr), 
            S_OR(cur->username, S_OR(cur->cid_num, "(None)")),
            cur->callid, 
            cur->ocseq, cur->icseq, 
            ast_getformatname(cur->owner ? cur->owner->nativeformats : 0), 
            ast_test_flag(&cur->flags[1], SIP_PAGE2_CALL_ONHOLD) ? "Yes" : "No",
            ast_test_flag(&cur->flags[0], SIP_NEEDDESTROY) ? "(d)" : "",
            cur->lastmsg ,
            referstatus
         );
         numchans++;
      }
      if (cur->subscribed != NONE && subscriptions) {
         ast_cli(fd, FORMAT3, ast_inet_ntoa(cur->sa.sin_addr),
            S_OR(cur->username, S_OR(cur->cid_num, "(None)")), 
               cur->callid,
            /* the 'complete' exten/context is hidden in the refer_to field for subscriptions */
            cur->subscribed == MWI_NOTIFICATION ? "--" : cur->subscribeuri,
            cur->subscribed == MWI_NOTIFICATION ? "<none>" : ast_extension_state2str(cur->laststate), 
            subscription_type2str(cur->subscribed),
            cur->subscribed == MWI_NOTIFICATION ? (cur->relatedpeer ? cur->relatedpeer->mailbox : "<none>") : "<none>"
);
         numchans++;
      }
   }
   ast_mutex_unlock(&iflock);
   if (!subscriptions)
      ast_cli(fd, "%d active SIP channel%s\n", numchans, (numchans != 1) ? "s" : "");
   else
      ast_cli(fd, "%d active SIP subscription%s\n", numchans, (numchans != 1) ? "s" : "");
   return RESULT_SUCCESS;
#undef FORMAT
#undef FORMAT2
#undef FORMAT3
}

static int __sip_xmit	(	struct sip_pvt *	p,
		char *	data,
		int	len
	)			[static]

Transmit SIP message.

Definition at line 1747 of file chan_sip.c.

References ast_inet_ntoa(), ast_log(), LOG_WARNING, sip_real_dst(), and sipsock.

Referenced by __sip_reliable_xmit(), retrans_pkt(), send_request(), and send_response().

{
   int res;
   const struct sockaddr_in *dst = sip_real_dst(p);
   res = sendto(sipsock, data, len, 0, (const struct sockaddr *)dst, sizeof(struct sockaddr_in));

   if (res != len)
      ast_log(LOG_WARNING, "sip_xmit of %p (len %d) to %s:%d returned %d: %s\n", data, len, ast_inet_ntoa(dst->sin_addr), ntohs(dst->sin_port), res, strerror(errno));
   return res;
}

static int __transmit_response	(	struct sip_pvt *	p,
		const char *	msg,
		const struct sip_request *	req,
		enum xmittype	reliable
	)			[static]

Base transmit response function.

Definition at line 5737 of file chan_sip.c.

References add_header(), add_header_contentLength(), ast_cause2str(), ast_log(), get_header(), ast_channel::hangupcause, LOG_WARNING, sip_pvt::method, sip_pvt::owner, respprep(), send_response(), and SIP_INVITE.

Referenced by transmit_response(), transmit_response_reliable(), and transmit_response_using_temp().

{
   struct sip_request resp;
   int seqno = 0;

   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;
   }
   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);
   }
   return send_response(p, &resp, reliable, seqno);
}

static int _sip_show_peer	(	int	type,
		int	fd,
		struct mansession *	s,
		const struct message *	m,
		int	argc,
		const char *	argv[]
	)			[static]

Show one peer in detail (main function).

Definition at line 9999 of file chan_sip.c.

References sip_peer::accountcode, sip_peer::addr, sip_peer::allowtransfer, sip_peer::amaflags, ast_callerid_merge(), ast_cdr_flags2str(), ast_check_realtime(), ast_cli(), ast_codec_pref_index(), ast_describe_caller_presentation(), ast_getformatname(), ast_getformatname_multiple(), ast_inet_ntoa(), ast_print_group(), ast_sched_when(), ast_strlen_zero(), ast_test_flag, astman_append(), astman_get_header(), astman_send_error(), ASTOBJ_UNREF, sip_peer::auth, sip_peer::autoframing, sip_peer::call_limit, sip_peer::callgroup, sip_peer::callingpres, sip_peer::capability, sip_peer::chanvars, sip_peer::cid_name, sip_peer::cid_num, sip_peer::context, sip_peer::defaddr, dtmfmode2str(), sip_peer::expire, FALSE, find_peer(), sip_peer::flags, sip_peer::fromdomain, sip_peer::fromuser, sip_peer::fullcontact, sip_peer::ha, insecure2str(), sip_peer::language, sip_peer::lastmsg, sip_peer::lastmsgssent, sip_peer::mailbox, sip_peer::maxcallbitrate, sip_auth::md5secret, sip_peer::md5secret, ast_variable::name, nat2str(), ast_variable::next, sip_auth::next, peer_status(), sip_peer::pickupgroup, sip_peer::prefs, print_codec_to_cli(), print_group(), sip_auth::realm, sip_peer::regexten, RESULT_SHOWUSAGE, RESULT_SUCCESS, s, S_OR, sched, sip_auth::secret, sip_peer::secret, SIP_CAN_REINVITE, sip_destroy_peer(), SIP_DTMF, SIP_INSECURE_INVITE, SIP_INSECURE_PORT, SIP_NAT, sip_options, SIP_PAGE2_ALLOWOVERLAP, SIP_PAGE2_ALLOWSUBSCRIBE, SIP_PAGE2_DYNAMIC, SIP_PAGE2_T38SUPPORT_RTP, SIP_PAGE2_T38SUPPORT_TCP, SIP_PAGE2_T38SUPPORT_UDPTL, SIP_PAGE2_VIDEOSUPPORT, SIP_PROMISCREDIR, SIP_REALTIME, SIP_SENDRPID, SIP_TRUSTRPID, SIP_USEREQPHONE, sip_peer::sipoptions, sip_peer::subscribecontext, text, sip_peer::tohost, transfermode2str(), TRUE, sip_peer::useragent, sip_peer::username, sip_auth::username, ast_variable::value, and sip_peer::vmexten.

Referenced by manager_sip_show_peer(), and sip_show_peer().

{
   char status[30] = "";
   char cbuf[256];
   struct sip_peer *peer;
   char codec_buf[512];
   struct ast_codec_pref *pref;
   struct ast_variable *v;
   struct sip_auth *auth;
   int x = 0, codec = 0, load_realtime;
   int realtimepeers;

   realtimepeers = ast_check_realtime("sippeers");

   if (argc < 4)
      return RESULT_SHOWUSAGE;

   load_realtime = (argc == 5 && !strcmp(argv[4], "load")) ? TRUE : FALSE;
   peer = find_peer(argv[3], NULL, load_realtime);
   if (s) {    /* Manager */
      if (peer) {
         const char *id = astman_get_header(m,"ActionID");

         astman_append(s, "Response: Success\r\n");
         if (!ast_strlen_zero(id))
            astman_append(s, "ActionID: %s\r\n",id);
      } else {
         snprintf (cbuf, sizeof(cbuf), "Peer %s not found.\n", argv[3]);
         astman_send_error(s, m, cbuf);
         return 0;
      }
   }
   if (peer && type==0 ) { /* Normal listing */
      ast_cli(fd,"\n\n");
      ast_cli(fd, "  * Name       : %s\n", peer->name);
      if (realtimepeers) { /* Realtime is enabled */
         ast_cli(fd, "  Realtime peer: %s\n", ast_test_flag(&peer->flags[0], SIP_REALTIME) ? "Yes, cached" : "No");
      }
      ast_cli(fd, "  Secret       : %s\n", ast_strlen_zero(peer->secret)?"<Not set>":"<Set>");
      ast_cli(fd, "  MD5Secret    : %s\n", ast_strlen_zero(peer->md5secret)?"<Not set>":"<Set>");
      for (auth = peer->auth; auth; auth = auth->next) {
         ast_cli(fd, "  Realm-auth   : Realm %-15.15s User %-10.20s ", auth->realm, auth->username);
         ast_cli(fd, "%s\n", !ast_strlen_zero(auth->secret)?"<Secret set>":(!ast_strlen_zero(auth->md5secret)?"<MD5secret set>" : "<Not set>"));
      }
      ast_cli(fd, "  Context      : %s\n", peer->context);
      ast_cli(fd, "  Subscr.Cont. : %s\n", S_OR(peer->subscribecontext, "<Not set>") );
      ast_cli(fd, "  Language     : %s\n", peer->language);
      if (!ast_strlen_zero(peer->accountcode))
         ast_cli(fd, "  Accountcode  : %s\n", peer->accountcode);
      ast_cli(fd, "  AMA flags    : %s\n", ast_cdr_flags2str(peer->amaflags));
      ast_cli(fd, "  Transfer mode: %s\n", transfermode2str(peer->allowtransfer));
      ast_cli(fd, "  CallingPres  : %s\n", ast_describe_caller_presentation(peer->callingpres));
      if (!ast_strlen_zero(peer->fromuser))
         ast_cli(fd, "  FromUser     : %s\n", peer->fromuser);
      if (!ast_strlen_zero(peer->fromdomain))
         ast_cli(fd, "  FromDomain   : %s\n", peer->fromdomain);
      ast_cli(fd, "  Callgroup    : ");
      print_group(fd, peer->callgroup, 0);
      ast_cli(fd, "  Pickupgroup  : ");
      print_group(fd, peer->pickupgroup, 0);
      ast_cli(fd, "  Mailbox      : %s\n", peer->mailbox);
      ast_cli(fd, "  VM Extension : %s\n", peer->vmexten);
      ast_cli(fd, "  LastMsgsSent : %d/%d\n", (peer->lastmsgssent & 0x7fff0000) >> 16, peer->lastmsgssent & 0xffff);
      ast_cli(fd, "  Call limit   : %d\n", peer->call_limit);
      ast_cli(fd, "  Dynamic      : %s\n", (ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC)?"Yes":"No"));
      ast_cli(fd, "  Callerid     : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
      ast_cli(fd, "  MaxCallBR    : %d kbps\n", peer->maxcallbitrate);
      ast_cli(fd, "  Expire       : %ld\n", ast_sched_when(sched, peer->expire));
      ast_cli(fd, "  Insecure     : %s\n", insecure2str(ast_test_flag(&peer->flags[0], SIP_INSECURE_PORT), ast_test_flag(&peer->flags[0], SIP_INSECURE_INVITE)));
      ast_cli(fd, "  Nat          : %s\n", nat2str(ast_test_flag(&peer->flags[0], SIP_NAT)));
      ast_cli(fd, "  ACL          : %s\n", (peer->ha?"Yes":"No"));
      ast_cli(fd, "  T38 pt UDPTL : %s\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_T38SUPPORT_UDPTL)?"Yes":"No");
#ifdef WHEN_WE_HAVE_T38_FOR_OTHER_TRANSPORTS
      ast_cli(fd, "  T38 pt RTP   : %s\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_T38SUPPORT_RTP)?"Yes":"No");
      ast_cli(fd, "  T38 pt TCP   : %s\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_T38SUPPORT_TCP)?"Yes":"No");
#endif
      ast_cli(fd, "  CanReinvite  : %s\n", ast_test_flag(&peer->flags[0], SIP_CAN_REINVITE)?"Yes":"No");
      ast_cli(fd, "  PromiscRedir : %s\n", ast_test_flag(&peer->flags[0], SIP_PROMISCREDIR)?"Yes":"No");
      ast_cli(fd, "  User=Phone   : %s\n", ast_test_flag(&peer->flags[0], SIP_USEREQPHONE)?"Yes":"No");
      ast_cli(fd, "  Video Support: %s\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_VIDEOSUPPORT)?"Yes":"No");
      ast_cli(fd, "  Trust RPID   : %s\n", ast_test_flag(&peer->flags[0], SIP_TRUSTRPID) ? "Yes" : "No");
      ast_cli(fd, "  Send RPID    : %s\n", ast_test_flag(&peer->flags[0], SIP_SENDRPID) ? "Yes" : "No");
      ast_cli(fd, "  Subscriptions: %s\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_ALLOWSUBSCRIBE) ? "Yes" : "No");
      ast_cli(fd, "  Overlap dial : %s\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_ALLOWOVERLAP) ? "Yes" : "No");

      /* - is enumerated */
      ast_cli(fd, "  DTMFmode     : %s\n", dtmfmode2str(ast_test_flag(&peer->flags[0], SIP_DTMF)));
      ast_cli(fd, "  LastMsg      : %d\n", peer->lastmsg);
      ast_cli(fd, "  ToHost       : %s\n", peer->tohost);
      ast_cli(fd, "  Addr->IP     : %s Port %d\n",  peer->addr.sin_addr.s_addr ? ast_inet_ntoa(peer->addr.sin_addr) : "(Unspecified)", ntohs(peer->addr.sin_port));
      ast_cli(fd, "  Defaddr->IP  : %s Port %d\n", ast_inet_ntoa(peer->defaddr.sin_addr), ntohs(peer->defaddr.sin_port));
      if (!ast_strlen_zero(global_regcontext))
         ast_cli(fd, "  Reg. exten   : %s\n", peer->regexten);
      ast_cli(fd, "  Def. Username: %s\n", peer->username);
      ast_cli(fd, "  SIP Options  : ");
      if (peer->sipoptions) {
         int lastoption = -1;
         for (x=0 ; (x < (sizeof(sip_options) / sizeof(sip_options[0]))); x++) {
            if (sip_options[x].id != lastoption) {
               if (peer->sipoptions & sip_options[x].id)
                  ast_cli(fd, "%s ", sip_options[x].text);
               lastoption = x;
            }
         }
      } else
         ast_cli(fd, "(none)");

      ast_cli(fd, "\n");
      ast_cli(fd, "  Codecs       : ");
      ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
      ast_cli(fd, "%s\n", codec_buf);
      ast_cli(fd, "  Codec Order  : (");
      print_codec_to_cli(fd, &peer->prefs);
      ast_cli(fd, ")\n");

      ast_cli(fd, "  Auto-Framing:  %s \n", peer->autoframing ? "Yes" : "No");
      ast_cli(fd, "  Status       : ");
      peer_status(peer, status, sizeof(status));
      ast_cli(fd, "%s\n",status);
      ast_cli(fd, "  Useragent    : %s\n", peer->useragent);
      ast_cli(fd, "  Reg. Contact : %s\n", peer->fullcontact);
      if (peer->chanvars) {
         ast_cli(fd, "  Variables    :\n");
         for (v = peer->chanvars ; v ; v = v->next)
            ast_cli(fd, "                 %s = %s\n", v->name, v->value);
      }
      ast_cli(fd,"\n");
      ASTOBJ_UNREF(peer,sip_destroy_peer);
   } else  if (peer && type == 1) { /* manager listing */
      char buf[256];
      astman_append(s, "Channeltype: SIP\r\n");
      astman_append(s, "ObjectName: %s\r\n", peer->name);
      astman_append(s, "ChanObjectType: peer\r\n");
      astman_append(s, "SecretExist: %s\r\n", ast_strlen_zero(peer->secret)?"N":"Y");
      astman_append(s, "MD5SecretExist: %s\r\n", ast_strlen_zero(peer->md5secret)?"N":"Y");
      astman_append(s, "Context: %s\r\n", peer->context);
      astman_append(s, "Language: %s\r\n", peer->language);
      if (!ast_strlen_zero(peer->accountcode))
         astman_append(s, "Accountcode: %s\r\n", peer->accountcode);
      astman_append(s, "AMAflags: %s\r\n", ast_cdr_flags2str(peer->amaflags));
      astman_append(s, "CID-CallingPres: %s\r\n", ast_describe_caller_presentation(peer->callingpres));
      if (!ast_strlen_zero(peer->fromuser))
         astman_append(s, "SIP-FromUser: %s\r\n", peer->fromuser);
      if (!ast_strlen_zero(peer->fromdomain))
         astman_append(s, "SIP-FromDomain: %s\r\n", peer->fromdomain);
      astman_append(s, "Callgroup: ");
      astman_append(s, "%s\r\n", ast_print_group(buf, sizeof(buf), peer->callgroup));
      astman_append(s, "Pickupgroup: ");
      astman_append(s, "%s\r\n", ast_print_group(buf, sizeof(buf), peer->pickupgroup));
      astman_append(s, "VoiceMailbox: %s\r\n", peer->mailbox);
      astman_append(s, "TransferMode: %s\r\n", transfermode2str(peer->allowtransfer));
      astman_append(s, "LastMsgsSent: %d\r\n", peer->lastmsgssent);
      astman_append(s, "Call-limit: %d\r\n", peer->call_limit);
      astman_append(s, "MaxCallBR: %d kbps\r\n", peer->maxcallbitrate);
      astman_append(s, "Dynamic: %s\r\n", (ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC)?"Y":"N"));
      astman_append(s, "Callerid: %s\r\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, ""));
      astman_append(s, "RegExpire: %ld seconds\r\n", ast_sched_when(sched,peer->expire));
      astman_append(s, "SIP-AuthInsecure: %s\r\n", insecure2str(ast_test_flag(&peer->flags[0], SIP_INSECURE_PORT), ast_test_flag(&peer->flags[0], SIP_INSECURE_INVITE)));
      astman_append(s, "SIP-NatSupport: %s\r\n", nat2str(ast_test_flag(&peer->flags[0], SIP_NAT)));
      astman_append(s, "ACL: %s\r\n", (peer->ha?"Y":"N"));
      astman_append(s, "SIP-CanReinvite: %s\r\n", (ast_test_flag(&peer->flags[0], SIP_CAN_REINVITE)?"Y":"N"));
      astman_append(s, "SIP-PromiscRedir: %s\r\n", (ast_test_flag(&peer->flags[0], SIP_PROMISCREDIR)?"Y":"N"));
      astman_append(s, "SIP-UserPhone: %s\r\n", (ast_test_flag(&peer->flags[0], SIP_USEREQPHONE)?"Y":"N"));
      astman_append(s, "SIP-VideoSupport: %s\r\n", (ast_test_flag(&peer->flags[1], SIP_PAGE2_VIDEOSUPPORT)?"Y":"N"));

      /* - is enumerated */
      astman_append(s, "SIP-DTMFmode: %s\r\n", dtmfmode2str(ast_test_flag(&peer->flags[0], SIP_DTMF)));
      astman_append(s, "SIPLastMsg: %d\r\n", peer->lastmsg);
      astman_append(s, "ToHost: %s\r\n", peer->tohost);
      astman_append(s, "Address-IP: %s\r\nAddress-Port: %d\r\n",  peer->addr.sin_addr.s_addr ? ast_inet_ntoa(peer->addr.sin_addr) : "", ntohs(peer->addr.sin_port));
      astman_append(s, "Default-addr-IP: %s\r\nDefault-addr-port: %d\r\n", ast_inet_ntoa(peer->defaddr.sin_addr), ntohs(peer->defaddr.sin_port));
      astman_append(s, "Default-Username: %s\r\n", peer->username);
      if (!ast_strlen_zero(global_regcontext))
         astman_append(s, "RegExtension: %s\r\n", peer->regexten);
      astman_append(s, "Codecs: ");
      ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
      astman_append(s, "%s\r\n", codec_buf);
      astman_append(s, "CodecOrder: ");
      pref = &peer->prefs;
      for(x = 0; x < 32 ; x++) {
         codec = ast_codec_pref_index(pref,x);
         if (!codec)
            break;
         astman_append(s, "%s", ast_getformatname(codec));
         if (x < 31 && ast_codec_pref_index(pref,x+1))
            astman_append(s, ",");
      }

      astman_append(s, "\r\n");
      astman_append(s, "Status: ");
      peer_status(peer, status, sizeof(status));
      astman_append(s, "%s\r\n", status);
      astman_append(s, "SIP-Useragent: %s\r\n", peer->useragent);
      astman_append(s, "Reg-Contact : %s\r\n", peer->fullcontact);
      if (peer->chanvars) {
         for (v = peer->chanvars ; v ; v = v->next) {
            astman_append(s, "ChanVariable:\n");
            astman_append(s, " %s,%s\r\n", v->name, v->value);
         }
      }

      ASTOBJ_UNREF(peer,sip_destroy_peer);

   } else {
      ast_cli(fd,"Peer %s not found.\n", argv[3]);
      ast_cli(fd,"\n");
   }

   return RESULT_SUCCESS;
}

static int _sip_show_peers	(	int	fd,
		int *	total,
		struct mansession *	s,
		const struct message *	m,
		int	argc,
		const char *	argv[]
	)			[static]

_sip_show_peers: Execute sip show peers command

Definition at line 9549 of file chan_sip.c.

References ast_check_realtime(), ast_cli(), ast_inet_ntoa(), ast_strlen_zero(), ast_test_flag, astman_append(), astman_get_header(), ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_RDLOCK, ASTOBJ_UNLOCK, FALSE, FORMAT, FORMAT2, id, name, peer_status(), peerl, RESULT_SHOWUSAGE, RESULT_SUCCESS, s, SIP_NAT_ROUTE, SIP_PAGE2_DYNAMIC, SIP_PAGE2_VIDEOSUPPORT, SIP_REALTIME, and TRUE.

Referenced by manager_sip_show_peers(), and sip_show_peers().

{
   regex_t regexbuf;
   int havepattern = FALSE;

#define FORMAT2 "%-25.25s  %-15.15s %-3.3s %-3.3s %-3.3s %-8s %-10s %-10s\n"
#define FORMAT  "%-25.25s  %-15.15s %-3.3s %-3.3s %-3.3s %-8d %-10s %-10s\n"

   char name[256];
   int total_peers = 0;
   int peers_mon_online = 0;
   int peers_mon_offline = 0;
   int peers_unmon_offline = 0;
   int peers_unmon_online = 0;
   const char *id;
   char idtext[256] = "";
   int realtimepeers;

   realtimepeers = ast_check_realtime("sippeers");

   if (s) { /* Manager - get ActionID */
      id = astman_get_header(m,"ActionID");
      if (!ast_strlen_zero(id))
         snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
   }

   switch (argc) {
   case 5:
      if (!strcasecmp(argv[3], "like")) {
         if (regcomp(&regexbuf, argv[4], REG_EXTENDED | REG_NOSUB))
            return RESULT_SHOWUSAGE;
         havepattern = TRUE;
      } else
         return RESULT_SHOWUSAGE;
   case 3:
      break;
   default:
      return RESULT_SHOWUSAGE;
   }

   if (!s) /* Normal list */
      ast_cli(fd, FORMAT2, "Name/username", "Host", "Dyn", "Nat", "ACL", "Port", "Status", (realtimepeers ? "Realtime" : ""));
   
   ASTOBJ_CONTAINER_TRAVERSE(&peerl, 1, do {
      char status[20] = "";
      char srch[2000];
      char pstatus;
      
      ASTOBJ_RDLOCK(iterator);

      if (havepattern && regexec(&regexbuf, iterator->name, 0, NULL, 0)) {
         ASTOBJ_UNLOCK(iterator);
         continue;
      }

      if (!ast_strlen_zero(iterator->username) && !s)
         snprintf(name, sizeof(name), "%s/%s", iterator->name, iterator->username);
      else
         ast_copy_string(name, iterator->name, sizeof(name));
      
      pstatus = peer_status(iterator, status, sizeof(status));
      if (pstatus == 1)
         peers_mon_online++;
      else if (pstatus == 0)
         peers_mon_offline++;
      else {
         if (iterator->addr.sin_port == 0)
            peers_unmon_offline++;
         else
            peers_unmon_online++;
      }

      snprintf(srch, sizeof(srch), FORMAT, name,
         iterator->addr.sin_addr.s_addr ? ast_inet_ntoa(iterator->addr.sin_addr) : "(Unspecified)",
         ast_test_flag(&iterator->flags[1], SIP_PAGE2_DYNAMIC) ? " D " : "   ",  /* Dynamic or not? */
         ast_test_flag(&iterator->flags[0], SIP_NAT_ROUTE) ? " N " : "   ",   /* NAT=yes? */
         iterator->ha ? " A " : "   ",    /* permit/deny */
         ntohs(iterator->addr.sin_port), status,
         realtimepeers ? (ast_test_flag(&iterator->flags[0], SIP_REALTIME) ? "Cached RT":"") : "");

      if (!s)  {/* Normal CLI list */
         ast_cli(fd, FORMAT, name, 
         iterator->addr.sin_addr.s_addr ? ast_inet_ntoa(iterator->addr.sin_addr) : "(Unspecified)",
         ast_test_flag(&iterator->flags[1], SIP_PAGE2_DYNAMIC) ? " D " : "   ",  /* Dynamic or not? */
         ast_test_flag(&iterator->flags[0], SIP_NAT_ROUTE) ? " N " : "   ",   /* NAT=yes? */
         iterator->ha ? " A " : "   ",       /* permit/deny */
         
         ntohs(iterator->addr.sin_port), status,
         realtimepeers ? (ast_test_flag(&iterator->flags[0], SIP_REALTIME) ? "Cached RT":"") : "");
      } else { /* Manager format */
         /* The names here need to be the same as other channels */
         astman_append(s, 
         "Event: PeerEntry\r\n%s"
         "Channeltype: SIP\r\n"
         "ObjectName: %s\r\n"
         "ChanObjectType: peer\r\n" /* "peer" or "user" */
         "IPaddress: %s\r\n"
         "IPport: %d\r\n"
         "Dynamic: %s\r\n"
         "Natsupport: %s\r\n"
         "VideoSupport: %s\r\n"
         "ACL: %s\r\n"
         "Status: %s\r\n"
         "RealtimeDevice: %s\r\n\r\n", 
         idtext,
         iterator->name, 
         iterator->addr.sin_addr.s_addr ? ast_inet_ntoa(iterator->addr.sin_addr) : "-none-",
         ntohs(iterator->addr.sin_port), 
         ast_test_flag(&iterator->flags[1], SIP_PAGE2_DYNAMIC) ? "yes" : "no",   /* Dynamic or not? */
         ast_test_flag(&iterator->flags[0], SIP_NAT_ROUTE) ? "yes" : "no", /* NAT=yes? */
         ast_test_flag(&iterator->flags[1], SIP_PAGE2_VIDEOSUPPORT) ? "yes" : "no", /* VIDEOSUPPORT=yes? */
         iterator->ha ? "yes" : "no",       /* permit/deny */
         status,
         realtimepeers ? (ast_test_flag(&iterator->flags[0], SIP_REALTIME) ? "yes":"no") : "no");
      }

      ASTOBJ_UNLOCK(iterator);

      total_peers++;
   } while(0) );
   
   if (!s)
      ast_cli(fd, "%d sip peers [Monitored: %d online, %d offline Unmonitored: %d online, %d offline]\n",
              total_peers, peers_mon_online, peers_mon_offline, peers_unmon_online, peers_unmon_offline);

   if (havepattern)
      regfree(&regexbuf);

   if (total)
      *total = total_peers;
   

   return RESULT_SUCCESS;
#undef FORMAT
#undef FORMAT2
}

static int acf_channel_read	(	struct ast_channel *	chan,
		char *	funcname,
		char *	preparse,
		char *	buf,
		size_t	buflen
	)			[static]

Definition at line 14159 of file chan_sip.c.

References AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_log(), ast_rtp_get_quality(), AST_STANDARD_APP_ARGS, ast_strdupa, LOG_ERROR, LOG_WARNING, parse(), sip_pvt::rtp, sip_tech, sip_tech_info, ast_channel::tech, ast_channel::tech_pvt, type, and sip_pvt::vrtp.

{
   struct ast_rtp_quality qos;
   struct sip_pvt *p = chan->tech_pvt;
   char *all = "", *parse = ast_strdupa(preparse);
   AST_DECLARE_APP_ARGS(args,
      AST_APP_ARG(param);
      AST_APP_ARG(type);
      AST_APP_ARG(field);
   );
   AST_STANDARD_APP_ARGS(args, parse);

   /* Sanity check */
   if (chan->tech != &sip_tech && chan->tech != &sip_tech_info) {
      ast_log(LOG_ERROR, "Cannot call %s on a non-SIP channel\n", funcname);
      return 0;
   }

   if (strcasecmp(args.param, "rtpqos"))
      return 0;

   memset(buf, 0, buflen);
   memset(&qos, 0, sizeof(qos));

   if (strcasecmp(args.type, "AUDIO") == 0) {
      all = ast_rtp_get_quality(p->rtp, &qos);
   } else if (strcasecmp(args.type, "VIDEO") == 0) {
      all = ast_rtp_get_quality(p->vrtp, &qos);
   }

   if (strcasecmp(args.field, "local_ssrc") == 0)
      snprintf(buf, buflen, "%u", qos.local_ssrc);
   else if (strcasecmp(args.field, "local_lostpackets") == 0)
      snprintf(buf, buflen, "%u", qos.local_lostpackets);
   else if (strcasecmp(args.field, "local_jitter") == 0)
      snprintf(buf, buflen, "%.0lf", qos.local_jitter * 1000.0);
   else if (strcasecmp(args.field, "local_count") == 0)
      snprintf(buf, buflen, "%u", qos.local_count);
   else if (strcasecmp(args.field, "remote_ssrc") == 0)
      snprintf(buf, buflen, "%u", qos.remote_ssrc);
   else if (strcasecmp(args.field, "remote_lostpackets") == 0)
      snprintf(buf, buflen, "%u", qos.remote_lostpackets);
   else if (strcasecmp(args.field, "remote_jitter") == 0)
      snprintf(buf, buflen, "%.0lf", qos.remote_jitter * 1000.0);
   else if (strcasecmp(args.field, "remote_count") == 0)
      snprintf(buf, buflen, "%u", qos.remote_count);
   else if (strcasecmp(args.field, "rtt") == 0)
      snprintf(buf, buflen, "%.0lf", qos.rtt * 1000.0);
   else if (strcasecmp(args.field, "all") == 0)
      ast_copy_string(buf, all, buflen);
   else {
      ast_log(LOG_WARNING, "Unrecognized argument '%s' to %s\n", preparse, funcname);
      return -1;
   }
   return 0;
}

static void add_blank

(

struct sip_request *

req

)

[static]

add a blank line if no body

Definition at line 2147 of file chan_sip.c.

References sip_request::data, sip_request::len, and sip_request::lines.

Referenced by send_request(), and send_response().

{
   if (!req->lines) {
      /* Add extra empty return. add_header() reserves 4 bytes so cannot be truncated */
      snprintf(req->data + req->len, sizeof(req->data) - req->len, "\r\n");
      req->len += strlen(req->data + req->len);
   }
}

static void add_codec_to_sdp	(	const struct sip_pvt *	p,
		int	codec,
		int	sample_rate,
		char **	m_buf,
		size_t *	m_size,
		char **	a_buf,
		size_t *	a_size,
		int	debug,
		int *	min_packet_size
	)			[static]

Add codec offer to SDP offer/answer body in INVITE or 200 OK.

Definition at line 5941 of file chan_sip.c.

References ast_build_string(), ast_codec_pref_getsize(), AST_FORMAT_G729A, AST_FORMAT_ILBC, ast_getformatname(), ast_rtp_codec_getpref(), ast_rtp_lookup_code(), ast_rtp_lookup_mime_subtype(), AST_RTP_OPT_G726_NONSTANDARD, ast_test_flag, ast_verbose(), sip_pvt::flags, fmt, sip_pvt::rtp, and SIP_G726_NONSTANDARD.

Referenced by add_sdp().

{
   int rtp_code;
   struct ast_format_list fmt;


   if (debug)
      ast_verbose("Adding codec 0x%x (%s) to SDP\n", codec, ast_getformatname(codec));
   if ((rtp_code = ast_rtp_lookup_code(p->rtp, 1, codec)) == -1)
      return;

   if (p->rtp) {
      struct ast_codec_pref *pref = ast_rtp_codec_getpref(p->rtp);
      fmt = ast_codec_pref_getsize(pref, codec);
   } else /* I dont see how you couldn't have p->rtp, but good to check for and error out if not there like earlier code */
      return;
   ast_build_string(m_buf, m_size, " %d", rtp_code);
   ast_build_string(a_buf, a_size, "a=rtpmap:%d %s/%d\r\n", rtp_code,
          ast_rtp_lookup_mime_subtype(1, codec,
                       ast_test_flag(&p->flags[0], SIP_G726_NONSTANDARD) ? AST_RTP_OPT_G726_NONSTANDARD : 0),
          sample_rate);
   if (codec == AST_FORMAT_G729A) {
      /* Indicate that we don't support VAD (G.729 annex B) */
      ast_build_string(a_buf, a_size, "a=fmtp:%d annexb=no\r\n", rtp_code);
   } else if (codec == AST_FORMAT_ILBC) {
      /* Add information about us using only 20/30 ms packetization */
      ast_build_string(a_buf, a_size, "a=fmtp:%d mode=%d\r\n", rtp_code, fmt.cur_ms);
   }

   if (fmt.cur_ms && (fmt.cur_ms < *min_packet_size))
      *min_packet_size = fmt.cur_ms;

   /* Our first codec packetization processed cannot be less than zero */
   if ((*min_packet_size) == 0  && fmt.cur_ms)
      *min_packet_size = fmt.cur_ms;
}

static int add_digit	(	struct sip_request *	req,
		char	digit,
		unsigned int	duration
	)			[static]

Add DTMF INFO tone to sip message.

Definition at line 5909 of file chan_sip.c.

References add_header(), add_header_contentLength(), and add_line().

Referenced by transmit_info_with_digit().

{
   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;
}

static int add_header	(	struct sip_request *	req,
		const char *	var,
		const char *	value
	)			[static]

Add header to SIP message.

Definition at line 5300 of file chan_sip.c.

References ast_log(), sip_request::data, find_alias(), sip_request::header, sip_request::headers, sip_request::len, sip_request::lines, LOG_WARNING, and SIP_MAX_HEADERS.

{
   int maxlen = sizeof(req->data) - 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);
      return -1;
   }

   req->header[req->headers] = req->data + req->len;

   if (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;   
}

static int add_header_contentLength	(	struct sip_request *	req,
		int	len
	)			[static]

Add 'Content-Length' header to SIP message.

Definition at line 5336 of file chan_sip.c.

References add_header().

Referenced by __transmit_response(), add_digit(), add_sdp(), add_t38_sdp(), add_text(), add_vidupdate(), transmit_invite(), transmit_notify_with_mwi(), transmit_notify_with_sipfrag(), transmit_register(), transmit_request(), transmit_request_with_auth(), transmit_response_with_allow(), transmit_response_with_auth(), transmit_response_with_date(), transmit_response_with_unsupported(), and transmit_state_notify().

{
   char clen[10];

   snprintf(clen, sizeof(clen), "%d", len);
   return add_header(req, "Content-Length", clen);
}

static int add_line	(	struct sip_request *	req,
		const char *	line
	)			[static]

Add content (not header) to SIP message.

Definition at line 5345 of file chan_sip.c.

References ast_log(), sip_request::data, 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, sizeof(req->data) - req->len, "\r\n");
      req->len += strlen(req->data + req->len);
   }
   if (req->len >= sizeof(req->data) - 4) {
      ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
      return -1;
   }
   req->line[req->lines] = req->data + req->len;
   snprintf(req->line[req->lines], sizeof(req->data) - req->len, "%s", line);
   req->len += strlen(req->line[req->lines]);
   req->lines++;
   return 0;   
}

static void add_noncodec_to_sdp	(	const struct sip_pvt *	p,
		int	format,
		int	sample_rate,
		char **	m_buf,
		size_t *	m_size,
		char **	a_buf,
		size_t *	a_size,
		int	debug
	)			[static]

Add RFC 2833 DTMF offer to SDP.

Definition at line 6114 of file chan_sip.c.

References ast_build_string(), AST_RTP_DTMF, ast_rtp_lookup_code(), ast_rtp_lookup_mime_subtype(), ast_verbose(), and sip_pvt::rtp.

Referenced by add_sdp().

{
   int rtp_code;

   if (debug)
      ast_verbose("Adding non-codec 0x%x (%s) to SDP\n", format, ast_rtp_lookup_mime_subtype(0, format, 0));
   if ((rtp_code = ast_rtp_lookup_code(p->rtp, 0, format)) == -1)
      return;

   ast_build_string(m_buf, m_size, " %d", rtp_code);
   ast_build_string(a_buf, a_size, "a=rtpmap:%d %s/%d\r\n", rtp_code,
          ast_rtp_lookup_mime_subtype(0, format, 0),
          sample_rate);
   if (format == AST_RTP_DTMF)
      /* Indicate we support DTMF and FLASH... */
      ast_build_string(a_buf, a_size, "a=fmtp:%d 0-16\r\n", rtp_code);
}

static struct sip_auth * add_realm_authentication	(	struct sip_auth *	authlist,
		char *	configuration,
		int	lineno
	)			[static]

Add realm authentication in list.

Definition at line 15680 of file chan_sip.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 username.

Referenced by build_peer().

{
   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;

}

static void add_route	(	struct sip_request *	req,
		struct sip_route *	route
	)			[static]

Add route header into request per learned route.

Definition at line 5466 of file chan_sip.c.

References add_header(), sip_route::hop, and sip_route::next.

Referenced by reqprep().

{
   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);
}

static enum sip_result add_sdp	(	struct sip_request *	resp,
		struct sip_pvt *	p
	)			[static]

Add Session Description Protocol message.

Definition at line 6137 of file chan_sip.c.

References add_codec_to_sdp(), add_header(), add_header_contentLength(), add_line(), add_noncodec_to_sdp(), ast_build_string(), ast_codec_pref_index(), AST_FAILURE, AST_FORMAT_AUDIO_MASK, AST_FORMAT_MAX_AUDIO, AST_FORMAT_MAX_VIDEO, AST_FORMAT_VIDEO_MASK, ast_getformatname_multiple(), ast_inet_ntoa(), ast_internal_timing_enabled(), ast_log(), ast_rtp_get_us(), AST_RTP_MAX, AST_SUCCESS, ast_test_flag, ast_verbose(), capability, debug, FALSE, sip_pvt::flags, sip_pvt::jointcapability, sip_pvt::jointnoncodeccapability, sip_pvt::lastrtprx, sip_pvt::lastrtptx, len, LOG_DEBUG, LOG_WARNING, sip_pvt::maxcallbitrate, option_debug, sip_pvt::ourip, sip_pvt::owner, sip_pvt::prefcodec, sip_pvt::prefs, sip_pvt::redirip, sip_pvt::rtp, SDP_SAMPLE_RATE, sip_pvt::sessionid, sip_pvt::sessionversion, sip_debug_test_pvt(), SIP_NOVIDEO, SIP_PAGE2_CALL_ONHOLD_INACTIVE, SIP_PAGE2_CALL_ONHOLD_ONEDIR, SIP_PAGE2_T38SUPPORT_RTP, sip_pvt::t38, t38properties::t38support, TRUE, sip_pvt::vredirip, and sip_pvt::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 AST_FAILURE;
   }

   /* Set RTP Session ID and version */
   if (!p->sessionid) {
      p->sessionid = getpid();
      p->sessionversion = p->sessionid;
   } else
      p->sessionversion++;

   /* Get our addresses */
   ast_rtp_get_us(p->rtp, &sin);
   if (p->vrtp)
      ast_rtp_get_us(p->vrtp, &vsin);

   /* Is this a re-invite to move the media out, then use the original offer from caller  */
   if (p->redirip.sin_addr.s_addr) {
      dest.sin_port = p->redirip.sin_port;
      dest.sin_addr = p->redirip.sin_addr;
   } else {
      dest.sin_addr = p->ourip;
      dest.sin_port = sin.sin_port;
   }

   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");
   }
      

   /* 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) {
      /* Determine video destination */
      if (p->vredirip.sin_addr.s_addr) {
         vdest.sin_addr = p->vredirip.sin_addr;
         vdest.sin_port = p->vredirip.sin_port;
      } else {
         vdest.sin_addr = p->ourip;
         vdest.sin_port = vsin.sin_port;
      }
      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));   
   }

   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) {
      int codec = p->prefcodec & AST_FORMAT_AUDIO_MASK;

      add_codec_to_sdp(p, codec, SDP_SAMPLE_RATE(codec),
             &m_audio_next, &m_audio_left,
             &a_audio_next, &a_audio_left,
             debug, &min_audio_packet_size);
      alreadysent |= codec;
   }

   /* Start by sending our preferred audio codecs */
   for (x = 0; x < 32; x++) {
      int codec;

      if (!(codec = ast_codec_pref_index(&p->prefs, x)))
         break; 

      if (!(capability & codec))
         continue;

      if (alreadysent & codec)
         continue;

      add_codec_to_sdp(p, codec, SDP_SAMPLE_RATE(codec),
             &m_audio_next, &m_audio_left,
             &a_audio_next, &a_audio_left,
             debug, &min_audio_packet_size);
      alreadysent |= 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, SDP_SAMPLE_RATE(x),
                &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 AST_SUCCESS;
}

static int add_sip_domain	(	const char *	domain,
		const enum domain_mode	mode,
		const char *	context
	)			[static]

Add SIP domain to list of domains we are responsible for.

Definition at line 15616 of file chan_sip.c.

References ast_calloc, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log(), ast_strlen_zero(), LOG_DEBUG, LOG_WARNING, and sipdebug.

{
   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 (sipdebug)  
      ast_log(LOG_DEBUG, "Added local SIP domain '%s'\n", domain);

   return 1;
}

static int add_t38_sdp	(	struct sip_request *	resp,
		struct sip_pvt *	p
	)			[static]

Add T.38 Session Description Protocol message.

Definition at line 6017 of file chan_sip.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_pvt::lastrtprx, sip_pvt::lastrtptx, len, LOG_DEBUG, LOG_WARNING, sip_pvt::ourip, t38properties::peercapability, s, sip_pvt::sessionid, sip_pvt::sessionversion, sip_debug_test_pvt(), t, sip_pvt::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_pvt::udptl, and sip_pvt::udptlredirip.

Referenced by transmit_invite(), transmit_reinvite_with_t38_sdp(), and transmit_response_with_t38_sdp().

{
   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;
}

static int add_text	(	struct sip_request *	req,
		const char *	text
	)			[static]

Add text body to SIP message.

Definition at line 5898 of file chan_sip.c.

References add_header(), add_header_contentLength(), and add_line().

Referenced by transmit_message_with_text().

{
   /* 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;
}

static int add_vidupdate

(

struct sip_request *

req

)

[static]

add XML encoded media control with update

Note:

XML: The only way to turn 0 bits of information into a few hundred. (markster)

Definition at line 5922 of file chan_sip.c.

References add_header(), add_header_contentLength(), and add_line().

Referenced by transmit_info_with_vidupdate().

{
   const char *xml_is_a_huge_waste_of_space =
      "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\r\n"
      " <media_control>\r\n"
      "  <vc_primitive>\r\n"
      "   <to_encoder>\r\n"
      "    <picture_fast_update>\r\n"
      "    </picture_fast_update>\r\n"
      "   </to_encoder>\r\n"
      "  </vc_primitive>\r\n"
      " </media_control>\r\n";
   add_header(req, "Content-Type", "application/media_control+xml");
   add_header_contentLength(req, strlen(xml_is_a_huge_waste_of_space));
   add_line(req, xml_is_a_huge_waste_of_space);
   return 0;
}

static void append_date

(

struct sip_request *

req

)

[static]

Append date to SIP message.

Definition at line 5845 of file chan_sip.c.

References add_header(), and t.

Referenced by build_csv_record(), transmit_invite(), transmit_response_with_date(), and transmit_response_with_unsupported().

{
   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);
}

static void append_history_full	(	struct sip_pvt *	p,
		const char *	fmt,
			...
	)			[static]

Append to SIP dialog history with arg list.

Definition at line 1836 of file chan_sip.c.

References append_history_va().

{
   va_list ap;

   if (!p)
      return;
   va_start(ap, fmt);
   append_history_va(p, fmt, ap);
   va_end(ap);

   return;
}

static void static void append_history_va	(	struct sip_pvt *	p,
		const char *	fmt,
		va_list	ap
	)			[static]

Append to SIP dialog history with arg list.

Definition at line 1816 of file chan_sip.c.

References ast_calloc, AST_LIST_INSERT_TAIL, free, and strsep().

Referenced by append_history_full().

{
   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);
}

AST_LIST_HEAD_NOLOCK	(	sip_history_head	,
		sip_history
	)

history list, entry in sip_pvt

static AST_LIST_HEAD_STATIC	(	domain_list	,
		domain
	)			[static]

The SIP domain list

AST_MODULE_INFO	(	ASTERISK_GPL_KEY	,
		AST_MODFLAG_DEFAULT	,
		"Session Initiation Protocol (SIP)"	,
		.	load = load_module,
		.	unload = unload_module,
		.	reload = reload
	)

AST_MUTEX_DEFINE_STATIC

(

sip_reload_lock

)

AST_MUTEX_DEFINE_STATIC

(

monlock

)

AST_MUTEX_DEFINE_STATIC

(

netlock

)

Protect the monitoring thread, so only one process can kill or start it, and not when it's doing something critical.

AST_MUTEX_DEFINE_STATIC

(

iflock

)

Protect the SIP dialog list (of sip_pvt's).

static void ast_quiet_chan

(

struct ast_channel *

chan

)

[static]

Turn off generator data XXX Does this function belong in the SIP channel?

Definition at line 12746 of file chan_sip.c.

References ast_channel::_state, ast_deactivate_generator(), AST_STATE_UP, and ast_channel::generatordata.

Referenced by attempt_transfer(), and handle_invite_replaces().

{
   if (chan && chan->_state == AST_STATE_UP) {
      if (chan->generatordata)
         ast_deactivate_generator(chan);
   }
}

static enum sip_result ast_sip_ouraddrfor	(	struct in_addr *	them,
		struct in_addr *	us
	)			[static]

NAT fix - decide which IP address to use for ASterisk server?

Using the localaddr structure built up with localnet statements in sip.conf apply it to their address to see if we need to substitute our externip or can get away with our internal bindaddr

Definition at line 1776 of file chan_sip.c.

References ahp, ast_apply_ha(), ast_gethostbyname(), ast_inet_ntoa(), ast_log(), ast_ouraddrfor(), AST_SUCCESS, externexpire, externhost, externrefresh, hp, localaddr, LOG_DEBUG, LOG_NOTICE, and option_debug.

Referenced by sip_alloc(), sip_notify(), sip_poke_peer(), sip_request_call(), sip_send_mwi_to_peer(), transmit_register(), and transmit_response_using_temp().

{
   struct sockaddr_in theirs, ours;

   /* Get our local information */
   ast_ouraddrfor(them, us);
   theirs.sin_addr = *them;
   ours.sin_addr = *us;

   if (localaddr && externip.sin_addr.s_addr &&
       (ast_apply_ha(localaddr, &theirs)) &&
       (!global_matchexterniplocally || !ast_apply_ha(localaddr, &ours))) {
      if (externexpire && time(NULL) >= externexpire) {
         struct ast_hostent ahp;
         struct hostent *hp;

         externexpire = time(NULL) + externrefresh;
         if ((hp = ast_gethostbyname(externhost, &ahp))) {
            memcpy(&externip.sin_addr, hp->h_addr, sizeof(externip.sin_addr));
         } else
            ast_log(LOG_NOTICE, "Warning: Re-lookup of '%s' failed!\n", externhost);
      }
      *us = externip.sin_addr;
      if (option_debug) {
         ast_log(LOG_DEBUG, "Target address %s is not local, substituting externip\n", 
            ast_inet_ntoa(*(struct in_addr *)&them->s_addr));
      }
   } else if (bindaddr.sin_addr.s_addr)
      *us = bindaddr.sin_addr;
   return AST_SUCCESS;
}

AST_THREADSTORAGE_CUSTOM	(	ts_temp_pvt	,
		temp_pvt_init	,
		temp_pvt_cleanup
	)

A per-thread temporary pvt structure.

static int attempt_transfer	(	struct sip_dual *	transferer,
		struct sip_dual *	target
	)			[static]

Attempt transfer of SIP call This fix for attended transfers on a local PBX.

Definition at line 12756 of file chan_sip.c.

References ast_channel::_state, ast_cdr_append(), ast_channel_masquerade(), ast_log(), ast_quiet_chan(), AST_SOFTHANGUP_DEV, ast_softhangup_nolock(), ast_state2str(), sip_dual::chan1, sip_dual::chan2, LOG_DEBUG, LOG_NOTICE, LOG_WARNING, and option_debug.

{
   int res = 0;
   struct ast_channel *peera = NULL,   
      *peerb = NULL,
      *peerc = NULL,
      *peerd = NULL;


   /* We will try to connect the transferee with the target and hangup
      all channels to the transferer */   
   if (option_debug > 3) {
      ast_log(LOG_DEBUG, "Sip transfer:--------------------\n");
      if (transferer->chan1)
         ast_log(LOG_DEBUG, "-- Transferer to PBX channel: %s State %s\n", transferer->chan1->name, ast_state2str(transferer->chan1->_state));
      else
         ast_log(LOG_DEBUG, "-- No transferer first channel - odd??? \n");
      if (target->chan1)
         ast_log(LOG_DEBUG, "-- Transferer to PBX second channel (target): %s State %s\n", target->chan1->name, ast_state2str(target->chan1->_state));
      else
         ast_log(LOG_DEBUG, "-- No target first channel ---\n");
      if (transferer->chan2)
         ast_log(LOG_DEBUG, "-- Bridged call to transferee: %s State %s\n", transferer->chan2->name, ast_state2str(transferer->chan2->_state));
      else
         ast_log(LOG_DEBUG, "-- No bridged call to transferee\n");
      if (target->chan2)
         ast_log(LOG_DEBUG, "-- Bridged call to transfer target: %s State %s\n", target->chan2 ? target->chan2->name : "<none>", target->chan2 ? ast_state2str(target->chan2->_state) : "(none)");
      else
         ast_log(LOG_DEBUG, "-- No target second channel ---\n");
      ast_log(LOG_DEBUG, "-- END Sip transfer:--------------------\n");
   }
   if (transferer->chan2) { /* We have a bridge on the transferer's channel */
      peera = transferer->chan1; /* Transferer - PBX -> transferee channel * the one we hangup */
      peerb = target->chan1;     /* Transferer - PBX -> target channel - This will get lost in masq */
      peerc = transferer->chan2; /* Asterisk to Transferee */
      peerd = target->chan2;     /* Asterisk to Target */
      if (option_debug > 2)
         ast_log(LOG_DEBUG, "SIP transfer: Four channels to handle\n");
   } else if (target->chan2) {   /* Transferer has no bridge (IVR), but transferee */
      peera = target->chan1;     /* Transferer to PBX -> target channel */
      peerb = transferer->chan1; /* Transferer to IVR*/
      peerc = target->chan2;     /* Asterisk to Target */
      peerd = transferer->chan2; /* Nothing */
      if (option_debug > 2)
         ast_log(LOG_DEBUG, "SIP transfer: Three channels to handle\n");
   }

   if (peera && peerb && peerc && (peerb != peerc)) {
      ast_quiet_chan(peera);     /* Stop generators */
      ast_quiet_chan(peerb);  
      ast_quiet_chan(peerc);
      if (peerd)
         ast_quiet_chan(peerd);

      /* Fix CDRs so they're attached to the remaining channel */
      if (peera->cdr && peerb->cdr)
         peerb->cdr = ast_cdr_append(peerb->cdr, peera->cdr);
      else if (peera->cdr) 
         peerb->cdr = peera->cdr;
      peera->cdr = NULL;

      if (peerb->cdr && peerc->cdr) 
         peerb->cdr = ast_cdr_append(peerb->cdr, peerc->cdr);
      else if (peerc->cdr)
         peerb->cdr = peerc->cdr;
      peerc->cdr = NULL;
   
      if (option_debug > 3)
         ast_log(LOG_DEBUG, "SIP transfer: trying to masquerade %s into %s\n", peerc->name, peerb->name);
      if (ast_channel_masquerade(peerb, peerc)) {
         ast_log(LOG_WARNING, "Failed to masquerade %s into %s\n", peerb->name, peerc->name);
         res = -1;
      } else
         ast_log(LOG_DEBUG, "SIP transfer: Succeeded to masquerade channels.\n");
      return res;
   } else {
      ast_log(LOG_NOTICE, "SIP Transfer attempted with no appropriate bridged calls to transfer\n");
      if (transferer->chan1)
         ast_softhangup_nolock(transferer->chan1, AST_SOFTHANGUP_DEV);
      if (target->chan1)
         ast_softhangup_nolock(target->chan1, AST_SOFTHANGUP_DEV);
      return -1;
   }
   return 0;
}

static int auto_congest

(

void *

nothing

)

[static]

Scheduled congestion on a call.

Definition at line 2749 of file chan_sip.c.

References append_history, ast_channel_trylock, ast_channel_unlock, AST_CONTROL_CONGESTION, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_queue_control(), sip_pvt::initid, sip_pvt::lock, LOG_NOTICE, and sip_pvt::owner.

{
   struct sip_pvt *p = nothing;

   ast_mutex_lock(&p->lock);
   p->initid = -1;
   if (p->owner) {
      /* XXX fails on possible deadlock */
      if (!ast_channel_trylock(p->owner)) {
         ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name);
         append_history(p, "Cong", "Auto-congesting (timer)");
         ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
         ast_channel_unlock(p->owner);
      }
   }
   ast_mutex_unlock(&p->lock);
   return 0;
}

static void build_callid_pvt

(

struct sip_pvt *

pvt

)

[static]

Build SIP Call-ID value for a non-REGISTER transaction.

Definition at line 4175 of file chan_sip.c.

References ast_inet_ntoa(), ast_string_field_build, generate_random_string(), sip_pvt::ourip, and S_OR.

Referenced by sip_alloc(), sip_notify(), sip_poke_peer(), sip_request_call(), and sip_send_mwi_to_peer().

{
   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);

}

static void build_callid_registry	(	struct sip_registry *	reg,
		struct in_addr	ourip,
		const char *	fromdomain
	)			[static]

Build SIP Call-ID value for a REGISTER transaction.

Definition at line 4186 of file chan_sip.c.

References ast_inet_ntoa(), ast_string_field_build, generate_random_string(), and S_OR.

Referenced by transmit_register().

{
   char buf[33];

   const char *host = S_OR(fromdomain, ast_inet_ntoa(ourip));

   ast_string_field_build(reg, callid, "%s@%s", generate_random_string(buf, sizeof(buf)), host);
}

static void build_contact

(

struct sip_pvt *

p

)

[static]

Build contact header - the contact header we send out.

Definition at line 6558 of file chan_sip.c.

References ast_inet_ntoa(), ast_string_field_build, ast_strlen_zero(), ourport, and STANDARD_SIP_PORT.

Referenced by check_user_full(), handle_request_invite(), handle_request_options(), handle_request_subscribe(), initreqprep(), register_verify(), and transmit_register().

{
   /* Construct Contact: header */
   if (ourport != STANDARD_SIP_PORT)
      ast_string_field_build(p, our_contact, "<sip:%s%s%s:%d>", p->exten, ast_strlen_zero(p->exten) ? "" : "@", ast_inet_ntoa(p->ourip), ourport);
   else
      ast_string_field_build(p, our_contact, "<sip:%s%s%s>", p->exten, ast_strlen_zero(p->exten) ? "" : "@", ast_inet_ntoa(p->ourip));
}

static struct sip_peer * build_peer	(	const char *	name,
		struct ast_variable *	v,
		struct ast_variable *	alt,
		int	realtime
	)			[static]

Build peer from configuration (file or realtime static/dynamic).

Definition at line 15946 of file chan_sip.c.

References sip_peer::accountcode, add_realm_authentication(), sip_peer::addr, sip_peer::allowtransfer, sip_peer::amaflags, ast_append_ha(), ast_callerid_split(), ast_calloc, ast_cdr_amaflags2int(), ast_clear_flag, ast_copy_flags, ast_free_ha(), ast_get_group(), ast_get_ip(), ast_get_ip_or_srv(), ast_get_time_t(), ast_log(), ast_parse_allow_disallow(), ast_parse_caller_presentation(), ast_sched_del(), ast_set2_flag, ast_set_flag, ast_strdupa, ast_strlen_zero(), ast_test_flag, ast_true(), ast_variable_new(), ast_variables_destroy(), ASTOBJ_CONTAINER_FIND_UNLINK_FULL, ASTOBJ_FLAG_MARKED, ASTOBJ_INIT, ASTOBJ_UNMARK, ASTOBJ_UNREF, sip_peer::auth, sip_peer::autoframing, sip_peer::call_limit, sip_peer::callgroup, sip_peer::callingpres, sip_peer::capability, sip_peer::chanvars, sip_peer::cid_name, sip_peer::cid_num, sip_peer::context, sip_peer::defaddr, DEFAULT_MAXMS, destroy_association(), sip_peer::expire, ast_flags::flags, sip_peer::flags, format, sip_peer::fromdomain, sip_peer::fromuser, sip_peer::fullcontact, global_flags, sip_peer::ha, handle_common_options(), sip_peer::language, sip_peer::lastmsgssent, ast_variable::lineno, LOG_DEBUG, LOG_WARNING, sip_peer::mailbox, sip_peer::maxcallbitrate, sip_peer::maxms, sip_peer::md5secret, sip_peer::mohinterpret, sip_peer::mohsuggest, ast_variable::name, ast_variable::next, option_debug, peerl, sip_peer::pickupgroup, sip_peer::prefs, reg_source_db(), sip_peer::regexten, sip_peer::rtpholdtimeout, sip_peer::rtpkeepalive, sip_peer::rtptimeout, sched, sip_peer::secret, set_peer_defaults(), sip_destroy_peer(), SIP_PAGE2_ALLOWSUBSCRIBE, SIP_PAGE2_DYNAMIC, SIP_PAGE2_IGNOREREGEXPIRE, SIP_PAGE2_RT_FROMCONTACT, SIP_PAGE2_SUBSCRIBEMWIONLY, SIP_REALTIME, SIP_USEREQPHONE, STANDARD_SIP_PORT, sip_peer::subscribecontext, sip_peer::tohost, TRANSFER_CLOSED, TRANSFER_OPENFORALL, TRUE, sip_peer::username, ast_variable::value, and sip_peer::vmexten.

{
   struct sip_peer *peer = NULL;
   struct ast_ha *oldha = NULL;
   int obproxyfound=0;
   int found=0;
   int firstpass=1;
   int format=0;     /* Ama flags */
   time_t regseconds = 0;
   char *varname = NULL, *varval = NULL;
   struct ast_variable *tmpvar = NULL;
   struct ast_flags peerflags[2] = {{(0)}};
   struct ast_flags mask[2] = {{(0)}};


   if (!realtime)
      /* Note we do NOT use find_peer here, to avoid realtime recursion */
      /* We also use a case-sensitive comparison (unlike find_peer) so
         that case changes made to the peer name will be properly handled
         during reload
      */
      peer = ASTOBJ_CONTAINER_FIND_UNLINK_FULL(&peerl, name, name, 0, 0, strcmp);

   if (peer) {
      /* Already in the list, remove it and it will be added back (or FREE'd)  */
      found = 1;
      if (!(peer->objflags & ASTOBJ_FLAG_MARKED))
         firstpass = 0;
   } else {
      if (!(peer = ast_calloc(1, sizeof(*peer))))
         return NULL;

      if (realtime)
         rpeerobjs++;
      else
         speerobjs++;
      ASTOBJ_INIT(peer);
   }
   /* Note that our peer HAS had its reference count incrased */
   if (firstpass) {
      peer->lastmsgssent = -1;
      oldha = peer->ha;
      peer->ha = NULL;
      set_peer_defaults(peer);   /* Set peer defaults */
   }
   if (!found && name)
         ast_copy_string(peer->name, name, sizeof(peer->name));

   /* If we have channel variables, remove them (reload) */
   if (peer->chanvars) {
      ast_variables_destroy(peer->chanvars);
      peer->chanvars = NULL;
      /* XXX should unregister ? */
   }
   for (; v || ((v = alt) && !(alt=NULL)); v = v->next) {
      if (handle_common_options(&peerflags[0], &mask[0], v))
         continue;
      if (realtime && !strcasecmp(v->name, "regseconds")) {
         ast_get_time_t(v->value, &regseconds, 0, NULL);
      } else if (realtime && !strcasecmp(v->name, "ipaddr") && !ast_strlen_zero(v->value) ) {
         inet_aton(v->value, &(peer->addr.sin_addr));
      } else if (realtime && !strcasecmp(v->name, "name"))
         ast_copy_string(peer->name, v->value, sizeof(peer->name));
      else if (realtime && !strcasecmp(v->name, "fullcontact")) {
         ast_copy_string(peer->fullcontact, v->value, sizeof(peer->fullcontact));
         ast_set_flag(&peer->flags[1], SIP_PAGE2_RT_FROMCONTACT);
      } else if (!strcasecmp(v->name, "secret")) 
         ast_copy_string(peer->secret, v->value, sizeof(peer->secret));
      else if (!strcasecmp(v->name, "md5secret")) 
         ast_copy_string(peer->md5secret, v->value, sizeof(peer->md5secret));
      else if (!strcasecmp(v->name, "auth"))
         peer->auth = add_realm_authentication(peer->auth, v->value, v->lineno);
      else if (!strcasecmp(v->name, "callerid")) {
         ast_callerid_split(v->value, peer->cid_name, sizeof(peer->cid_name), peer->cid_num, sizeof(peer->cid_num));
      } else if (!strcasecmp(v->name, "fullname")) {
         ast_copy_string(peer->cid_name, v->value, sizeof(peer->cid_name));
      } else if (!strcasecmp(v->name, "cid_number")) {
         ast_copy_string(peer->cid_num, v->value, sizeof(peer->cid_num));
      } else if (!strcasecmp(v->name, "context")) {
         ast_copy_string(peer->context, v->value, sizeof(peer->context));
      } else if (!strcasecmp(v->name, "subscribecontext")) {
         ast_copy_string(peer->subscribecontext, v->value, sizeof(peer->subscribecontext));
      } else if (!strcasecmp(v->name, "fromdomain")) {
         ast_copy_string(peer->fromdomain, v->value, sizeof(peer->fromdomain));
      } else if (!strcasecmp(v->name, "usereqphone")) {
         ast_set2_flag(&peer->flags[0], ast_true(v->value), SIP_USEREQPHONE);
      } else if (!strcasecmp(v->name, "fromuser")) {
         ast_copy_string(peer->fromuser, v->value, sizeof(peer->fromuser));
      } else if (!strcasecmp(v->name, "host") || !strcasecmp(v->name, "outboundproxy")) {
         if (!strcasecmp(v->value, "dynamic")) {
            if (!strcasecmp(v->name, "outboundproxy") || obproxyfound) {
               ast_log(LOG_WARNING, "You can't have a dynamic outbound proxy, you big silly head at line %d.\n", v->lineno);
            } else {
               /* They'll register with us */
               if (!found || !ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC)) {
                  /* Initialize stuff if this is a new peer, or if it used to be
                   * non-dynamic before the reload. */
                  memset(&peer->addr.sin_addr, 0, 4);
                  if (peer->addr.sin_port) {
                     /* If we've already got a port, make it the default rather than absolute */
                     peer->defaddr.sin_port = peer->addr.sin_port;
                     peer->addr.sin_port = 0;
                  }
               }
               ast_set_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC);
            }
         } else {
            /* Non-dynamic.  Make sure we become that way if we're not */
            if (peer->expire > -1)
               ast_sched_del(sched, peer->expire);
            peer->expire = -1;
            ast_clear_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC);
            if (!obproxyfound || !strcasecmp(v->name, "outboundproxy")) {
               if (ast_get_ip_or_srv(&peer->addr, v->value, srvlookup ? "_sip._udp" : NULL)) {
                  ASTOBJ_UNREF(peer, sip_destroy_peer);
                  return NULL;
               }
            }
            if (!strcasecmp(v->name, "outboundproxy"))
               obproxyfound=1;
            else {
               ast_copy_string(peer->tohost, v->value, sizeof(peer->tohost));
               if (!peer->addr.sin_port)
                  peer->addr.sin_port = htons(STANDARD_SIP_PORT);
            }
         }
      } else if (!strcasecmp(v->name, "defaultip")) {
         if (ast_get_ip(&peer->defaddr, v->value)) {
            ASTOBJ_UNREF(peer, sip_destroy_peer);
            return NULL;
         }
      } else if (!strcasecmp(v->name, "permit") || !strcasecmp(v->name, "deny")) {
         peer->ha = ast_append_ha(v->name, v->value, peer->ha);
      } else if (!strcasecmp(v->name, "port")) {
         if (!realtime && ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC))
            peer->defaddr.sin_port = htons(atoi(v->value));
         else
            peer->addr.sin_port = htons(atoi(v->value));
      } else if (!strcasecmp(v->name, "callingpres")) {
         peer->callingpres = ast_parse_caller_presentation(v->value);
         if (peer->callingpres == -1)
            peer->callingpres = atoi(v->value);
      } else if (!strcasecmp(v->name, "username")) {
         ast_copy_string(peer->username, v->value, sizeof(peer->username));
      } else if (!strcasecmp(v->name, "language")) {
         ast_copy_string(peer->language, v->value, sizeof(peer->language));
      } else if (!strcasecmp(v->name, "regexten")) {
         ast_copy_string(peer->regexten, v->value, sizeof(peer->regexten));
      } else if (!strcasecmp(v->name, "call-limit") || !strcasecmp(v->name, "incominglimit")) {
         peer->call_limit = atoi(v->value);
         if (peer->call_limit < 0)
            peer->call_limit = 0;
      } else if (!strcasecmp(v->name, "amaflags")) {
         format = ast_cdr_amaflags2int(v->value);
         if (format < 0) {
            ast_log(LOG_WARNING, "Invalid AMA Flags for peer: %s at line %d\n", v->value, v->lineno);
         } else {
            peer->amaflags = format;
         }
      } else if (!strcasecmp(v->name, "accountcode")) {
         ast_copy_string(peer->accountcode, v->value, sizeof(peer->accountcode));
      } else if (!strcasecmp(v->name, "mohinterpret")
         || !strcasecmp(v->name, "musicclass") || !strcasecmp(v->name, "musiconhold")) {
         ast_copy_string(peer->mohinterpret, v->value, sizeof(peer->mohinterpret));
      } else if (!strcasecmp(v->name, "mohsuggest")) {
         ast_copy_string(peer->mohsuggest, v->value, sizeof(peer->mohsuggest));
      } else if (!strcasecmp(v->name, "mailbox")) {
         ast_copy_string(peer->mailbox, v->value, sizeof(peer->mailbox));
      } else if (!strcasecmp(v->name, "subscribemwi")) {
         ast_set2_flag(&peer->flags[1], ast_true(v->value), SIP_PAGE2_SUBSCRIBEMWIONLY);
      } else if (!strcasecmp(v->name, "vmexten")) {
         ast_copy_string(peer->vmexten, v->value, sizeof(peer->vmexten));
      } else if (!strcasecmp(v->name, "callgroup")) {
         peer->callgroup = ast_get_group(v->value);
      } else if (!strcasecmp(v->name, "allowtransfer")) {
         peer->allowtransfer = ast_true(v->value) ? TRANSFER_OPENFORALL : TRANSFER_CLOSED;
      } else if (!strcasecmp(v->name, "pickupgroup")) {
         peer->pickupgroup = ast_get_group(v->value);
      } else if (!strcasecmp(v->name, "allow")) {
         ast_parse_allow_disallow(&peer->prefs, &peer->capability, v->value, 1);
      } else if (!strcasecmp(v->name, "disallow")) {
         ast_parse_allow_disallow(&peer->prefs, &peer->capability, v->value, 0);
      } else if (!strcasecmp(v->name, "autoframing")) {
         peer->autoframing = ast_true(v->value);
      } else if (!strcasecmp(v->name, "rtptimeout")) {
         if ((sscanf(v->value, "%d", &peer->rtptimeout) != 1) || (peer->rtptimeout < 0)) {
            ast_log(LOG_WARNING, "'%s' is not a valid RTP hold time at line %d.  Using default.\n", v->value, v->lineno);
            peer->rtptimeout = global_rtptimeout;
         }
      } else if (!strcasecmp(v->name, "rtpholdtimeout")) {
         if ((sscanf(v->value, "%d", &peer->rtpholdtimeout) != 1) || (peer->rtpholdtimeout < 0)) {
            ast_log(LOG_WARNING, "'%s' is not a valid RTP hold time at line %d.  Using default.\n", v->value, v->lineno);
            peer->rtpholdtimeout = global_rtpholdtimeout;
         }
      } else if (!strcasecmp(v->name, "rtpkeepalive")) {
         if ((sscanf(v->value, "%d", &peer->rtpkeepalive) != 1) || (peer->rtpkeepalive < 0)) {
            ast_log(LOG_WARNING, "'%s' is not a valid RTP keepalive time at line %d.  Using default.\n", v->value, v->lineno);
            peer->rtpkeepalive = global_rtpkeepalive;
         }
      } else if (!strcasecmp(v->name, "setvar")) {
         /* Set peer channel variable */
         varname = ast_strdupa(v->value);
         if ((varval = strchr(varname, '='))) {
            *varval++ = '\0';
            if ((tmpvar = ast_variable_new(varname, varval))) {
               tmpvar->next = peer->chanvars;
               peer->chanvars = tmpvar;
            }
         }
      } else if (!strcasecmp(v->name, "qualify")) {
         if (!strcasecmp(v->value, "no")) {
            peer->maxms = 0;
         } else if (!strcasecmp(v->value, "yes")) {
            peer->maxms = DEFAULT_MAXMS;
         } else if (sscanf(v->value, "%d", &peer->maxms) != 1) {
            ast_log(LOG_WARNING, "Qualification of peer '%s' should be 'yes', 'no', or a number of milliseconds at line %d of sip.conf\n", peer->name, v->lineno);
            peer->maxms = 0;
         }
      } else if (!strcasecmp(v->name, "maxcallbitrate")) {
         peer->maxcallbitrate = atoi(v->value);
         if (peer->maxcallbitrate < 0)
            peer->maxcallbitrate = default_maxcallbitrate;
      }
   }
   if (!ast_test_flag(&global_flags[1], SIP_PAGE2_IGNOREREGEXPIRE) && ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC) && realtime) {
      time_t nowtime = time(NULL);

      if ((nowtime - regseconds) > 0) {
         destroy_association(peer);
         memset(&peer->addr, 0, sizeof(peer->addr));
         if (option_debug)
            ast_log(LOG_DEBUG, "Bah, we're expired (%d/%d/%d)!\n", (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
      }
   }
   ast_copy_flags(&peer->flags[0], &peerflags[0], mask[0].flags);
   ast_copy_flags(&peer->flags[1], &peerflags[1], mask[1].flags);
   if (ast_test_flag(&peer->flags[1], SIP_PAGE2_ALLOWSUBSCRIBE))
      global_allowsubscribe = TRUE; /* No global ban any more */
   if (!found && ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC) && !ast_test_flag(&peer->flags[0], SIP_REALTIME))
      reg_source_db(peer);
   ASTOBJ_UNMARK(peer);
   ast_free_ha(oldha);
   return peer;
}

static int build_reply_digest	(	struct sip_pvt *	p,
		int	method,
		char *	digest,
		int	digest_len
	)			[static]

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 11187 of file chan_sip.c.

References append_history, 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_pvt::noncecount, sip_pvt::sa, sip_auth::secret, secret, sip_methods, sipdebug, text, sip_auth::username, and username.

Referenced by reply_digest(), transmit_register(), and transmit_request_with_auth().

{
   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->username, 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][%s]\n",
         auth->username, p->peername, p->username);
      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_methods[method].text, 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);

   append_history(p, "AuthResp", "Auth response sent for %s in realm %s - nc %d", username, p->realm, p->noncecount);

   return 0;
}

static void build_route	(	struct sip_pvt *	p,
		struct sip_request *	req,
		int	backwards
	)			[static]

Build route list from Record-Route header.

Definition at line 7933 of file chan_sip.c.

References __get_header(), ast_log(), ast_malloc, ast_strlen_zero(), free_old_route(), get_header(), sip_route::hop, len, list_route(), LOG_DEBUG, sip_route::next, option_debug, sip_pvt::route, sip_pvt::route_persistant, and sip_debug_test_pvt().

Referenced by handle_request_invite(), and handle_response_invite().

{
   struct sip_route *thishop, *head, *tail;
   int start = 0;
   int len;
   const char *rr, *contact, *c;

   /* Once a persistant route is set, don't fool with it */
   if (p->route && p->route_persistant) {
      if (option_debug)
         ast_log(LOG_DEBUG, "build_route: Retaining previous route: <%s>\n", p->route->hop);
      return;
   }

   if (p->route) {
      free_old_route(p->route);
      p->route = NULL;
   }
   
   p->route_persistant = backwards;
   
   /* Build a tailq, then assign it to p->route when done.
    * If backwards, we add entries from the head so they end up
    * in reverse order. However, we do need to maintain a correct
    * tail pointer because the contact is always at the end.
    */
   head = NULL;
   tail = head;
   /* 1st we pass through all the hops in any Record-Route headers */
   for (;;) {
      /* Each Record-Route header */
      rr = __get_header(req, "Record-Route", &start);
      if (*rr == '\0')
         break;
      for (; (rr = strchr(rr, '<')) ; rr += len) { /* Each route entry */
         ++rr;
         len = strcspn(rr, ">") + 1;
         /* Make a struct route */
         if ((thishop = ast_malloc(sizeof(*thishop) + len))) {
            /* ast_calloc is not needed because all fields are initialized in this block */
            ast_copy_string(thishop->hop, rr, len);
            if (option_debug > 1)
               ast_log(LOG_DEBUG, "build_route: Record-Route hop: <%s>\n", thishop->hop);
            /* Link in */
            if (backwards) {
               /* Link in at head so they end up in reverse order */
               thishop->next = head;
               head = thishop;
               /* If this was the first then it'll be the tail */
               if (!tail)
                  tail = thishop;
            } else {
               thishop->next = NULL;
               /* Link in at the end */
               if (tail)
                  tail->next = thishop;
               else
                  head = thishop;
               tail = thishop;
            }
         }
      }
   }

   /* Only append the contact if we are dealing with a strict router */
   if (!head || (!ast_strlen_zero(head->hop) && strstr(head->hop,";lr") == NULL) ) {
      /* 2nd append the Contact: if there is one */
      /* Can be multiple Contact headers, comma separated values - we just take the first */
      contact = get_header(req, "Contact");
      if (!ast_strlen_zero(contact)) {
         if (option_debug > 1)
            ast_log(LOG_DEBUG, "build_route: Contact hop: %s\n", contact);
         /* Look for <: delimited address */
         c = strchr(contact, '<');
         if (c) {
            /* Take to > */
            ++c;
            len = strcspn(c, ">") + 1;
         } else {
            /* No <> - just take the lot */
            c = contact;
            len = strlen(contact) + 1;
         }
         if ((thishop = ast_malloc(sizeof(*thishop) + len))) {
            /* ast_calloc is not needed because all fields are initialized in this block */
            ast_copy_string(thishop->hop, c, len);
            thishop->next = NULL;
            /* Goes at the end */
            if (tail)
               tail->next = thishop;
            else
               head = thishop;
         }
      }
   }

   /* Store as new route */
   p->route = head;

   /* For debugging dump what we ended up with */
   if (sip_debug_test_pvt(p))
      list_route(p->route);
}

static void build_rpid

(

struct sip_pvt *

p

)

[static]

Build the Remote Party-ID & From using callingpres options.

Definition at line 6568 of file chan_sip.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_pvt::callingpres, ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, FALSE, LOG_WARNING, sip_pvt::ourip, sip_pvt::owner, S_OR, sip_pvt::tag, and TRUE.

Referenced by initreqprep().

{
   int send_pres_tags = TRUE;
   const char *privacy=NULL;
   const char *screen=NULL;
   char buf[256];
   const char *clid = 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 = "yes";
      break;
   case AST_PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN:
      privacy = "off";
      screen = "no";
      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 = "yes";
      break;
   case AST_PRES_PROHIB_USER_NUMBER_FAILED_SCREEN:
      privacy = "full";
      screen = "no";
      break;
   case AST_PRES_PROHIB_NETWORK_NUMBER:
      privacy = "full";
      screen = "yes";
      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);
}

static struct sip_user * build_user	(	const char *	name,
		struct ast_variable *	v,
		int	realtime
	)			[static]

Initiate a SIP user structure from configuration (configuration or realtime).

Definition at line 15767 of file chan_sip.c.

References sip_user::allowtransfer, ast_append_ha(), ast_calloc, ast_copy_flags, ast_strdupa, ast_true(), ast_variable_new(), ASTOBJ_INIT, sip_user::chanvars, default_prefs, format, global_flags, sip_user::ha, handle_common_options(), ast_variable::name, ast_variable::next, sip_user::secret, SIP_FLAGS_TO_COPY, SIP_PAGE2_FLAGS_TO_COPY, TRANSFER_CLOSED, TRANSFER_OPENFORALL, and ast_variable::value.

{
   struct sip_user *user;
   int format;
   struct ast_ha *oldha = NULL;
   char *varname = NULL, *varval = NULL;
   struct ast_variable *tmpvar = NULL;
   struct ast_flags userflags[2] = {{(0)}};
   struct ast_flags mask[2] = {{(0)}};


   if (!(user = ast_calloc(1, sizeof(*user))))
      return NULL;
      
   suserobjs++;
   ASTOBJ_INIT(user);
   ast_copy_string(user->name, name, sizeof(user->name));
   oldha = user->ha;
   user->ha = NULL;
   ast_copy_flags(&user->flags[0], &global_flags[0], SIP_FLAGS_TO_COPY);
   ast_copy_flags(&user->flags[1], &global_flags[1], SIP_PAGE2_FLAGS_TO_COPY);
   user->capability = global_capability;
   user->allowtransfer = global_allowtransfer;
   user->maxcallbitrate = default_maxcallbitrate;
   user->autoframing = global_autoframing;
   user->prefs = default_prefs;
   /* set default context */
   strcpy(user->context, default_context);
   strcpy(user->language, default_language);
   strcpy(user->mohinterpret, default_mohinterpret);
   strcpy(user->mohsuggest, default_mohsuggest);
   for (; v; v = v->next) {
      if (handle_common_options(&userflags[0], &mask[0], v))
         continue;

      if (!strcasecmp(v->name, "context")) {
         ast_copy_string(user->context, v->value, sizeof(user->context));
      } else if (!strcasecmp(v->name, "subscribecontext")) {
         ast_copy_string(user->subscribecontext, v->value, sizeof(user->subscribecontext));
      } else if (!strcasecmp(v->name, "setvar")) {
         varname = ast_strdupa(v->value);
         if ((varval = strchr(varname,'='))) {
            *varval++ = '\0';
            if ((tmpvar = ast_variable_new(varname, varval))) {
               tmpvar->next = user->chanvars;
               user->chanvars = tmpvar;
            }
         }
      } else if (!strcasecmp(v->name, "permit") ||
               !strcasecmp(v->name, "deny")) {
         user->ha = ast_append_ha(v->name, v->value, user->ha);
      } else if (!strcasecmp(v->name, "allowtransfer")) {
         user->allowtransfer = ast_true(v->value) ? TRANSFER_OPENFORALL : TRANSFER_CLOSED;
      } else if (!strcasecmp(v->name, "secret")) {
         ast_copy_string(user->secret, v->value, sizeof(user->secret)); 
      } else if (!strcasecmp(v->name, "md5secret")) {
         ast_copy_string(user->md5secret, v->value, sizeof(user->md5secret));
      } else if (!strcasecmp(v->name, "callerid")) {
         ast_callerid_split(v->value, user->cid_name, sizeof(user->cid_name), user->cid_num, sizeof(user->cid_num));
      } else if (!strcasecmp(v->name, "fullname")) {
         ast_copy_string(user->cid_name, v->value, sizeof(user->cid_name));
      } else if (!strcasecmp(v->name, "cid_number")) {
         ast_copy_string(user->cid_num, v->value, sizeof(user->cid_num));
      } else if (!strcasecmp(v->name, "callgroup")) {
         user->callgroup = ast_get_group(v->value);
      } else if (!strcasecmp(v->name, "pickupgroup")) {
         user->pickupgroup = ast_get_group(v->value);
      } else if (!strcasecmp(v->name, "language")) {
         ast_copy_string(user->language, v->value, sizeof(user->language));
      } else if (!strcasecmp(v->name, "mohinterpret") 
         || !strcasecmp(v->name, "musicclass") || !strcasecmp(v->name, "musiconhold")) {
         ast_copy_string(user->mohinterpret, v->value, sizeof(user->mohinterpret));
      } else if (!strcasecmp(v->name, "mohsuggest")) {
         ast_copy_string(user->mohsuggest, v->value, sizeof(user->mohsuggest));
      } else if (!strcasecmp(v->name, "accountcode")) {
         ast_copy_string(user->accountcode, v->value, sizeof(user->accountcode));
      } else if (!strcasecmp(v->name, "call-limit")) {
         user->call_limit = atoi(v->value);
         if (user->call_limit < 0)
            user->call_limit = 0;
      } else if (!strcasecmp(v->name, "amaflags")) {
         format = ast_cdr_amaflags2int(v->value);
         if (format < 0) {
            ast_log(LOG_WARNING, "Invalid AMA Flags: %s at line %d\n", v->value, v->lineno);
         } else {
            user->amaflags = format;
         }
      } else if (!strcasecmp(v->name, "allow")) {
         ast_parse_allow_disallow(&user->prefs, &user->capability, v->value, 1);
      } else if (!strcasecmp(v->name, "disallow")) {
         ast_parse_allow_disallow(&user->prefs, &user->capability, v->value, 0);
      } else if (!strcasecmp(v->name, "autoframing")) {
         user->autoframing = ast_true(v->value);
      } else if (!strcasecmp(v->name, "callingpres")) {
         user->callingpres = ast_parse_caller_presentation(v->value);
         if (user->callingpres == -1)
            user->callingpres = atoi(v->value);
      } else if (!strcasecmp(v->name, "maxcallbitrate")) {
         user->maxcallbitrate = atoi(v->value);
         if (user->maxcallbitrate < 0)
            user->maxcallbitrate = default_maxcallbitrate;
      }
      /* We can't just report unknown options here because this may be a
       * type=friend entry.  All user options are valid for a peer, but not
       * the other way around.  */
   }
   ast_copy_flags(&user->flags[0], &userflags[0], mask[0].flags);
   ast_copy_flags(&user->flags[1], &userflags[1], mask[1].flags);
   if (ast_test_flag(&user->flags[1], SIP_PAGE2_ALLOWSUBSCRIBE))
      global_allowsubscribe = TRUE; /* No global ban any more */
   ast_free_ha(oldha);
   return user;
}

static void build_via

(

struct sip_pvt *

p

)

[static]

Build a Via header for a request.

Definition at line 1760 of file chan_sip.c.

References ast_inet_ntoa(), ast_string_field_build, ast_test_flag, sip_pvt::branch, sip_pvt::flags, sip_pvt::ourip, ourport, SIP_NAT, and SIP_NAT_RFC3581.

Referenced by reqprep(), sip_alloc(), sip_notify(), sip_poke_peer(), sip_request_call(), sip_send_mwi_to_peer(), transmit_invite(), transmit_register(), and transmit_response_using_temp().

{
   /* Work around buggy UNIDEN UIP200 firmware */
   const char *rport = ast_test_flag(&p->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(p, via, "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x%s",
          ast_inet_ntoa(p->ourip), ourport, p->branch, rport);
}

static int cb_extensionstate	(	char *	context,
		char *	exten,
		int	state,
		void *	data
	)			[static]

Callback for the devicestate notification (SUBSCRIBE) support subsystem.

Note:

If you add an "hint" priority to the extension in the dial plan, you will get notifications on device state changes

Definition at line 8225 of file chan_sip.c.

References append_history, AST_EXTENSION_DEACTIVATED, AST_EXTENSION_REMOVED, ast_extension_state2str(), ast_verbose(), sip_pvt::autokillid, DEFAULT_TRANS_TIMEOUT, FALSE, sip_pvt::laststate, NONE, option_verbose, sip_cancel_destroy(), sip_scheddestroy(), sip_pvt::stateid, sip_pvt::subscribed, transmit_state_notify(), VERBOSE_PREFIX_1, and VERBOSE_PREFIX_2.

Referenced by handle_request_subscribe().

{
   struct sip_pvt *p = data;

   switch(state) {
   case AST_EXTENSION_DEACTIVATED:  /* Retry after a while */
   case AST_EXTENSION_REMOVED:   /* Extension is gone */
      if (p->autokillid > -1)
         sip_cancel_destroy(p);  /* Remove subscription expiry for renewals */
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);  /* Delete subscription in 32 secs */
      ast_verbose(VERBOSE_PREFIX_2 "Extension state: Watcher for hint %s %s. Notify User %s\n", exten, state == AST_EXTENSION_DEACTIVATED ? "deactivated" : "removed", p->username);
      p->stateid = -1;
      p->subscribed = NONE;
      append_history(p, "Subscribestatus", "%s", state == AST_EXTENSION_REMOVED ? "HintRemoved" : "Deactivated");
      break;
   default: /* Tell user */
      p->laststate = state;
      break;
   }
   if (p->subscribed != NONE) /* Only send state NOTIFY if we know the format */
      transmit_state_notify(p, state, 1, FALSE);

   if (option_verbose > 1)
      ast_verbose(VERBOSE_PREFIX_1 "Extension Changed %s new state %s for Notify User %s\n", exten, ast_extension_state2str(state), p->username);
   return 0;
}

static enum check_auth_result check_auth	(	struct sip_pvt *	p,
		struct sip_request *	req,
		const char *	username,
		const char *	secret,
		const char *	md5secret,
		int	sipmethod,
		char *	uri,
		enum xmittype	reliable,
		int	ignore
	)			[static]

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 8043 of file chan_sip.c.

References append_history, ast_log(), ast_md5_hash(), ast_random(), ast_string_field_build, ast_strlen_zero(), AUTH_CHALLENGE_SENT, AUTH_SUCCESSFUL, AUTH_USERNAME_MISMATCH, DEFAULT_TRANS_TIMEOUT, FALSE, get_header(), key(), keys, LOG_NOTICE, LOG_WARNING, s, S_OR, sip_methods, SIP_REGISTER, sip_scheddestroy(), SIP_SUBSCRIBE, sipdebug, strsep(), text, transmit_response_with_auth(), and TRUE.

Referenced by check_user_full(), and register_verify().

{
   const char *response = "407 Proxy Authentication Required";
   const char *reqheader = "Proxy-Authorization";
   const char *respheader = "Proxy-Authenticate";
   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;
   if (sipmethod == SIP_REGISTER || sipmethod == SIP_SUBSCRIBE) {
      /* On a REGISTER, we have to use 401 and its family of headers instead of 407 and its family
         of headers -- GO SIP!  Whoo hoo!  Two things that do the same thing but are used in
         different circumstances! What a surprise. */
      response = "401 Unauthorized";
      reqheader = "Authorization";
      respheader = "WWW-Authenticate";
   }
   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_methods[sipmethod].text,
            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, TRUE);
      } 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, FALSE);
      }

      /* Schedule auto destroy in 32 seconds */
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
      return AUTH_CHALLENGE_SENT;
   } 
   if (good_response) {
      append_history(p, "AuthOK", "Auth challenge succesful for %s", username);
      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;
}

static void check_pendings

(

struct sip_pvt *

p

)

[static]

Check pending actions on SIP call.

Definition at line 11641 of file chan_sip.c.

References ast_clear_flag, ast_log(), ast_test_flag, DEFAULT_TRANS_TIMEOUT, FALSE, sip_pvt::flags, INV_EARLY_MEDIA, INV_PROCEEDING, sip_pvt::invitestate, LOG_DEBUG, option_debug, SIP_BYE, SIP_CANCEL, SIP_NEEDREINVITE, SIP_PENDINGBYE, sip_scheddestroy(), transmit_reinvite_with_sdp(), transmit_request(), transmit_request_with_auth(), TRUE, and XMIT_RELIABLE.

Referenced by handle_request(), and handle_response_invite().

{
   if (ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
      /* if we can't BYE, then this is really a pending CANCEL */
      if (p->invitestate == INV_PROCEEDING || p->invitestate == INV_EARLY_MEDIA)
         transmit_request(p, SIP_CANCEL, p->ocseq, XMIT_RELIABLE, FALSE);
         /* Actually don't destroy us yet, wait for the 487 on our original 
            INVITE, but do set an autodestruct just in case we never get it. */
      else 
         transmit_request_with_auth(p, SIP_BYE, 0, XMIT_RELIABLE, TRUE);
      ast_clear_flag(&p->flags[0], SIP_PENDINGBYE);   
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
   } else if (ast_test_flag(&p->flags[0], SIP_NEEDREINVITE)) {
      if (option_debug)
         ast_log(LOG_DEBUG, "Sending pending reinvite on '%s'\n", p->callid);
      /* Didn't get to reinvite yet, so do it now */
      transmit_reinvite_with_sdp(p);
      ast_clear_flag(&p->flags[0], SIP_NEEDREINVITE); 
   }
}

static int check_sip_domain	(	const char *	domain,
		char *	context,
		size_t	len
	)			[static]

check_sip_domain: Check if domain part of uri is local to our server

Definition at line 15646 of file chan_sip.c.

References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strlen_zero(), domain::context, domain::domain, and result.

Referenced by func_check_sipdomain(), get_destination(), handle_request_refer(), and register_verify().

{
   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;
}

static int check_user	(	struct sip_pvt *	p,
		struct sip_request *	req,
		int	sipmethod,
		char *	uri,
		enum xmittype	reliable,
		struct sockaddr_in *	sin
	)			[static]

Find user If we get a match, this will add a reference pointer to the user object in ASTOBJ, that needs to be unreferenced.

Definition at line 9297 of file chan_sip.c.

References check_user_full().

Referenced by handle_request_invite().

{
   return check_user_full(p, req, sipmethod, uri, reliable, sin, NULL);
}

static enum check_auth_result check_user_full	(	struct sip_pvt *	p,
		struct sip_request *	req,
		int	sipmethod,
		char *	uri,
		enum xmittype	reliable,
		struct sockaddr_in *	sin,
		struct sip_peer **	authpeer
	)			[static]

Check if matching user or peer is defined Match user on From: user name and peer on IP/port This is used on first invite (not re-invites) and subscribe requests.

Returns:

0 on success, non-zero on failure

Definition at line 8983 of file chan_sip.c.

References sip_peer::accountcode, sip_user::accountcode, accountcode, sip_user::allowtransfer, sip_peer::amaflags, sip_user::amaflags, ast_apply_ha(), ast_copy_flags, AST_FORMAT_VIDEO_MASK, ast_inet_ntoa(), ast_is_shrinkable_phonenumber(), ast_log(), ast_rtp_codec_setpref(), ast_rtp_destroy(), AST_RTP_DTMF, ast_set_flag, ast_shrink_phone_number(), ast_strdupa, ast_string_field_free, ast_string_field_set, ast_strlen_zero(), ast_test_flag, ast_uri_decode(), ast_variable_new(), ast_verbose(), ASTOBJ_REF, ASTOBJ_UNREF, AUTH_FAKE_AUTH, AUTH_SECRET_FAILED, AUTH_SUCCESSFUL, sip_peer::autoframing, sip_user::autoframing, build_contact(), sip_peer::call_limit, sip_user::call_limit, sip_peer::callgroup, sip_user::callgroup, sip_peer::callingpres, sip_user::callingpres, sip_peer::capability, sip_user::capability, sip_peer::chanvars, sip_user::chanvars, check_auth(), sip_peer::cid_name, sip_user::cid_name, cid_name, sip_peer::cid_num, sip_user::cid_num, cid_num, sip_peer::context, context, sip_user::context, debug, do_setnat(), exten, find_peer(), find_user(), sip_peer::flags, sip_user::flags, sip_peer::fullcontact, get_calleridname(), get_header(), get_in_brackets(), get_rpid_num(), sip_user::ha, sip_peer::language, sip_user::language, language, sip_peer::lastms, LOG_NOTICE, sip_peer::maxcallbitrate, sip_user::maxcallbitrate, sip_peer::maxms, sip_peer::md5secret, sip_user::md5secret, sip_peer::mohinterpret, sip_user::mohinterpret, mohinterpret, sip_peer::mohsuggest, sip_user::mohsuggest, mohsuggest, ast_variable::next, sip_peer::pickupgroup, sip_user::pickupgroup, sip_peer::prefs, sip_user::prefs, sip_peer::secret, sip_user::secret, SIP_CALL_LIMIT, sip_cancel_destroy(), sip_debug_test_addr(), sip_destroy_peer(), sip_destroy_user(), SIP_DTMF, SIP_DTMF_AUTO, SIP_DTMF_RFC2833, SIP_FLAGS_TO_COPY, SIP_INSECURE_INVITE, SIP_NAT_ROUTE, SIP_PAGE2_FLAGS_TO_COPY, SIP_PAGE2_VIDEOSUPPORT, SIP_PKT_IGNORE, SIP_SUBSCRIBE, SIP_TRUSTRPID, sip_peer::sipoptions, sip_user::sipoptions, strsep(), sip_peer::subscribecontext, sip_user::subscribecontext, t, sip_peer::username, and username.

Referenced by check_user(), and handle_request_subscribe().

{
   struct sip_user *user = NULL;
   struct sip_peer *peer;
   char from[256], *c;
   char *of;
   char rpid_num[50];
   const char *rpid;
   enum check_auth_result res = AUTH_SUCCESSFUL;
   char *t;
   char calleridname[50];
   int debug=sip_debug_test_addr(sin);
   struct ast_variable *tmpvar = NULL, *v = NULL;
   char *uri2 = ast_strdupa(uri);

   /* Terminate URI */
   t = uri2;
   while (*t && *t > 32 && *t != ';')
      t++;
   *t = '\0';
   ast_copy_string(from, get_header(req, "From"), sizeof(from));  /* XXX bug in original code, overwrote string */
   if (pedanticsipchecking)
      ast_uri_decode(from);
   /* XXX here tries to map the username for invite things */
   memset(calleridname, 0, sizeof(calleridname));
   get_calleridname(from, calleridname, sizeof(calleridname));
   if (calleridname[0])
      ast_string_field_set(p, cid_name, calleridname);

   rpid = get_header(req, "Remote-Party-ID");
   memset(rpid_num, 0, sizeof(rpid_num));
   if (!ast_strlen_zero(rpid)) 
      p->callingpres = get_rpid_num(rpid, rpid_num, sizeof(rpid_num));

   of = get_in_brackets(from);
   if (ast_strlen_zero(p->exten)) {
      t = uri2;
      if (!strncmp(t, "sip:", 4))
         t+= 4;
      ast_string_field_set(p, exten, t);
      t = strchr(p->exten, '@');
      if (t)
         *t = '\0';
      if (ast_strlen_zero(p->our_contact))
         build_contact(p);
   }
   /* save the URI part of the From header */
   ast_string_field_set(p, from, of);
   if (strncmp(of, "sip:", 4)) {
      ast_log(LOG_NOTICE, "From address missing 'sip:', using it anyway\n");
   } else
      of += 4;
   /* Get just the username part */
   if ((c = strchr(of, '@'))) {
      char *tmp;
      *c = '\0';
      if ((c = strchr(of, ':')))
         *c = '\0';
      tmp = ast_strdupa(of);
      /* We need to be able to handle auth-headers looking like
         <sip:8164444422;phone-context=+1@1.2.3.4:5060;user=phone;tag=SDadkoa01-gK0c3bdb43>
      */
      tmp = strsep(&tmp, ";");
      if (ast_is_shrinkable_phonenumber(tmp))
         ast_shrink_phone_number(tmp);
      ast_string_field_set(p, cid_num, tmp);
   }
   if (ast_strlen_zero(of))
      return AUTH_SUCCESSFUL;

   if (!authpeer) /* If we are looking for a peer, don't check the user objects (or realtime) */
      user = find_user(of, 1);

   /* Find user based on user name in the from header */
   if (user && ast_apply_ha(user->ha, sin)) {
      ast_copy_flags(&p->flags[0], &user->flags[0], SIP_FLAGS_TO_COPY);
      ast_copy_flags(&p->flags[1], &user->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
      /* copy channel vars */
      for (v = user->chanvars ; v ; v = v->next) {
         if ((tmpvar = ast_variable_new(v->name, v->value))) {
            tmpvar->next = p->chanvars; 
            p->chanvars = tmpvar;
         }
      }
      p->prefs = user->prefs;
      /* Set Frame packetization */
      if (p->rtp) {
         ast_rtp_codec_setpref(p->rtp, &p->prefs);
         p->autoframing = user->autoframing;
      }
      /* replace callerid if rpid found, and not restricted */
      if (!ast_strlen_zero(rpid_num) && ast_test_flag(&p->flags[0], SIP_TRUSTRPID)) {
         char *tmp;
         if (*calleridname)
            ast_string_field_set(p, cid_name, calleridname);
         tmp = ast_strdupa(rpid_num);
         if (ast_is_shrinkable_phonenumber(tmp))
            ast_shrink_phone_number(tmp);
         ast_string_field_set(p, cid_num, tmp);
      }
      
      do_setnat(p, ast_test_flag(&p->flags[0], SIP_NAT_ROUTE) );

      if (!(res = check_auth(p, req, user->name, user->secret, user->md5secret, sipmethod, uri2, reliable, ast_test_flag(req, SIP_PKT_IGNORE)))) {
         sip_cancel_destroy(p);
         ast_copy_flags(&p->flags[0], &user->flags[0], SIP_FLAGS_TO_COPY);
         ast_copy_flags(&p->flags[1], &user->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
         /* Copy SIP extensions profile from INVITE */
         if (p->sipoptions)
            user->sipoptions = p->sipoptions;

         /* If we have a call limit, set flag */
         if (user->call_limit)
            ast_set_flag(&p->flags[0], SIP_CALL_LIMIT);
         if (!ast_strlen_zero(user->context))
            ast_string_field_set(p, context, user->context);
         if (!ast_strlen_zero(user->cid_num) && !ast_strlen_zero(p->cid_num)) {
            char *tmp = ast_strdupa(user->cid_num);
            if (ast_is_shrinkable_phonenumber(tmp))
               ast_shrink_phone_number(tmp);
            ast_string_field_set(p, cid_num, tmp);
         }
         if (!ast_strlen_zero(user->cid_name) && !ast_strlen_zero(p->cid_num))
            ast_string_field_set(p, cid_name, user->cid_name);
         ast_string_field_set(p, username, user->name);
         ast_string_field_set(p, peername, user->name);
         ast_string_field_set(p, peersecret, user->secret);
         ast_string_field_set(p, peermd5secret, user->md5secret);
         ast_string_field_set(p, subscribecontext, user->subscribecontext);
         ast_string_field_set(p, accountcode, user->accountcode);
         ast_string_field_set(p, language, user->language);
         ast_string_field_set(p, mohsuggest, user->mohsuggest);
         ast_string_field_set(p, mohinterpret, user->mohinterpret);
         p->allowtransfer = user->allowtransfer;
         p->amaflags = user->amaflags;
         p->callgroup = user->callgroup;
         p->pickupgroup = user->pickupgroup;
         if (user->callingpres)  /* User callingpres setting will override RPID header */
            p->callingpres = user->callingpres;
         
         /* Set default codec settings for this call */
         p->capability = user->capability;      /* User codec choice */
         p->jointcapability = user->capability;    /* Our codecs */
         if (p->peercapability)           /* AND with peer's codecs */
            p->jointcapability &= p->peercapability;
         if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
             (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO))
            p->noncodeccapability |= AST_RTP_DTMF;
         else
            p->noncodeccapability &= ~AST_RTP_DTMF;
         p->jointnoncodeccapability = p->noncodeccapability;
         if (p->t38.peercapability)
            p->t38.jointcapability &= p->t38.peercapability;
         p->maxcallbitrate = user->maxcallbitrate;
         /* If we do not support video, remove video from call structure */
         if ((!ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT) || !(p->capability & AST_FORMAT_VIDEO_MASK)) && p->vrtp) {
            ast_rtp_destroy(p->vrtp);
            p->vrtp = NULL;
         }
      }
      if (user && debug)
         ast_verbose("Found user '%s'\n", user->name);
   } else {
      if (user) {
         if (!authpeer && debug)
            ast_verbose("Found user '%s', but fails host access\n", user->name);
         ASTOBJ_UNREF(user,sip_destroy_user);
      }
      user = NULL;
   }

   if (!user) {
      /* If we didn't find a user match, check for peers */
      if (sipmethod == SIP_SUBSCRIBE)
         /* For subscribes, match on peer name only */
         peer = find_peer(of, NULL, 1);
      else
         /* Look for peer based on the IP address we received data from */
         /* If peer is registered from this IP address or have this as a default
            IP address, this call is from the peer 
         */
         peer = find_peer(NULL, &p->recv, 1);

      if (peer) {
         /* Set Frame packetization */
         if (p->rtp) {
            ast_rtp_codec_setpref(p->rtp, &peer->prefs);
            p->autoframing = peer->autoframing;
         }
         if (debug)
            ast_verbose("Found peer '%s'\n", peer->name);

         /* Take the peer */
         ast_copy_flags(&p->flags[0], &peer->flags[0], SIP_FLAGS_TO_COPY);
         ast_copy_flags(&p->flags[1], &peer->flags[1], SIP_PAGE2_FLAGS_TO_COPY);

         /* Copy SIP extensions profile to peer */
         if (p->sipoptions)
            peer->sipoptions = p->sipoptions;

         /* replace callerid if rpid found, and not restricted */
         if (!ast_strlen_zero(rpid_num) && ast_test_flag(&p->flags[0], SIP_TRUSTRPID)) {
            char *tmp = ast_strdupa(rpid_num);
            if (*calleridname)
               ast_string_field_set(p, cid_name, calleridname);
            if (ast_is_shrinkable_phonenumber(tmp))
               ast_shrink_phone_number(tmp);
            ast_string_field_set(p, cid_num, tmp);
         }
         do_setnat(p, ast_test_flag(&p->flags[0], SIP_NAT_ROUTE));

         ast_string_field_set(p, peersecret, peer->secret);
         ast_string_field_set(p, peermd5secret, peer->md5secret);
         ast_string_field_set(p, subscribecontext, peer->subscribecontext);
         ast_string_field_set(p, mohinterpret, peer->mohinterpret);
         ast_string_field_set(p, mohsuggest, peer->mohsuggest);
         if (peer->callingpres)  /* Peer calling pres setting will override RPID */
            p->callingpres = peer->callingpres;
         if (peer->maxms && peer->lastms)
            p->timer_t1 = peer->lastms;
         if (ast_test_flag(&peer->flags[0], SIP_INSECURE_INVITE)) {
            /* Pretend there is no required authentication */
            ast_string_field_free(p, peersecret);
            ast_string_field_free(p, peermd5secret);
         }
         if (!(res = check_auth(p, req, peer->name, p->peersecret, p->peermd5secret, sipmethod, uri2, reliable, ast_test_flag(req, SIP_PKT_IGNORE)))) {
            ast_copy_flags(&p->flags[0], &peer->flags[0], SIP_FLAGS_TO_COPY);
            ast_copy_flags(&p->flags[1], &peer->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
            /* If we have a call limit, set flag */
            if (peer->call_limit)
               ast_set_flag(&p->flags[0], SIP_CALL_LIMIT);
            ast_string_field_set(p, peername, peer->name);
            ast_string_field_set(p, authname, peer->name);

            /* copy channel vars */
            for (v = peer->chanvars ; v ; v = v->next) {
               if ((tmpvar = ast_variable_new(v->name, v->value))) {
                  tmpvar->next = p->chanvars; 
                  p->chanvars = tmpvar;
               }
            }
            if (authpeer) {
               (*authpeer) = ASTOBJ_REF(peer);  /* Add a ref to the object here, to keep it in memory a bit longer if it is realtime */
            }

            if (!ast_strlen_zero(peer->username)) {
               ast_string_field_set(p, username, peer->username);
               /* Use the default username for authentication on outbound calls */
               /* XXX this takes the name from the caller... can we override ? */
               ast_string_field_set(p, authname, peer->username);
            }
            if (!ast_strlen_zero(peer->cid_num) && !ast_strlen_zero(p->cid_num)) {
               char *tmp = ast_strdupa(peer->cid_num);
               if (ast_is_shrinkable_phonenumber(tmp))
                  ast_shrink_phone_number(tmp);
               ast_string_field_set(p, cid_num, tmp);
            }
            if (!ast_strlen_zero(peer->cid_name) && !ast_strlen_zero(p->cid_name)) 
               ast_string_field_set(p, cid_name, peer->cid_name);
            ast_string_field_set(p, fullcontact, peer->fullcontact);
            if (!ast_strlen_zero(peer->context))
               ast_string_field_set(p, context, peer->context);
            ast_string_field_set(p, peersecret, peer->secret);
            ast_string_field_set(p, peermd5secret, peer->md5secret);
            ast_string_field_set(p, language, peer->language);
            ast_string_field_set(p, accountcode, peer->accountcode);
            p->amaflags = peer->amaflags;
            p->callgroup = peer->callgroup;
            p->pickupgroup = peer->pickupgroup;
            p->capability = peer->capability;
            p->prefs = peer->prefs;
            p->jointcapability = peer->capability;
            if (p->peercapability)
               p->jointcapability &= p->peercapability;
            p->maxcallbitrate = peer->maxcallbitrate;
            if ((!ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT) || !(p->capability & AST_FORMAT_VIDEO_MASK)) && p->vrtp) {
               ast_rtp_destroy(p->vrtp);
               p->vrtp = NULL;
            }
            if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
                (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO))
               p->noncodeccapability |= AST_RTP_DTMF;
            else
               p->noncodeccapability &= ~AST_RTP_DTMF;
            p->jointnoncodeccapability = p->noncodeccapability;
            if (p->t38.peercapability)
               p->t38.jointcapability &= p->t38.peercapability;
         }
         ASTOBJ_UNREF(peer, sip_destroy_peer);
      } else { 
         if (debug)
            ast_verbose("Found no matching peer or user for '%s:%d'\n", ast_inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));

         /* do we allow guests? */
         if (!global_allowguest) {
            if (global_alwaysauthreject)
               res = AUTH_FAKE_AUTH; /* reject with fake authorization request */
            else
               res = AUTH_SECRET_FAILED; /* we don't want any guests, authentication will fail */
         }
      }

   }

   if (user)
      ASTOBJ_UNREF(user, sip_destroy_user);
   return res;
}

static void check_via	(	struct sip_pvt *	p,
		struct sip_request *	req
	)			[static]

check Via: header for hostname, port and rport request/answer

Definition at line 8851 of file chan_sip.c.

References ahp, ast_gethostbyname(), ast_inet_ntoa(), ast_log(), ast_set_flag, ast_verbose(), sip_pvt::flags, get_header(), hp, LOG_WARNING, sip_pvt::sa, sip_debug_test_pvt(), sip_nat_mode(), SIP_NAT_ROUTE, sip_real_dst(), and STANDARD_SIP_PORT.

Referenced by handle_request_bye(), handle_request_cancel(), handle_request_invite(), handle_request_register(), and handle_request_subscribe().

{
   char via[256];
   char *c, *pt;
   struct hostent *hp;
   struct ast_hostent ahp;

   ast_copy_string(via, get_header(req, "Via"), sizeof(via));

   /* Work on the leftmost value of the topmost Via header */
   c = strchr(via, ',');
   if (c)
      *c = '\0';

   /* Check for rport */
   c = strstr(via, ";rport");
   if (c && (c[6] != '=')) /* rport query, not answer */
      ast_set_flag(&p->flags[0], SIP_NAT_ROUTE);

   c = strchr(via, ';');
   if (c) 
      *c = '\0';

   c = strchr(via, ' ');
   if (c) {
      *c = '\0';
      c = ast_skip_blanks(c+1);
      if (strcasecmp(via, "SIP/2.0/UDP")) {
         ast_log(LOG_WARNING, "Don't know how to respond via '%s'\n", via);
         return;
      }
      pt = strchr(c, ':');
      if (pt)
         *pt++ = '\0';  /* remember port pointer */
      hp = ast_gethostbyname(c, &ahp);
      if (!hp) {
         ast_log(LOG_WARNING, "'%s' is not a valid host\n", c);
         return;
      }
      memset(&p->sa, 0, sizeof(p->sa));
      p->sa.sin_family = AF_INET;
      memcpy(&p->sa.sin_addr, hp->h_addr, sizeof(p->sa.sin_addr));
      p->sa.sin_port = htons(pt ? atoi(pt) : STANDARD_SIP_PORT);

      if (sip_debug_test_pvt(p)) {
         const struct sockaddr_in *dst = sip_real_dst(p);
         ast_verbose("Sending to %s : %d (%s)\n", ast_inet_ntoa(dst->sin_addr), ntohs(dst->sin_port), sip_nat_mode(p));
      }
   }
}

static void cleanup_stale_contexts	(	char *	new,
		char *	old
	)			[static]

Destroy disused contexts between reloads Only used in reload_config so the code for regcontext doesn't get ugly.

Definition at line 9739 of file chan_sip.c.

References ast_context_destroy(), ast_context_find(), AST_MAX_CONTEXT, and strsep().

{
   char *oldcontext, *newcontext, *stalecontext, *stringp, newlist[AST_MAX_CONTEXT];

   while ((oldcontext = strsep(&old, "&"))) {
      stalecontext = '\0';
      ast_copy_string(newlist, new, sizeof(newlist));
      stringp = newlist;
      while ((newcontext = strsep(&stringp, "&"))) {
         if (strcmp(newcontext, oldcontext) == 0) {
            /* This is not the context you're looking for */
            stalecontext = '\0';
            break;
         } else if (strcmp(newcontext, oldcontext)) {
            stalecontext = oldcontext;
         }
         
      }
      if (stalecontext)
         ast_context_destroy(ast_context_find(stalecontext), "SIP");
   }
}

static int clear_realm_authentication

(

struct sip_auth *

authlist

)

[static]

Clear realm authentication list (at reload).

Definition at line 15739 of file chan_sip.c.

References free, and sip_auth::next.

Referenced by sip_destroy_peer(), sip_do_reload(), and unload_module().

{
   struct sip_auth *a = authlist;
   struct sip_auth *b;

   while (a) {
      b = a;
      a = a->next;
      free(b);
   }

   return 1;
}

static void clear_sip_domains

(

void

)

[static]

Clear our domain list (at reload).

Definition at line 15668 of file chan_sip.c.

References AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, and free.

Referenced by sip_do_reload(), and unload_module().

{
   struct domain *d;

   AST_LIST_LOCK(&domain_list);
   while ((d = AST_LIST_REMOVE_HEAD(&domain_list, list)))
      free(d);
   AST_LIST_UNLOCK(&domain_list);
}

static char * complete_sip_debug_peer	(	const char *	line,
		const char *	word,
		int	pos,
		int	state
	)			[static]

Support routine for 'sip debug peer' CLI.

Definition at line 10552 of file chan_sip.c.

References complete_sip_peer().

{
   if (pos == 3)
      return complete_sip_peer(word, state, 0);

   return NULL;
}

static char * complete_sip_peer	(	const char *	word,
		int	state,
		int	flags2
	)			[static]

Do completion on peer name.

Definition at line 10526 of file chan_sip.c.

References ast_strdup, ast_test_flag, ASTOBJ_CONTAINER_TRAVERSE, peerl, and result.

Referenced by complete_sip_debug_peer(), complete_sip_prune_realtime_peer(), complete_sip_show_peer(), and complete_sipnotify().

{
   char *result = NULL;
   int wordlen = strlen(word);
   int which = 0;

   ASTOBJ_CONTAINER_TRAVERSE(&peerl, !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;
}

static char * complete_sip_prune_realtime_peer	(	const char *	line,
		const char *	word,
		int	pos,
		int	state
	)			[static]

Support routine for 'sip prune realtime peer' CLI.

Definition at line 10620 of file chan_sip.c.

References complete_sip_peer(), and SIP_PAGE2_RTCACHEFRIENDS.

{
   if (pos == 4)
      return complete_sip_peer(word, state, SIP_PAGE2_RTCACHEFRIENDS);
   return NULL;
}

static char * complete_sip_prune_realtime_user	(	const char *	line,
		const char *	word,
		int	pos,
		int	state
	)			[static]

Support routine for 'sip prune realtime user' CLI.

Definition at line 10628 of file chan_sip.c.

References complete_sip_user(), and SIP_PAGE2_RTCACHEFRIENDS.

{
   if (pos == 4)
      return complete_sip_user(word, state, SIP_PAGE2_RTCACHEFRIENDS);

   return NULL;
}

static char * complete_sip_show_peer	(	const char *	line,
		const char *	word,
		int	pos,
		int	state
	)			[static]

Support routine for 'sip show peer' CLI.

Definition at line 10543 of file chan_sip.c.

References complete_sip_peer().

{
   if (pos == 3)
      return complete_sip_peer(word, state, 0);

   return NULL;
}

static char * complete_sip_show_user	(	const char *	line,
		const char *	word,
		int	pos,
		int	state
	)			[static]

Support routine for 'sip show user' CLI.

Definition at line 10581 of file chan_sip.c.

References complete_sip_user().

{
   if (pos == 3)
      return complete_sip_user(word, state, 0);

   return NULL;
}

static char * complete_sip_user	(	const char *	word,
		int	state,
		int	flags2
	)			[static]

Do completion on user name.

Definition at line 10561 of file chan_sip.c.

References ast_strdup, ast_test_flag, ASTOBJ_CONTAINER_TRAVERSE, result, and userl.

Referenced by complete_sip_prune_realtime_user(), and complete_sip_show_user().

{
   char *result = NULL;
   int wordlen = strlen(word);
   int which = 0;

   ASTOBJ_CONTAINER_TRAVERSE(&userl, !result, do {
      /* locking of the object is not required because only the name and flags are being compared */
      if (!strncasecmp(word, iterator->name, wordlen)) {
         if (flags2 && !ast_test_flag(&iterator->flags[1], flags2))
            continue;
         if (++which > state) {
            result = ast_strdup(iterator->name);
         }
      }
   } while(0) );
   return result;
}

static char * complete_sipch	(	const char *	line,
		const char *	word,
		int	pos,
		int	state
	)			[static]

Support routine for 'sip show channel' CLI.

Definition at line 10507 of file chan_sip.c.

References ast_mutex_lock(), ast_strdup, iflist, and sip_pvt::next.

{
   int which=0;
   struct sip_pvt *cur;
   char *c = NULL;
   int wordlen = strlen(word);

   ast_mutex_lock(&iflock);
   for (cur = iflist; cur; cur = cur->next) {
      if (!strncasecmp(word, cur->callid, wordlen) && ++which > state) {
         c = ast_strdup(cur->callid);
         break;
      }
   }
   ast_mutex_unlock(&iflock);
   return c;
}

static char * complete_sipnotify	(	const char *	line,
		const char *	word,
		int	pos,
		int	state
	)			[static]

Support routine for 'sip notify' CLI.

Definition at line 10590 of file chan_sip.c.

References ast_category_browse(), ast_strdup, complete_sip_peer(), and notify_types.

{
   char *c = NULL;

   if (pos == 2) {
      int which = 0;
      char *cat = NULL;
      int wordlen = strlen(word);

      /* do completion for notify type */

      if (!notify_types)
         return NULL;
      
      while ( (cat = ast_category_browse(notify_types, cat)) ) {
         if (!strncasecmp(word, cat, wordlen) && ++which > state) {
            c = ast_strdup(cat);
            break;
         }
      }
      return c;
   }

   if (pos > 2)
      return complete_sip_peer(word, state, 0);

   return NULL;
}

static int copy_all_header	(	struct sip_request *	req,
		const struct sip_request *	orig,
		const char *	field
	)			[static]

Copy all headers from one request to another.

Definition at line 5379 of file chan_sip.c.

References __get_header(), add_header(), and ast_strlen_zero().

Referenced by respprep().

{
   int start = 0;
   int copied = 0;
   for (;;) {
      const char *tmp = __get_header(orig, field, &start);

      if (ast_strlen_zero(tmp))
         break;
      /* Add what we're responding to */
      add_header(req, field, tmp);
      copied++;
   }
   return copied ? 0 : -1;
}

static int copy_header	(	struct sip_request *	req,
		const struct sip_request *	orig,
		const char *	field
	)			[static]

Copy one header field from one request to another.

Definition at line 5368 of file chan_sip.c.

References add_header(), ast_log(), ast_strlen_zero(), get_header(), and LOG_NOTICE.

Referenced by reqprep(), and respprep().

{
   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;
}

static void copy_request	(	struct sip_request *	dst,
		const struct sip_request *	src
	)			[static]

copy SIP request (mostly used to save request for responses)

Definition at line 6413 of file chan_sip.c.

References offset.

Referenced by handle_request_bye(), handle_request_invite(), handle_request_refer(), handle_request_register(), handle_request_subscribe(), initialize_initreq(), sip_park(), and sip_park_thread().

{
   long offset;
   int x;
   offset = ((void *)dst) - ((void *)src);
   /* First copy stuff */
   memcpy(dst, src, sizeof(*dst));
   /* 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;
   dst->rlPart1 += offset;
   dst->rlPart2 += offset;
}

static int copy_via_headers	(	struct sip_pvt *	p,
		struct sip_request *	req,
		const struct sip_request *	orig,
		const char *	field
	)			[static]

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 5401 of file chan_sip.c.

References __get_header(), add_header(), ast_inet_ntoa(), ast_log(), ast_strlen_zero(), ast_test_flag, sip_pvt::flags, LOG_NOTICE, sip_pvt::recv, SIP_NAT, SIP_NAT_ALWAYS, and SIP_NAT_RFC3581.

Referenced by respprep().

{
   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 */

         /* Check rport if NAT=yes or NAT=rfc3581 (which is the default setting)  */
         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 */
            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;
}

static int create_addr	(	struct sip_pvt *	dialog,
		const char *	opeer
	)			[static]

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 2699 of file chan_sip.c.

References ahp, ast_get_srv(), ast_gethostbyname(), ast_log(), ast_string_field_set, ASTOBJ_UNREF, create_addr_from_peer(), find_peer(), hp, LOG_WARNING, portno, sip_pvt::recv, sip_pvt::sa, sip_destroy_peer(), STANDARD_SIP_PORT, sip_pvt::timer_t1, and sip_peer::tohost.

{
   struct hostent *hp;
   struct ast_hostent ahp;
   struct sip_peer *p;
   char *port;
   int portno;
   char host[MAXHOSTNAMELEN], *hostn;
   char peer[256];

   ast_copy_string(peer, opeer, sizeof(peer));
   port = strchr(peer, ':');
   if (port)
      *port++ = '\0';
   dialog->sa.sin_family = AF_INET;
   dialog->timer_t1 = 500; /* Default SIP retransmission timer T1 (RFC 3261) */
   p = find_peer(peer, NULL, 1);

   if (p) {
      int res = create_addr_from_peer(dialog, p);
      ASTOBJ_UNREF(p, sip_destroy_peer);
      return res;
   }
   hostn = peer;
   portno = port ? atoi(port) : STANDARD_SIP_PORT;
   if (srvlookup) {
      char service[MAXHOSTNAMELEN];
      int tportno;
      int ret;

      snprintf(service, sizeof(service), "_sip._udp.%s", peer);
      ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service);
      if (ret > 0) {
         hostn = host;
         portno = tportno;
      }
   }
   hp = ast_gethostbyname(hostn, &ahp);
   if (!hp) {
      ast_log(LOG_WARNING, "No such host: %s\n", peer);
      return -1;
   }
   ast_string_field_set(dialog, tohost, peer);
   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;
}

static int create_addr_from_peer	(	struct sip_pvt *	r,
		struct sip_peer *	peer
	)			[static]

Create address structure from peer reference. return -1 on error, 0 on success.

Definition at line 2594 of file chan_sip.c.

References sip_peer::addr, sip_peer::allowtransfer, sip_pvt::allowtransfer, ast_copy_flags, AST_FORMAT_VIDEO_MASK, ast_inet_ntoa(), ast_log(), ast_rtp_codec_setpref(), ast_rtp_destroy(), AST_RTP_DTMF, ast_rtp_set_rtpholdtimeout(), ast_rtp_set_rtpkeepalive(), ast_rtp_set_rtptimeout(), ast_rtp_setdtmf(), ast_rtp_setdtmfcompensate(), ast_set_flag, ast_strdupa, ast_string_field_build, ast_string_field_set, ast_strlen_zero(), ast_test_flag, ast_udptl_destroy(), ast_udptl_get_error_correction_scheme(), sip_peer::autoframing, sip_pvt::autoframing, sip_peer::call_limit, sip_peer::callgroup, sip_pvt::callgroup, t38properties::capability, sip_peer::capability, sip_pvt::capability, sip_peer::context, context, sip_peer::defaddr, do_setnat(), sip_peer::flags, sip_pvt::flags, sip_peer::fromdomain, sip_peer::fromuser, sip_peer::fullcontact, global_t38_capability, sip_request::headers, sip_pvt::initreq, t38properties::jointcapability, sip_peer::lastms, LOG_DEBUG, sip_peer::maxcallbitrate, sip_pvt::maxcallbitrate, sip_peer::maxms, sip_pvt::maxtime, sip_peer::md5secret, sip_peer::mohinterpret, mohinterpret, sip_peer::mohsuggest, mohsuggest, sip_pvt::noncodeccapability, option_debug, sip_peer::pickupgroup, sip_pvt::pickupgroup, sip_peer::prefs, sip_pvt::prefs, sip_pvt::recv, sip_pvt::rtp, sip_peer::rtpholdtimeout, sip_peer::rtpkeepalive, sip_pvt::rtptimeout, sip_peer::rtptimeout, sip_pvt::sa, sip_peer::secret, SIP_CALL_LIMIT, SIP_DTMF, SIP_DTMF_AUTO, SIP_DTMF_RFC2833, SIP_FLAGS_TO_COPY, SIP_NAT, SIP_NAT_ROUTE, SIP_PAGE2_FLAGS_TO_COPY, SIP_PAGE2_RFC2833_COMPENSATE, SIP_PAGE2_T38SUPPORT, SIP_PAGE2_VIDEOSUPPORT, sip_pvt::t38, T38FAX_RATE_MANAGEMENT_TRANSFERED_TCF, T38FAX_UDP_EC_FEC, T38FAX_UDP_EC_NONE, T38FAX_UDP_EC_REDUNDANCY, sip_pvt::timer_t1, sip_peer::tohost, sip_pvt::udptl, UDPTL_ERROR_CORRECTION_FEC, UDPTL_ERROR_CORRECTION_NONE, UDPTL_ERROR_CORRECTION_REDUNDANCY, username, sip_peer::username, and sip_pvt::vrtp.

Referenced by create_addr(), and sip_send_mwi_to_peer().

{
   if ((peer->addr.sin_addr.s_addr || peer->defaddr.sin_addr.s_addr) &&
       (!peer->maxms || ((peer->lastms >= 0)  && (peer->lastms <= peer->maxms)))) {
      dialog->sa = (peer->addr.sin_addr.s_addr) ? peer->addr : peer->defaddr;
      dialog->recv = dialog->sa;
   } else 
      return -1;

   ast_copy_flags(&dialog->flags[0], &peer->flags[0], SIP_FLAGS_TO_COPY);
   ast_copy_flags(&dialog->flags[1], &peer->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
   dialog->capability = peer->capability;
   if ((!ast_test_flag(&dialog->flags[1], SIP_PAGE2_VIDEOSUPPORT) || !(dialog->capability & AST_FORMAT_VIDEO_MASK)) && dialog->vrtp) {
      ast_rtp_destroy(dialog->vrtp);
      dialog->vrtp = NULL;
   }
   dialog->prefs = peer->prefs;
   if (ast_test_flag(&dialog->flags[1], SIP_PAGE2_T38SUPPORT)) {
      dialog->t38.capability = global_t38_capability;
      if (dialog->udptl) {
         if (ast_udptl_get_error_correction_scheme(dialog->udptl) == UDPTL_ERROR_CORRECTION_FEC )
            dialog->t38.capability |= T38FAX_UDP_EC_FEC;
         else if (ast_udptl_get_error_correction_scheme(dialog->udptl) == UDPTL_ERROR_CORRECTION_REDUNDANCY )
            dialog->t38.capability |= T38FAX_UDP_EC_REDUNDANCY;
         else if (ast_udptl_get_error_correction_scheme(dialog->udptl) == UDPTL_ERROR_CORRECTION_NONE )
            dialog->t38.capability |= T38FAX_UDP_EC_NONE;
         dialog->t38.capability |= T38FAX_RATE_MANAGEMENT_TRANSFERED_TCF;
         if (option_debug > 1)
            ast_log(LOG_DEBUG,"Our T38 capability (%d)\n", dialog->t38.capability);
      }
      dialog->t38.jointcapability = dialog->t38.capability;
   } else if (dialog->udptl) {
      ast_udptl_destroy(dialog->udptl);
      dialog->udptl = NULL;
   }
   do_setnat(dialog, ast_test_flag(&dialog->flags[0], SIP_NAT) & SIP_NAT_ROUTE );

   if (dialog->rtp) {
      ast_rtp_setdtmf(dialog->rtp, ast_test_flag(&dialog->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833);
      ast_rtp_setdtmfcompensate(dialog->rtp, ast_test_flag(&dialog->flags[1], SIP_PAGE2_RFC2833_COMPENSATE));
      ast_rtp_set_rtptimeout(dialog->rtp, peer->rtptimeout);
      ast_rtp_set_rtpholdtimeout(dialog->rtp, peer->rtpholdtimeout);
      ast_rtp_set_rtpkeepalive(dialog->rtp, peer->rtpkeepalive);
      /* Set Frame packetization */
      ast_rtp_codec_setpref(dialog->rtp, &dialog->prefs);
      dialog->autoframing = peer->autoframing;
   }
   if (dialog->vrtp) {
      ast_rtp_setdtmf(dialog->vrtp, 0);
      ast_rtp_setdtmfcompensate(dialog->vrtp, 0);
      ast_rtp_set_rtptimeout(dialog->vrtp, peer->rtptimeout);
      ast_rtp_set_rtpholdtimeout(dialog->vrtp, peer->rtpholdtimeout);
      ast_rtp_set_rtpkeepalive(dialog->vrtp, peer->rtpkeepalive);
   }

   ast_string_field_set(dialog, peername, peer->username);
   ast_string_field_set(dialog, authname, peer->username);
   ast_string_field_set(dialog, username, peer->username);
   ast_string_field_set(dialog, peersecret, peer->secret);
   ast_string_field_set(dialog, peermd5secret, peer->md5secret);
   ast_string_field_set(dialog, mohsuggest, peer->mohsuggest);
   ast_string_field_set(dialog, mohinterpret, peer->mohinterpret);
   ast_string_field_set(dialog, tohost, peer->tohost);
   ast_string_field_set(dialog, fullcontact, peer->fullcontact);
   if (!dialog->initreq.headers && !ast_strlen_zero(peer->fromdomain)) {
      char *tmpcall;
      char *c;
      tmpcall = ast_strdupa(dialog->callid);
      c = strchr(tmpcall, '@');
      if (c) {
         *c = '\0';
         ast_string_field_build(dialog, callid, "%s@%s", tmpcall, peer->fromdomain);
      }
   }
   if (ast_strlen_zero(dialog->tohost))
      ast_string_field_set(dialog, tohost, ast_inet_ntoa(dialog->sa.sin_addr));
   if (!ast_strlen_zero(peer->fromdomain))
      ast_string_field_set(dialog, fromdomain, peer->fromdomain);
   if (!ast_strlen_zero(peer->fromuser))
      ast_string_field_set(dialog, fromuser, peer->fromuser);
   dialog->maxtime = peer->maxms;
   dialog->callgroup = peer->callgroup;
   dialog->pickupgroup = peer->pickupgroup;
   dialog->allowtransfer = peer->allowtransfer;
   /* Set timer T1 to RTT for this peer (if known by qualify=) */
   /* Minimum is settable or default to 100 ms */
   if (peer->maxms && peer->lastms)
      dialog->timer_t1 = peer->lastms < global_t1min ? global_t1min : peer->lastms;
   if ((ast_test_flag(&dialog->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
       (ast_test_flag(&dialog->flags[0], SIP_DTMF) == SIP_DTMF_AUTO))
      dialog->noncodeccapability |= AST_RTP_DTMF;
   else
      dialog->noncodeccapability &= ~AST_RTP_DTMF;
   ast_string_field_set(dialog, context, peer->context);
   dialog->rtptimeout = peer->rtptimeout;
   if (peer->call_limit)
      ast_set_flag(&dialog->flags[0], SIP_CALL_LIMIT);
   dialog->maxcallbitrate = peer->maxcallbitrate;
   
   return 0;
}

static void destroy_association

(

struct sip_peer *

peer

)

[static]

Remove registration data from realtime database or AST/DB when registration expires.

Definition at line 7567 of file chan_sip.c.

References ast_db_del(), ast_test_flag, ast_update_realtime(), sip_peer::flags, global_flags, SIP_PAGE2_IGNOREREGEXPIRE, and SIP_PAGE2_RT_FROMCONTACT.

Referenced by build_peer(), expire_register(), and parse_register_contact().

{
   if (!ast_test_flag(&global_flags[1], SIP_PAGE2_IGNOREREGEXPIRE)) {
      if (ast_test_flag(&peer->flags[1], SIP_PAGE2_RT_FROMCONTACT))
         ast_update_realtime("sippeers", "name", peer->name, "fullcontact", "", "ipaddr", "", "port", "", "regseconds", "0", "username", "", "regserver", "", NULL);
      else 
         ast_db_del("SIP/Registry", peer->name);
   }
}

static int determine_firstline_parts

(

struct sip_request *

req

)

[static]

Parse first line of incoming SIP request.

Definition at line 6455 of file chan_sip.c.

References ast_log(), sip_request::header, LOG_WARNING, sip_request::rlPart1, and sip_request::rlPart2.

Referenced by parse_request().

{
   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;
}

static void * do_monitor

(

void *

data

)

[static]

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 15024 of file chan_sip.c.

References __sip_destroy(), ast_channel_trylock, ast_channel_unlock, ast_io_add(), ast_io_change(), AST_IO_IN, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_rtp_get_bridged(), ast_rtp_get_peer(), ast_rtp_get_rtpholdtimeout(), ast_rtp_get_rtpkeepalive(), ast_rtp_get_rtptimeout(), ast_rtp_sendcng(), ast_rtp_set_rtpholdtimeout(), ast_rtp_set_rtptimeout(), AST_SOFTHANGUP_DEV, ast_softhangup_nolock(), AST_STATE_UP, ast_test_flag, ast_verbose(), FALSE, sip_pvt::flags, iflist, io, sip_pvt::lock, LOG_NOTICE, sip_pvt::next, option_verbose, sip_pvt::owner, sip_pvt::packets, sip_do_reload(), SIP_NEEDDESTROY, sipsock, sipsock_read(), t, and VERBOSE_PREFIX_1.

{
   int res;
   struct sip_pvt *sip;
   struct sip_peer *peer = NULL;
   time_t t;
   int fastrestart = FALSE;
   int lastpeernum = -1;
   int curpeernum;
   int reloading;

   /* Add an I/O event to our SIP UDP socket */
   if (sipsock > -1) 
      sipsock_read_id = ast_io_add(io, sipsock, sipsock_read, AST_IO_IN, NULL);
   
   /* From here on out, we die whenever asked */
   for(;;) {
      /* Check for a reload request */
      ast_mutex_lock(&sip_reload_lock);
      reloading = sip_reloading;
      sip_reloading = FALSE;
      ast_mutex_unlock(&sip_reload_lock);
      if (reloading) {
         if (option_verbose > 0)
            ast_verbose(VERBOSE_PREFIX_1 "Reloading SIP\n");
         sip_do_reload(sip_reloadreason);

         /* Change the I/O fd of our UDP socket */
         if (sipsock > -1)
            sipsock_read_id = ast_io_change(io, sipsock_read_id, sipsock, NULL, 0, NULL);
      }
      /* Check for interfaces needing to be killed */
      ast_mutex_lock(&iflock);
restartsearch:    
      t = 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 = iflist; !fastrestart && sip; sip = sip->next) {
         ast_mutex_lock(&sip->lock);
         /* Check RTP timeouts and kill calls if we have a timeout set and do not get RTP */
         if (sip->rtp && sip->owner &&
             (sip->owner->_state == AST_STATE_UP) &&
             !sip->redirip.sin_addr.s_addr) {
            if (sip->lastrtptx &&
                ast_rtp_get_rtpkeepalive(sip->rtp) &&
                (t > sip->lastrtptx + ast_rtp_get_rtpkeepalive(sip->rtp))) {
               /* Need to send an empty RTP packet */
               sip->lastrtptx = time(NULL);
               ast_rtp_sendcng(sip->rtp, 0);
            }
            if (sip->lastrtprx &&
               (ast_rtp_get_rtptimeout(sip->rtp) || ast_rtp_get_rtpholdtimeout(sip->rtp)) &&
                (t > sip->lastrtprx + ast_rtp_get_rtptimeout(sip->rtp))) {
               /* Might be a timeout now -- see if we're on hold */
               struct sockaddr_in sin;
               ast_rtp_get_peer(sip->rtp, &sin);
               if (sin.sin_addr.s_addr || 
                   (ast_rtp_get_rtpholdtimeout(sip->rtp) &&
                    (t > sip->lastrtprx + ast_rtp_get_rtpholdtimeout(sip->rtp)))) {
                  /* Needs a hangup */
                  if (ast_rtp_get_rtptimeout(sip->rtp)) {
                     while (sip->owner && ast_channel_trylock(sip->owner)) {
                        ast_mutex_unlock(&sip->lock);
                        usleep(1);
                        ast_mutex_lock(&sip->lock);
                     }
                     if (sip->owner) {
                        if (!(ast_rtp_get_bridged(sip->rtp))) {
                           ast_log(LOG_NOTICE,
                              "Disconnecting call '%s' for lack of RTP activity in %ld seconds\n",
                              sip->owner->name,
                              (long) (t - sip->lastrtprx));
                           /* Issue a softhangup */
                           ast_softhangup_nolock(sip->owner, AST_SOFTHANGUP_DEV);
                        } else
                           ast_log(LOG_NOTICE, "'%s' will not be disconnected in %ld seconds because it is directly bridged to another RTP stream\n", sip->owner->name, (long) (t - sip->lastrtprx));
                        ast_channel_unlock(sip->owner);
                        /* forget the timeouts for this call, since a hangup
                           has already been requested and we don't want to
                           repeatedly request hangups
                        */
                        ast_rtp_set_rtptimeout(sip->rtp, 0);
                        ast_rtp_set_rtpholdtimeout(sip->rtp, 0);
                        if (sip->vrtp) {
                           ast_rtp_set_rtptimeout(sip->vrtp, 0);
                           ast_rtp_set_rtpholdtimeout(sip->vrtp, 0);
                        }
                     }
                  }
               }
            }
         }
         /* 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) {
            ast_mutex_unlock(&sip->lock);
            __sip_destroy(sip, 1);
            goto restartsearch;
         }
         ast_mutex_unlock(&sip->lock);
      }
      ast_mutex_unlock(&iflock);

      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);
         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 peers - static and cached realtime peers */
      t = time(NULL);
      fastrestart = FALSE;
      curpeernum = 0;
      peer = NULL;
      /* Find next peer that needs mwi */
      ASTOBJ_CONTAINER_TRAVERSE(&peerl, !peer, do {
         if ((curpeernum > lastpeernum) && does_peer_need_mwi(iterator)) {
            fastrestart = TRUE;
            lastpeernum = curpeernum;
            peer = ASTOBJ_REF(iterator);
         };
         curpeernum++;
      } while (0)
      );
      /* Send MWI to the peer */
      if (peer) {
         ASTOBJ_WRLOCK(peer);
         sip_send_mwi_to_peer(peer);
         ASTOBJ_UNLOCK(peer);
         ASTOBJ_UNREF(peer,sip_destroy_peer);
      } else {
         /* Reset where we come from */
         lastpeernum = -1;
      }
      ast_mutex_unlock(&monlock);
   }
   /* Never reached */
   return NULL;
   
}

static int do_proxy_auth	(	struct sip_pvt *	p,
		struct sip_request *	req,
		char *	header,
		char *	respheader,
		int	sipmethod,
		int	init
	)			[static]

Add authentication on outbound SIP packet.

Definition at line 11088 of file chan_sip.c.

References ast_calloc, ast_log(), sip_invite_param::auth, sip_invite_param::authheader, sip_pvt::authtries, LOG_DEBUG, option_debug, sip_pvt::options, reply_digest(), SIP_INVITE, sip_methods, cfsip_methods::text, and transmit_invite().

Referenced by handle_response(), handle_response_invite(), and handle_response_refer().

{
   char digest[1024];

   if (!p->options && !(p->options = ast_calloc(1, sizeof(*p->options))))
      return -2;

   p->authtries++;
   if (option_debug > 1)
      ast_log(LOG_DEBUG, "Auth attempt %d on %s\n", p->authtries, sip_methods[sipmethod].text);
   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->options->auth = digest;
   p->options->authheader = respheader;
   return transmit_invite(p, sipmethod, sipmethod == SIP_INVITE, init); 
}

static int do_register_auth	(	struct sip_pvt *	p,
		struct sip_request *	req,
		char *	header,
		char *	respheader
	)			[static]

Authenticate for outbound registration.

Definition at line 11067 of file chan_sip.c.

References append_history, ast_test_flag, ast_verbose(), sip_pvt::authtries, sip_pvt::flags, reply_digest(), sip_debug_test_pvt(), SIP_NO_HISTORY, SIP_REGISTER, and transmit_register().

Referenced by handle_response_register().

{
   char digest[1024];
   p->authtries++;
   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); 
}

static void do_setnat	(	struct sip_pvt *	p,
		int	natflags
	)			[static]

Set nat mode on the various data sockets.

Definition at line 2570 of file chan_sip.c.

References ast_log(), ast_rtp_setnat(), ast_udptl_setnat(), LOG_DEBUG, option_debug, sip_pvt::rtp, sip_pvt::udptl, and sip_pvt::vrtp.

Referenced by check_user_full(), create_addr_from_peer(), sip_alloc(), and transmit_response_using_temp().

{
   const char *mode = natflags ? "On" : "Off";

   if (p->rtp) {
      if (option_debug)
         ast_log(LOG_DEBUG, "Setting NAT on RTP to %s\n", mode);
      ast_rtp_setnat(p->rtp, natflags);
   }
   if (p->vrtp) {
      if (option_debug)
         ast_log(LOG_DEBUG, "Setting NAT on VRTP to %s\n", mode);
      ast_rtp_setnat(p->vrtp, natflags);
   }
   if (p->udptl) {
      if (option_debug)
         ast_log(LOG_DEBUG, "Setting NAT on UDPTL to %s\n", mode);
      ast_udptl_setnat(p->udptl, natflags);
   }
}

static int does_peer_need_mwi

(

struct sip_peer *

peer

)

[static]

Check whether peer needs a new MWI notification check.

Definition at line 15003 of file chan_sip.c.

References ast_strlen_zero(), ast_test_flag, FALSE, sip_peer::flags, sip_peer::lastmsgcheck, sip_peer::mailbox, sip_peer::mwipvt, SIP_PAGE2_SUBSCRIBEMWIONLY, t, and TRUE.

{
   time_t t = time(NULL);

   if (ast_test_flag(&peer->flags[1], SIP_PAGE2_SUBSCRIBEMWIONLY) &&
       !peer->mwipvt) { /* We don't have a subscription */
      peer->lastmsgcheck = t; /* Reset timer */
      return FALSE;
   }

   if (!ast_strlen_zero(peer->mailbox) && (t - peer->lastmsgcheck) > global_mwitime)
      return TRUE;

   return FALSE;
}

static const char * domain_mode_to_text

(

const enum domain_mode

mode

)

[static]

Print domain mode to cli.

Definition at line 9928 of file chan_sip.c.

References SIP_DOMAIN_AUTO, and SIP_DOMAIN_CONFIG.

Referenced by sip_show_domains().

{
   switch (mode) {
   case SIP_DOMAIN_AUTO:
      return "[Automatic]";
   case SIP_DOMAIN_CONFIG:
      return "[Configured]";
   }

   return "";
}

static const char * dtmfmode2str

(

int

mode

)

const [static]

Convert DTMF mode to printable string.

Definition at line 9708 of file chan_sip.c.

References SIP_DTMF_AUTO, SIP_DTMF_INBAND, SIP_DTMF_INFO, and SIP_DTMF_RFC2833.

Referenced by _sip_show_peer(), sip_show_channel(), and sip_show_settings().

{
   switch (mode) {
   case SIP_DTMF_RFC2833:
      return "rfc2833";
   case SIP_DTMF_INFO:
      return "info";
   case SIP_DTMF_INBAND:
      return "inband";
   case SIP_DTMF_AUTO:
      return "auto";
   }
   return "<error>";
}

static int expire_register

(

void *

data

)

[static]

Expire registration of SIP peer.

Definition at line 7578 of file chan_sip.c.

References sip_peer::addr, ast_device_state_changed(), ast_test_flag, ASTOBJ_CONTAINER_UNLINK, ASTOBJ_UNREF, destroy_association(), EVENT_FLAG_SYSTEM, sip_peer::expire, FALSE, sip_peer::flags, manager_event(), peerl, register_peer_exten(), sip_destroy_peer(), SIP_PAGE2_RTAUTOCLEAR, and SIP_PAGE2_SELFDESTRUCT.

Referenced by parse_register_contact(), and reg_source_db().

{
   struct sip_peer *peer = data;
   
   if (!peer)     /* Hmmm. We have no peer. Weird. */
      return 0;

   memset(&peer->addr, 0, sizeof(peer->addr));

   destroy_association(peer); /* remove registration data from storage */
   
   manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "Peer: SIP/%s\r\nPeerStatus: Unregistered\r\nCause: Expired\r\n", peer->name);
   register_peer_exten(peer, FALSE);   /* Remove regexten */
   peer->expire = -1;
   ast_device_state_changed("SIP/%s", peer->name);

   /* Do we need to release this peer from memory? 
      Only for realtime peers and autocreated peers
   */
   if (ast_test_flag(&peer->flags[1], SIP_PAGE2_SELFDESTRUCT) ||
       ast_test_flag(&peer->flags[1], SIP_PAGE2_RTAUTOCLEAR)) {
      peer = ASTOBJ_CONTAINER_UNLINK(&peerl, peer);   /* Remove from peer list */
      ASTOBJ_UNREF(peer, sip_destroy_peer);     /* Remove from memory */
   }

   return 0;
}

static void extract_uri	(	struct sip_pvt *	p,
		struct sip_request *	req
	)			[static]

Check Contact: URI of SIP message.

Definition at line 6545 of file chan_sip.c.

References ast_string_field_set, ast_strlen_zero(), get_header(), get_in_brackets(), and strsep().

Referenced by handle_request(), and handle_request_invite().

{
   char stripped[BUFSIZ];
   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);
}

static const char * find_alias	(	const char *	name,
		const char *	_default
	)			[static]

Find compressed SIP alias.

Structure for conversion between compressed SIP and "normal" SIP

Definition at line 3969 of file chan_sip.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;
}

static struct sip_pvt * find_call	(	struct sip_request *	req,
		struct sockaddr_in *	sin,
		const int	intended_method
	)			[static]

Connect incoming SIP message to current dialog or create new dialog structure Called by handle_request, sipsock_read.

Definition at line 4328 of file chan_sip.c.

References ast_log(), ast_mutex_lock(), ast_set_flag, ast_strlen_zero(), FALSE, get_header(), gettag(), iflist, LOG_DEBUG, sip_request::method, sip_pvt::next, option_debug, SIP_PKT_WITH_TOTAG, SIP_REGISTER, SIP_RESPONSE, and sip_pvt::tag.

Referenced by sipsock_read().

{
   struct sip_pvt *p = NULL;
   char *tag = "";   /* note, tag is never NULL */
   char totag[128];
   char fromtag[128];
   const char *callid = get_header(req, "Call-ID");
   const char *from = get_header(req, "From");
   const char *to = get_header(req, "To");
   const char *cseq = get_header(req, "Cseq");

   /* Call-ID, to, from and Cseq are required by RFC 3261. (Max-forwards and via too - ignored now) */
   /* get_header always returns non-NULL so we must use ast_strlen_zero() */
   if (ast_strlen_zero(callid) || ast_strlen_zero(to) ||
         ast_strlen_zero(from) || ast_strlen_zero(cseq))
      return NULL;   /* Invalid packet */

   if (pedanticsipchecking) {
      /* In principle Call-ID's uniquely identify a call, but with a forking SIP proxy
         we need more to identify a branch - so we have to check branch, from
         and to tags to identify a call leg.
         For Asterisk to behave correctly, you need to turn on pedanticsipchecking
         in sip.conf
         */
      if (gettag(req, "To", totag, sizeof(totag)))
         ast_set_flag(req, SIP_PKT_WITH_TOTAG); /* Used in handle_request/response */
      gettag(req, "From", fromtag, sizeof(fromtag));

      tag = (req->method == SIP_RESPONSE) ? totag : fromtag;

      if (option_debug > 4 )
         ast_log(LOG_DEBUG, "= Looking for  Call ID: %s (Checking %s) --From tag %s --To-tag %s  \n", callid, req->method==SIP_RESPONSE ? "To" : "From", fromtag, totag);
   }

   ast_mutex_lock(&iflock);
   for (p = iflist; p; p = p->next) {
      /* In pedantic, we do not want packets with bad syntax to be connected to a PVT */
      int found = FALSE;
      if (ast_strlen_zero(p->callid))
         continue;
      if (req->method == SIP_REGISTER)
         found = (!strcmp(p->callid, callid));
      else 
         found = (!strcmp(p->callid, callid) && 
         (!pedanticsipchecking || !tag || ast_strlen_zero(p->theirtag) || !strcmp(p->theirtag, tag))) ;

      if (option_debug > 4)
         ast_log(LOG_DEBUG, "= %s Their Call ID: %s Their Tag %s Our tag: %s\n", found ? "Found" : "No match", p->callid, p->theirtag, p->tag);

      /* If we get a new request within an existing to-tag - check the to tag as well */
      if (pedanticsipchecking && found  && req->method != SIP_RESPONSE) {  /* SIP Request */
         if (p->tag[0] == '\0' && totag[0]) {
            /* We have no to tag, but they have. Wrong dialog */
            found = FALSE;
         } else if (totag[0]) {        /* Both have tags, compare them */
            if (strcmp(totag, p->tag)) {
               found = FALSE;    /* This is not our packet */
            }
         }
         if (!found && option_debug > 4)
            ast_log(LOG_DEBUG, "= Being pedantic: This is not our match on request: Call ID: %s Ourtag <null> Totag %s Method %s\n", p->callid, totag, sip_methods[req->method].text);
      }


      if (found) {
         /* Found the call */
         ast_mutex_unlock(&iflock);
         ast_mutex_lock(&p->lock);
         return p;
      }
   }
   ast_mutex_unlock(&iflock);

   /* See if the method is capable of creating a dialog */
   if (sip_methods[intended_method].can_create == CAN_CREATE_DIALOG) {
      if (intended_method == SIP_REFER) {
         /* We do support REFER, but not outside of a dialog yet */
         transmit_response_using_temp(callid, sin, 1, intended_method, req, "603 Declined (no dialog)");
      } else if (intended_method == SIP_NOTIFY) {
         /* We do not support out-of-dialog NOTIFY either,
            like voicemail notification, so cancel that early */
         transmit_response_using_temp(callid, sin, 1, intended_method, req, "489 Bad event");
      } else {
         /* Ok, time to create a new SIP dialog object, a pvt */
         if ((p = sip_alloc(callid, sin, 1, intended_method)))  {
            /* Ok, we've created a dialog, let's go and process it */
            ast_mutex_lock(&p->lock);
         } else {
            /* We have a memory or file/socket error (can't allocate RTP sockets or something) so we're not
               getting a dialog from sip_alloc. 
   
               Without a dialog we can't retransmit and handle ACKs and all that, but at least
               send an error message.
   
               Sorry, we apologize for the inconvienience
            */
            transmit_response_using_temp(callid, sin, 1, intended_method, req, "500 Server internal error");
            if (option_debug > 3)
               ast_log(LOG_DEBUG, "Failed allocating SIP dialog, sending 500 Server internal error and giving up\n");
         }
      }
      return p;
   } else if( sip_methods[intended_method].can_create == CAN_CREATE_DIALOG_UNSUPPORTED_METHOD) {
      /* A method we do not support, let's take it on the volley */
      transmit_response_using_temp(callid, sin, 1, intended_method, req, "501 Method Not Implemented");
   } else if (intended_method != SIP_RESPONSE && intended_method != SIP_ACK) {
      /* This is a request outside of a dialog that we don't know about 
         ...never reply to an ACK!
      */
      transmit_response_using_temp(callid, sin, 1, intended_method, req, "481 Call leg/transaction does not exist");
   }
   /* We do not respond to responses for dialogs that we don't know about, we just drop
      the session quickly */

   return p;
}

static const char* find_closing_quote	(	const char *	start,
		const char *	lim
	)			[static]

Locate closing quote in a string, skipping escaped quotes. optionally with a limit on the search. start must be past the first quote.

Definition at line 2211 of file chan_sip.c.

References s.

Referenced by get_in_brackets().

{
        char last_char = '\0';
        const char *s;
        for (s = start; *s && s != lim; last_char = *s++) {
                if (*s == '"' && last_char != '\\')
                        break;
        }
        return s;
}

static struct sip_peer * find_peer	(	const char *	peer,
		struct sockaddr_in *	sin,
		int	realtime
	)			[static]

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.

Definition at line 2482 of file chan_sip.c.

References ASTOBJ_CONTAINER_FIND, ASTOBJ_CONTAINER_FIND_FULL, name, peerl, realtime_peer(), and sip_addrcmp().

{
   struct sip_peer *p = NULL;

   if (peer)
      p = ASTOBJ_CONTAINER_FIND(&peerl, peer);
   else
      p = ASTOBJ_CONTAINER_FIND_FULL(&peerl, sin, name, sip_addr_hashfunc, 1, sip_addrcmp);

   if (!p && realtime)
      p = realtime_peer(peer, sin);

   return p;
}

static struct sip_auth * find_realm_authentication	(	struct sip_auth *	authlist,
		const char *	realm
	)			[static]

Find authentication for a specific realm.

Definition at line 15754 of file chan_sip.c.

References sip_auth::next, and sip_auth::realm.

Referenced by build_reply_digest().

{
   struct sip_auth *a;

   for (a = authlist; a; a = a->next) {
      if (!strcasecmp(a->realm, realm))
         break;
   }

   return a;
}

static int find_sdp

(

struct sip_request *

req

)

[static]

Determine whether a SIP message contains an SDP in its body.

Parameters:

req

the SIP request to process

Returns:

1 if SDP found, 0 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 4649 of file chan_sip.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.

Referenced by handle_request(), handle_request_invite(), handle_response(), and handle_response_invite().

{
   const char *content_type;
   const char *search;
   char *boundary;
   unsigned int x;
   int boundaryisquoted = FALSE;

   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 1;
   }

   /* if it's not multipart/mixed, there cannot be an SDP */
   if (strncasecmp(content_type, "multipart/mixed", 15))
      return 0;

   /* if there is no boundary marker, it's invalid */
   if (!(search = strcasestr(content_type, ";boundary=")))
      return 0;

   search += 10;
   if (ast_strlen_zero(search))
      return 0;

   /* If the boundary is quoted with ", remove quote */
   if (*search == '\"')  {
      search++;
      boundaryisquoted = TRUE;
   }

   /* make a duplicate of the string, with two extra characters
      at the beginning */
   boundary = ast_strdupa(search - 2);
   boundary[0] = boundary[1] = '-';

   /* Remove final quote */
   if (boundaryisquoted)
      boundary[strlen(boundary) - 1] = '\0';

   /* 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 1;
      }
   }

   return 0;
}

static int find_sip_method

(

const char *

msg

)

[static]

find_sip_method: Find SIP method from header

Definition at line 1655 of file chan_sip.c.

References ast_strlen_zero(), method_match(), and sip_methods.

Referenced by __sip_pretend_ack(), handle_response(), and sipsock_read().

{
   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;
}

static struct cfsubscription_types * find_subscription_type

(

enum subscriptiontype

subtype

)

[static]

Find subscription type in array.

Definition at line 10422 of file chan_sip.c.

References subscription_types, and type.

Referenced by transmit_state_notify().

{
   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];
}

static struct sip_user * find_user	(	const char *	name,
		int	realtime
	)			[static]

Locate user by name Locates user by name (From: sip uri user name part) first from in-memory list (static configuration) then from realtime storage (defined in extconfig.conf).

Definition at line 2561 of file chan_sip.c.

References ASTOBJ_CONTAINER_FIND, realtime_user(), and userl.

{
   struct sip_user *u = ASTOBJ_CONTAINER_FIND(&userl, name);
   if (!u && realtime)
      u = realtime_user(name);
   return u;
}

static void free_old_route

(

struct sip_route *

route

)

[static]

Remove route from route list.

Definition at line 7910 of file chan_sip.c.

References free, and sip_route::next.

Referenced by __sip_destroy(), and build_route().

{
   struct sip_route *next;

   while (route) {
      next = route->next;
      free(route);
      route = next;
   }
}

static int func_check_sipdomain	(	struct ast_channel *	chan,
		char *	cmd,
		char *	data,
		char *	buf,
		size_t	len
	)			[static]

Dial plan function to check if domain is local.

Definition at line 11414 of file chan_sip.c.

References ast_log(), ast_strlen_zero(), check_sip_domain(), and LOG_WARNING.

{
   if (ast_strlen_zero(data)) {
      ast_log(LOG_WARNING, "CHECKSIPDOMAIN requires an argument - A domain name\n");
      return -1;
   }
   if (check_sip_domain(data, NULL, 0))
      ast_copy_string(buf, data, len);
   else
      buf[0] = '\0';
   return 0;
}

static int func_header_read	(	struct ast_channel *	chan,
		char *	function,
		char *	data,
		char *	buf,
		size_t	len
	)			[static]

Read SIP header (dialplan function).

Definition at line 11350 of file chan_sip.c.

References __get_header(), AST_APP_ARG, ast_channel_lock, ast_channel_unlock, AST_DECLARE_APP_ARGS, ast_log(), AST_STANDARD_APP_ARGS, ast_strlen_zero(), sip_request::header, sip_pvt::initreq, LOG_WARNING, sip_tech, sip_tech_info, ast_channel::tech, and ast_channel::tech_pvt.

{
   struct sip_pvt *p;
   const char *content = NULL;
   AST_DECLARE_APP_ARGS(args,
      AST_APP_ARG(header);
      AST_APP_ARG(number);
   );
   int i, number, start = 0;

   if (ast_strlen_zero(data)) {
      ast_log(LOG_WARNING, "This function requires a header name.\n");
      return -1;
   }

   ast_channel_lock(chan);
   if (chan->tech != &sip_tech && chan->tech != &sip_tech_info) {
      ast_log(LOG_WARNING, "This function can only be used on SIP channels.\n");
      ast_channel_unlock(chan);
      return -1;
   }

   AST_STANDARD_APP_ARGS(args, data);
   if (!args.number) {
      number = 1;
   } else {
      sscanf(args.number, "%d", &number);
      if (number < 1)
         number = 1;
   }

   p = chan->tech_pvt;

   /* If there is no private structure, this channel is no longer alive */
   if (!p) {
      ast_channel_unlock(chan);
      return -1;
   }

   for (i = 0; i < number; i++)
      content = __get_header(&p->initreq, args.header, &start);

   if (ast_strlen_zero(content)) {
      ast_channel_unlock(chan);
      return -1;
   }

   ast_copy_string(buf, content, len);
   ast_channel_unlock(chan);

   return 0;
}

static int function_sipchaninfo_read	(	struct ast_channel *	chan,
		char *	cmd,
		char *	data,
		char *	buf,
		size_t	len
	)			[static]

${SIPCHANINFO()} Dialplan function - reads sip channel data

Definition at line 11529 of file chan_sip.c.

References ast_channel_lock, ast_channel_unlock, ast_inet_ntoa(), ast_log(), LOG_WARNING, sip_pvt::recv, sip_pvt::sa, sip_tech, sip_tech_info, t38properties::state, sip_pvt::t38, T38_DISABLED, ast_channel::tech, and ast_channel::tech_pvt.

{
   struct sip_pvt *p;

   *buf = 0;
   
   if (!data) {
      ast_log(LOG_WARNING, "This function requires a parameter name.\n");
      return -1;
   }

   ast_channel_lock(chan);
   if (chan->tech != &sip_tech && chan->tech != &sip_tech_info) {
      ast_log(LOG_WARNING, "This function can only be used on SIP channels.\n");
      ast_channel_unlock(chan);
      return -1;
   }

   p = chan->tech_pvt;

   /* If there is no private structure, this channel is no longer alive */
   if (!p) {
      ast_channel_unlock(chan);
      return -1;
   }

   if (!strcasecmp(data, "peerip")) {
      ast_copy_string(buf, p->sa.sin_addr.s_addr ? ast_inet_ntoa(p->sa.sin_addr) : "", len);
   } else  if (!strcasecmp(data, "recvip")) {
      ast_copy_string(buf, p->recv.sin_addr.s_addr ? ast_inet_ntoa(p->recv.sin_addr) : "", len);
   } else  if (!strcasecmp(data, "from")) {
      ast_copy_string(buf, p->from, len);
   } else  if (!strcasecmp(data, "uri")) {
      ast_copy_string(buf, p->uri, len);
   } else  if (!strcasecmp(data, "useragent")) {
      ast_copy_string(buf, p->useragent, len);
   } else  if (!strcasecmp(data, "peername")) {
      ast_copy_string(buf, p->peername, len);
   } else if (!strcasecmp(data, "t38passthrough")) {
      if (p->t38.state == T38_DISABLED)
         ast_copy_string(buf, "0", sizeof("0"));
      else    /* T38 is offered or enabled in this call */
         ast_copy_string(buf, "1", sizeof("1"));
   } else {
      ast_channel_unlock(chan);
      return -1;
   }
   ast_channel_unlock(chan);

   return 0;
}

static int function_sippeer	(	struct ast_channel *	chan,
		char *	cmd,
		char *	data,
		char *	buf,
		size_t	len
	)			[static]

${SIPPEER()} Dialplan function - reads peer data

Todo:

Will be deprecated after 1.4

Definition at line 11439 of file chan_sip.c.

References sip_peer::accountcode, sip_peer::addr, ast_codec_pref_index(), ast_getformatname(), ast_getformatname_multiple(), ast_inet_ntoa(), ast_test_flag, ASTOBJ_UNREF, sip_peer::call_limit, sip_peer::capability, sip_peer::cid_name, sip_peer::cid_num, sip_peer::context, sip_peer::expire, find_peer(), sip_peer::flags, sip_peer::inUse, sip_peer::language, sip_peer::mailbox, peer_status(), sip_peer::prefs, sip_peer::regexten, sip_destroy_peer(), SIP_PAGE2_DYNAMIC, strsep(), and sip_peer::useragent.

{
   struct sip_peer *peer;
   char *colname;

   if ((colname = strchr(data, ':')))  /*! \todo Will be deprecated after 1.4 */
      *colname++ = '\0';
   else if ((colname = strchr(data, '|')))
      *colname++ = '\0';
   else
      colname = "ip";

   if (!(peer = find_peer(data, NULL, 1)))
      return -1;

   if (!strcasecmp(colname, "ip")) {
      ast_copy_string(buf, peer->addr.sin_addr.s_addr ? ast_inet_ntoa(peer->addr.sin_addr) : "", len);
   } else  if (!strcasecmp(colname, "status")) {
      peer_status(peer, buf, len);
   } else  if (!strcasecmp(colname, "language")) {
      ast_copy_string(buf, peer->language, len);
   } else  if (!strcasecmp(colname, "regexten")) {
      ast_copy_string(buf, peer->regexten, len);
   } else  if (!strcasecmp(colname, "limit")) {
      snprintf(buf, len, "%d", peer->call_limit);
   } else  if (!strcasecmp(colname, "curcalls")) {
      snprintf(buf, len, "%d", peer->inUse);
   } else  if (!strcasecmp(colname, "accountcode")) {
      ast_copy_string(buf, peer->accountcode, len);
   } else  if (!strcasecmp(colname, "useragent")) {
      ast_copy_string(buf, peer->useragent, len);
   } else  if (!strcasecmp(colname, "mailbox")) {
      ast_copy_string(buf, peer->mailbox, len);
   } else  if (!strcasecmp(colname, "context")) {
      ast_copy_string(buf, peer->context, len);
   } else  if (!strcasecmp(colname, "expire")) {
      snprintf(buf, len, "%d", peer->expire);
   } else  if (!strcasecmp(colname, "dynamic")) {
      ast_copy_string(buf, (ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC) ? "yes" : "no"), len);
   } else  if (!strcasecmp(colname, "callerid_name")) {
      ast_copy_string(buf, peer->cid_name, len);
   } else  if (!strcasecmp(colname, "callerid_num")) {
      ast_copy_string(buf, peer->cid_num, len);
   } else  if (!strcasecmp(colname, "codecs")) {
      ast_getformatname_multiple(buf, len -1, peer->capability);
   } else  if (!strncasecmp(colname, "codec[", 6)) {
      char *codecnum;
      int index = 0, codec = 0;
      
      codecnum = colname + 6; /* move past the '[' */
      codecnum = strsep(&codecnum, "]"); /* trim trailing ']' if any */
      index = atoi(codecnum);
      if((codec = ast_codec_pref_index(&peer->prefs, index))) {
         ast_copy_string(buf, ast_getformatname(codec), len);
      }
   }

   ASTOBJ_UNREF(peer, sip_destroy_peer);

   return 0;
}

static char * generate_random_string	(	char *	buf,
		size_t	size
	)			[static]

Generate 32 byte random string for callid's etc.

Definition at line 4162 of file chan_sip.c.

References ast_random().

Referenced by build_callid_pvt(), and build_callid_registry().

{
   long val[4];
   int x;

   for (x=0; x<4; x++)
      val[x] = ast_random();
   snprintf(buf, size, "%08lx%08lx%08lx%08lx", val[0], val[1], val[2], val[3]);

   return buf;
}

static int get_also_info	(	struct sip_pvt *	p,
		struct sip_request *	oreq
	)			[static]

Call transfer support (old way, deprecated by the IETF)--.

Definition at line 8796 of file chan_sip.c.

References ast_canmatch_extension(), ast_exists_extension(), ast_log(), ast_string_field_set, ast_strlen_zero(), ast_uri_decode(), ast_verbose(), context, get_header(), get_in_brackets(), sip_pvt::initreq, LOG_DEBUG, LOG_WARNING, ast_channel::macrocontext, option_debug, sip_pvt::owner, pbx_builtin_getvar_helper(), sip_pvt::refer, sip_refer::refer_call, sip_refer::refer_contact, sip_refer::refer_to, sip_refer::refer_to_domain, sip_refer::referred_by, S_OR, and sip_debug_test_pvt().

Referenced by handle_request_bye().

{
   char tmp[256] = "", *c, *a;
   struct sip_request *req = oreq ? oreq : &p->initreq;
   struct sip_refer *referdata = p->refer;
   const char *transfer_context = NULL;
   
   ast_copy_string(tmp, get_header(req, "Also"), sizeof(tmp));
   c = get_in_brackets(tmp);

   if (pedanticsipchecking)
      ast_uri_decode(c);
   
   if (strncmp(c, "sip:", 4)) {
      ast_log(LOG_WARNING, "Huh?  Not a SIP header in Also: transfer (%s)?\n", c);
      return -1;
   }
   c += 4;
   if ((a = strchr(c, ';')))  /* Remove arguments */
      *a = '\0';
   
   if ((a = strchr(c, '@'))) {   /* Separate Domain */
      *a++ = '\0';
      ast_copy_string(referdata->refer_to_domain, a, sizeof(referdata->refer_to_domain));
   }
   
   if (sip_debug_test_pvt(p))
      ast_verbose("Looking for %s in %s\n", c, p->context);

   if (p->owner)  /* Mimic behaviour in res_features.c */
      transfer_context = pbx_builtin_getvar_helper(p->owner, "TRANSFER_CONTEXT");

   /* By default, use the context in the channel sending the REFER */
   if (ast_strlen_zero(transfer_context)) {
      transfer_context = S_OR(p->owner->macrocontext,
               S_OR(p->context, default_context));
   }
   if (ast_exists_extension(NULL, transfer_context, c, 1, NULL)) {
      /* This is a blind transfer */
      if (option_debug)
         ast_log(LOG_DEBUG,"SIP Bye-also transfer to Extension %s@%s \n", c, transfer_context);
      ast_copy_string(referdata->refer_to, c, sizeof(referdata->refer_to));
      ast_copy_string(referdata->referred_by, "", sizeof(referdata->referred_by));
      ast_copy_string(referdata->refer_contact, "", sizeof(referdata->refer_contact));
      referdata->refer_call = NULL;
      /* Set new context */
      ast_string_field_set(p, context, transfer_context);
      return 0;
   } else if (ast_canmatch_extension(NULL, p->context, c, 1, NULL)) {
      return 1;
   }

   return -1;
}

static char* get_body	(	struct sip_request *	req,
		char *	name
	)			[static]

Get a specific line from the message body.

Definition at line 3953 of file chan_sip.c.

References get_body_by_line(), len, sip_request::line, and sip_request::lines.

Referenced by handle_request_info().

{
   int x;
   int len = strlen(name);
   char *r;

   for (x = 0; x < req->lines; x++) {
      r = get_body_by_line(req->line[x], name, len);
      if (r[0] != '\0')
         return r;
   }

   return "";
}

static char* get_body_by_line	(	const char *	line,
		const char *	name,
		int	nameLen
	)			[static]

Reads one line of SIP message body.

Definition at line 3919 of file chan_sip.c.

Referenced by get_body(), and get_sdp_iterate().

{
   if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=')
      return ast_skip_blanks(line + nameLen + 1);

   return "";
}

static char * get_calleridname	(	const char *	input,
		char *	output,
		size_t	outputsize
	)			[static]

Get caller id name from SIP headers.

Definition at line 8903 of file chan_sip.c.

Referenced by check_user_full().

{
   const char *end = strchr(input,'<');   /* first_bracket */
   const char *tmp = strchr(input,'"');   /* first quote */
   int bytes = 0;
   int maxbytes = outputsize - 1;

   if (!end || end == input)  /* we require a part in brackets */
      return NULL;

   end--; /* move just before "<" */

   if (tmp && tmp <= end) {
      /* The quote (tmp) precedes the bracket (end+1).
       * Find the matching quote and return the content.
       */
      end = strchr(tmp+1, '"');
      if (!end)
         return NULL;
      bytes = (int) (end - tmp);
      /* protect the output buffer */
      if (bytes > maxbytes)
         bytes = maxbytes;
      ast_copy_string(output, tmp + 1, bytes);
   } else {
      /* No quoted string, or it is inside brackets. */
      /* clear the empty characters in the begining*/
      input = ast_skip_blanks(input);
      /* clear the empty characters in the end */
      while(*end && *end < 33 && end > input)
         end--;
      if (end >= input) {
         bytes = (int) (end - input) + 2;
         /* protect the output buffer */
         if (bytes > maxbytes)
            bytes = maxbytes;
         ast_copy_string(output, input, bytes);
      } else
         return NULL;
   }
   return output;
}

static int get_destination	(	struct sip_pvt *	p,
		struct sip_request *	oreq
	)			[static]

Find out who the call is for We use the INVITE uri to find out.

Definition at line 8470 of file chan_sip.c.

References ast_canmatch_extension(), ast_exists_extension(), AST_LIST_EMPTY, ast_log(), AST_MAX_EXTENSION, ast_pickup_ext(), ast_string_field_set, ast_strlen_zero(), ast_test_flag, ast_uri_decode(), ast_verbose(), check_sip_domain(), context, exten, get_header(), get_in_brackets(), global_flags, sip_pvt::initreq, LOG_DEBUG, LOG_WARNING, sip_request::method, option_debug, sip_request::rlPart2, sip_debug_test_pvt(), SIP_INVITE, sip_methods, SIP_PAGE2_ALLOWOVERLAP, SIP_REFER, strsep(), and cfsip_methods::text.

Referenced by handle_request_invite(), handle_request_options(), and handle_request_subscribe().

{
   char tmp[256] = "", *uri, *a;
   char tmpf[256] = "", *from;
   struct sip_request *req;
   char *colon;
   
   req = oreq;
   if (!req)
      req = &p->initreq;

   /* Find the request URI */
   if (req->rlPart2)
      ast_copy_string(tmp, req->rlPart2, sizeof(tmp));
   
   if (pedanticsipchecking)
      ast_uri_decode(tmp);

   uri = get_in_brackets(tmp);

   if (strncmp(uri, "sip:", 4)) {
      ast_log(LOG_WARNING, "Huh?  Not a SIP header (%s)?\n", uri);
      return -1;
   }
   uri += 4;

   /* Now find the From: caller ID and name */
   ast_copy_string(tmpf, get_header(req, "From"), sizeof(tmpf));
   if (!ast_strlen_zero(tmpf)) {
      if (pedanticsipchecking)
         ast_uri_decode(tmpf);
      from = get_in_brackets(tmpf);
   } else {
      from = NULL;
   }
   
   if (!ast_strlen_zero(from)) {
      if (strncmp(from, "sip:", 4)) {
         ast_log(LOG_WARNING, "Huh?  Not a SIP header (%s)?\n", from);
         return -1;
      }
      from += 4;
      if ((a = strchr(from, '@')))
         *a++ = '\0';
      else
         a = from;   /* just a domain */
      from = strsep(&from, ";"); /* Remove userinfo options */
      a = strsep(&a, ";");    /* Remove URI options */
      ast_string_field_set(p, fromdomain, a);
   }

   /* Skip any options and find the domain */

   /* Get the target domain */
   if ((a = strchr(uri, '@'))) {
      *a++ = '\0';
   } else { /* No username part */
      a = uri;
      uri = "s";  /* Set extension to "s" */
   }
   colon = strchr(a, ':'); /* Remove :port */
   if (colon)
      *colon = '\0';

   uri = strsep(&uri, ";");   /* Remove userinfo options */
   a = strsep(&a, ";");    /* Remove URI options */

   ast_string_field_set(p, domain, a);

   if (!AST_LIST_EMPTY(&domain_list)) {
      char domain_context[AST_MAX_EXTENSION];

      domain_context[0] = '\0';
      if (!check_sip_domain(p->domain, domain_context, sizeof(domain_context))) {
         if (!allow_external_domains && (req->method == SIP_INVITE || req->method == SIP_REFER)) {
            if (option_debug)
               ast_log(LOG_DEBUG, "Got SIP %s to non-local domain '%s'; refusing request.\n", sip_methods[req->method].text, p->domain);
            return -2;
         }
      }
      /* If we have a context defined, overwrite the original context */
      if (!ast_strlen_zero(domain_context))
         ast_string_field_set(p, context, domain_context);
   }

   if (sip_debug_test_pvt(p))
      ast_verbose("Looking for %s in %s (domain %s)\n", uri, p->context, p->domain);

   /* Check the dialplan for the username part of the request URI,
      the domain will be stored in the SIPDOMAIN variable
      Return 0 if we have a matching extension */
   if (ast_exists_extension(NULL, p->context, uri, 1, from) ||
      !strcmp(uri, ast_pickup_ext())) {
      if (!oreq)
         ast_string_field_set(p, exten, uri);
      return 0;
   }

   /* Return 1 for pickup extension or overlap dialling support (if we support it) */
   if((ast_test_flag(&global_flags[1], SIP_PAGE2_ALLOWOVERLAP) && 
       ast_canmatch_extension(NULL, p->context, uri, 1, from)) ||
       !strncmp(uri, ast_pickup_ext(), strlen(uri))) {
      return 1;
   }
   
   return -1;
}

static const char * get_header	(	const struct sip_request *	req,
		const char *	name
	)			[static]

Get header from SIP request.

Definition at line 4042 of file chan_sip.c.

References __get_header().

{
   int start = 0;
   return __get_header(req, name, &start);
}

static char * get_in_brackets

(

char *

tmp

)

[static]

Pick out text in brackets from character string.

Returns:

pointer to terminated stripped string

Parameters:

tmp

input string that will be modified Examples:

"foo" <bar> valid input, returns bar foo returns the whole string < "foo ... > returns the string between brackets < "foo... bogus (missing closing bracket), returns the whole string XXX maybe should still skip the opening bracket

Definition at line 2233 of file chan_sip.c.

References ast_log(), find_closing_quote(), LOG_WARNING, and parse().

Referenced by check_user_full(), extract_uri(), get_also_info(), get_destination(), get_rdnis(), get_refer_info(), parse_moved_contact(), parse_ok_contact(), parse_register_contact(), register_verify(), reqprep(), transmit_refer(), and transmit_state_notify().

{
   const char *parse = tmp;
   char *first_bracket;

   /*
    * Skip any quoted text until we find the part in brackets.
         * On any error give up and return the full string.
         */
        while ( (first_bracket = strchr(parse, '<')) ) {
                char *first_quote = strchr(parse, '"');

      if (!first_quote || first_quote > first_bracket)
         break; /* no need to look at quoted part */
      /* the bracket is within quotes, so ignore it */
      parse = find_closing_quote(first_quote + 1, NULL);
      if (!*parse) { /* not found, return full string ? */
         /* XXX or be robust and return in-bracket part ? */
         ast_log(LOG_WARNING, "No closing quote found in '%s'\n", tmp);
         break;
      }
      parse++;
   }
   if (first_bracket) {
      char *second_bracket = strchr(first_bracket + 1, '>');
      if (second_bracket) {
         *second_bracket = '\0';
         tmp = first_bracket + 1;
      } else {
         ast_log(LOG_WARNING, "No closing bracket found in '%s'\n", tmp);
      }
   }
   return tmp;
}

static int get_msg_text	(	char *	buf,
		int	len,
		struct sip_request *	req
	)			[static]

Get text out of a SIP MESSAGE packet.

Definition at line 9303 of file chan_sip.c.

References sip_request::line, and sip_request::lines.

Referenced by handle_request_notify(), and receive_message().

{
   int x;
   int y;

   buf[0] = '\0';
   y = len - strlen(buf) - 5;
   if (y < 0)
      y = 0;
   for (x=0;x<req->lines;x++) {
      strncat(buf, req->line[x], y); /* safe */
      y -= strlen(req->line[x]) + 1;
      if (y < 0)
         y = 0;
      if (y != 0)
         strcat(buf, "\n"); /* safe */
   }
   return 0;
}

static int get_rdnis	(	struct sip_pvt *	p,
		struct sip_request *	oreq
	)			[static]

Get referring dnis.

Definition at line 8441 of file chan_sip.c.

References ast_log(), ast_string_field_set, ast_strlen_zero(), ast_verbose(), get_header(), get_in_brackets(), sip_pvt::initreq, LOG_WARNING, sip_debug_test_pvt(), and strsep().

Referenced by handle_request_invite().

{
   char tmp[256], *c, *a;
   struct sip_request *req;
   
   req = oreq;
   if (!req)
      req = &p->initreq;
   ast_copy_string(tmp, get_header(req, "Diversion"), sizeof(tmp));
   if (ast_strlen_zero(tmp))
      return 0;
   c = get_in_brackets(tmp);
   if (strncmp(c, "sip:", 4)) {
      ast_log(LOG_WARNING, "Huh?  Not an RDNIS SIP header (%s)?\n", c);
      return -1;
   }
   c += 4;
   a = c;
   strsep(&a, "@;"); /* trim anything after @ or ; */
   if (sip_debug_test_pvt(p))
      ast_verbose("RDNIS is %s\n", c);
   ast_string_field_set(p, rdnis, c);

   return 0;
}

static int get_refer_info	(	struct sip_pvt *	transferer,
		struct sip_request *	outgoing_req
	)			[static]

Call transfer support (the REFER method) Extracts Refer headers into pvt dialog structure.

Definition at line 8635 of file chan_sip.c.

References ast_exists_extension(), ast_log(), ast_strdupa, ast_strlen_zero(), ast_uri_decode(), ast_verbose(), sip_refer::attendedtransfer, get_header(), get_in_brackets(), sip_pvt::initreq, LOG_DEBUG, LOG_WARNING, ast_channel::macrocontext, option_debug, sip_pvt::owner, pbx_builtin_getvar_helper(), sip_pvt::refer, sip_refer::refer_to, sip_refer::refer_to_context, sip_refer::refer_to_domain, sip_refer::refer_to_urioption, sip_refer::referred_by, sip_refer::referred_by_name, sip_refer::replaces_callid, sip_refer::replaces_callid_fromtag, sip_refer::replaces_callid_totag, S_OR, sip_debug_test_pvt(), and strcasestr().

Referenced by handle_request_refer().

{

   const char *p_referred_by = NULL;
   char *h_refer_to = NULL; 
   char *h_referred_by = NULL;
   char *refer_to;
   const char *p_refer_to;
   char *referred_by_uri = NULL;
   char *ptr;
   struct sip_request *req = NULL;
   const char *transfer_context = NULL;
   struct sip_refer *referdata;


   req = outgoing_req;
   referdata = transferer->refer;

   if (!req)
      req = &transferer->initreq;

   p_refer_to = get_header(req, "Refer-To");
   if (ast_strlen_zero(p_refer_to)) {
      ast_log(LOG_WARNING, "Refer-To Header missing. Skipping transfer.\n");
      return -2;  /* Syntax error */
   }
   h_refer_to = ast_strdupa(p_refer_to);
   refer_to = get_in_brackets(h_refer_to);
   if (pedanticsipchecking)
      ast_uri_decode(refer_to);

   if (strncasecmp(refer_to, "sip:", 4)) {
      ast_log(LOG_WARNING, "Can't transfer to non-sip: URI.  (Refer-to: %s)?\n", refer_to);
      return -3;
   }
   refer_to += 4;       /* Skip sip: */

   /* Get referred by header if it exists */
   p_referred_by = get_header(req, "Referred-By");
   if (!ast_strlen_zero(p_referred_by)) {
      char *lessthan;
      h_referred_by = ast_strdupa(p_referred_by);
      if (pedanticsipchecking)
         ast_uri_decode(h_referred_by);

      /* Store referrer's caller ID name */
      ast_copy_string(referdata->referred_by_name, h_referred_by, sizeof(referdata->referred_by_name));
      if ((lessthan = strchr(referdata->referred_by_name, '<'))) {
         *(lessthan - 1) = '\0'; /* Space */
      }

      referred_by_uri = get_in_brackets(h_referred_by);
      if(strncasecmp(referred_by_uri, "sip:", 4)) {
         ast_log(LOG_WARNING, "Huh?  Not a sip: header (Referred-by: %s). Skipping.\n", referred_by_uri);
         referred_by_uri = (char *) NULL;
      } else {
         referred_by_uri += 4;      /* Skip sip: */
      }
   }

   /* Check for arguments in the refer_to header */
   if ((ptr = strchr(refer_to, '?'))) { /* Search for arguments */
      *ptr++ = '\0';
      if (!strncasecmp(ptr, "REPLACES=", 9)) {
         char *to = NULL, *from = NULL;

         /* This is an attended transfer */
         referdata->attendedtransfer = 1;
         ast_copy_string(referdata->replaces_callid, ptr+9, sizeof(referdata->replaces_callid));
         ast_uri_decode(referdata->replaces_callid);
         if ((ptr = strchr(referdata->replaces_callid, ';')))  /* Find options */ {
            *ptr++ = '\0';
         }

         if (ptr) {
            /* Find the different tags before we destroy the string */
            to = strcasestr(ptr, "to-tag=");
            from = strcasestr(ptr, "from-tag=");
         }

         /* Grab the to header */
         if (to) {
            ptr = to + 7;
            if ((to = strchr(ptr, '&')))
               *to = '\0';
            if ((to = strchr(ptr, ';')))
               *to = '\0';
            ast_copy_string(referdata->replaces_callid_totag, ptr, sizeof(referdata->replaces_callid_totag));
         }

         if (from) {
            ptr = from + 9;
            if ((to = strchr(ptr, '&')))
               *to = '\0';
            if ((to = strchr(ptr, ';')))
               *to = '\0';
            ast_copy_string(referdata->replaces_callid_fromtag, ptr, sizeof(referdata->replaces_callid_fromtag));
         }

         if (option_debug > 1) {
            if (!pedanticsipchecking)
               ast_log(LOG_DEBUG,"Attended transfer: Will use Replace-Call-ID : %s (No check of from/to tags)\n", referdata->replaces_callid );
            else
               ast_log(LOG_DEBUG,"Attended transfer: Will use Replace-Call-ID : %s F-tag: %s T-tag: %s\n", referdata->replaces_callid, referdata->replaces_callid_fromtag ? referdata->replaces_callid_fromtag : "<none>", referdata->replaces_callid_totag ? referdata->replaces_callid_totag : "<none>" );
         }
      }
   }
   
   if ((ptr = strchr(refer_to, '@'))) {   /* Separate domain */
      char *urioption;

      *ptr++ = '\0';
      if ((urioption = strchr(ptr, ';')))
         *urioption++ = '\0';
      /* Save the domain for the dial plan */
      ast_copy_string(referdata->refer_to_domain, ptr, sizeof(referdata->refer_to_domain));
      if (urioption)
         ast_copy_string(referdata->refer_to_urioption, urioption, sizeof(referdata->refer_to_urioption));
   }

   if ((ptr = strchr(refer_to, ';')))  /* Remove options */
      *ptr = '\0';
   ast_copy_string(referdata->refer_to, refer_to, sizeof(referdata->refer_to));
   
   if (referred_by_uri) {
      if ((ptr = strchr(referred_by_uri, ';')))    /* Remove options */
         *ptr = '\0';
      ast_copy_string(referdata->referred_by, referred_by_uri, sizeof(referdata->referred_by));
   } else {
      referdata->referred_by[0] = '\0';
   }

   /* Determine transfer context */
   if (transferer->owner)  /* Mimic behaviour in res_features.c */
      transfer_context = pbx_builtin_getvar_helper(transferer->owner, "TRANSFER_CONTEXT");

   /* By default, use the context in the channel sending the REFER */
   if (ast_strlen_zero(transfer_context)) {
      transfer_context = S_OR(transferer->owner->macrocontext,
               S_OR(transferer->context, default_context));
   }

   ast_copy_string(referdata->refer_to_context, transfer_context, sizeof(referdata->refer_to_context));
   
   /* Either an existing extension or the parking extension */
   if (ast_exists_extension(NULL, transfer_context, refer_to, 1, NULL) ) {
      if (sip_debug_test_pvt(transferer)) {
         ast_verbose("SIP transfer to extension %s@%s by %s\n", refer_to, transfer_context, referred_by_uri);
      }
      /* We are ready to transfer to the extension */
      return 0;
   } 
   if (sip_debug_test_pvt(transferer))
      ast_verbose("Failed SIP Transfer to non-existing extension %s in context %s\n n", refer_to, transfer_context);

   /* Failure, we can't find this extension */
   return -1;
}

static int get_rpid_num	(	const char *	input,
		char *	output,
		int	maxlen
	)			[static]

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.

Definition at line 8950 of file chan_sip.c.

References AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED.

Referenced by check_user_full().

{
   char *start;
   char *end;

   start = strchr(input,':');
   if (!start) {
      output[0] = '\0';
      return 0;
   }
   start++;

   /* we found "number" */
   ast_copy_string(output,start,maxlen);
   output[maxlen-1] = '\0';

   end = strchr(output,'@');
   if (end)
      *end = '\0';
   else
      output[0] = '\0';
   if (strstr(input,"privacy=full") || strstr(input,"privacy=uri"))
      return AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED;

   return 0;
}

static const char * get_sdp	(	struct sip_request *	req,
		const char *	name
	)			[static]

Get a line from an SDP message body.

Definition at line 3945 of file chan_sip.c.

References get_sdp_iterate().

{
   int dummy = 0;

   return get_sdp_iterate(&dummy, req, name);
}

static const char * get_sdp_iterate	(	int *	start,
		struct sip_request *	req,
		const char *	name
	)			[static]

Lookup 'name' in the SDP starting at the 'start' line. Returns the matching line, and 'start' is updated with the next line number.

Definition at line 3931 of file chan_sip.c.

References get_body_by_line(), len, and sip_request::line.

{
   int len = strlen(name);

   while (*start < req->sdp_end) {
      const char *r = get_body_by_line(req->line[(*start)++], name, len);
      if (r[0] != '\0')
         return r;
   }

   return "";
}

static struct sip_pvt * get_sip_pvt_byid_locked	(	const char *	callid,
		const char *	totag,
		const char *	fromtag
	)			[static]

Lock interface 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.

Definition at line 8583 of file chan_sip.c.

References ast_channel_trylock, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_test_flag, sip_pvt::flags, iflist, sip_pvt::lock, LOG_DEBUG, match(), sip_pvt::next, option_debug, sip_pvt::owner, SIP_OUTGOING, and sip_pvt::tag.

Referenced by handle_request_invite(), and local_attended_transfer().

{
   struct sip_pvt *sip_pvt_ptr;

   ast_mutex_lock(&iflock);

   if (option_debug > 3 && totag)
      ast_log(LOG_DEBUG, "Looking for callid %s (fromtag %s totag %s)\n", callid, fromtag ? fromtag : "<no fromtag>", totag ? totag : "<no totag>");

   /* Search interfaces and find the match */
   for (sip_pvt_ptr = iflist; sip_pvt_ptr; sip_pvt_ptr = sip_pvt_ptr->next) {
      if (!strcmp(sip_pvt_ptr->callid, callid)) {
         int match = 1;
         char *ourtag = sip_pvt_ptr->tag;

         /* Go ahead and lock it (and its owner) before returning */
         ast_mutex_lock(&sip_pvt_ptr->lock);

         /* Check if tags match. If not, this is not the call we want
            (With a forking SIP proxy, several call legs share the
            call id, but have different tags)
         */
         if (pedanticsipchecking && (strcmp(fromtag, sip_pvt_ptr->theirtag) || strcmp(totag, ourtag)))
            match = 0;

         if (!match) {
            ast_mutex_unlock(&sip_pvt_ptr->lock);
            continue;
         }

         if (option_debug > 3 && totag)             
            ast_log(LOG_DEBUG, "Matched %s call - their tag is %s Our tag is %s\n",
               ast_test_flag(&sip_pvt_ptr->flags[0], SIP_OUTGOING) ? "OUTGOING": "INCOMING",
               sip_pvt_ptr->theirtag, sip_pvt_ptr->tag);

         /* deadlock avoidance... */
         while (sip_pvt_ptr->owner && ast_channel_trylock(sip_pvt_ptr->owner)) {
            ast_mutex_unlock(&sip_pvt_ptr->lock);
            usleep(1);
            ast_mutex_lock(&sip_pvt_ptr->lock);
         }
         break;
      }
   }
   ast_mutex_unlock(&iflock);
   if (option_debug > 3 && !sip_pvt_ptr)
      ast_log(LOG_DEBUG, "Found no match for callid %s to-tag %s from-tag %s\n", callid, totag, fromtag);
   return sip_pvt_ptr;
}

static const char * gettag	(	const struct sip_request *	req,
		const char *	header,
		char *	tagbuf,
		int	tagbufsize
	)			[static]

Get tag from packet.

Returns:

Returns the pointer to the provided tag buffer, or NULL if the tag was not found.

Definition at line 12847 of file chan_sip.c.

References get_header(), strcasestr(), and strsep().

Referenced by find_call(), handle_request(), and handle_response().

{
   const char *thetag;

   if (!tagbuf)
      return NULL;
   tagbuf[0] = '\0';    /* reset the buffer */
   thetag = get_header(req, header);
   thetag = strcasestr(thetag, ";tag=");
   if (thetag) {
      thetag += 5;
      ast_copy_string(tagbuf, thetag, tagbufsize);
      return strsep(&tagbuf, ";");
   }
   return NULL;
}

static int handle_common_options	(	struct ast_flags *	flags,
		struct ast_flags *	mask,
		struct ast_variable *	v
	)			[static]

Handle flag-type options common to configuration of devices - users and peers.

Parameters:

	flags	array of two struct ast_flags
	mask	array of two struct ast_flags
	v	linked list of config variables to process

Returns:

non-zero if any config options were handled, zero otherwise

Definition at line 15476 of file chan_sip.c.

References ast_clear_flag, ast_false(), ast_log(), ast_set2_flag, ast_set_flag, ast_true(), ast_variable::lineno, LOG_WARNING, ast_variable::name, SIP_CAN_REINVITE, SIP_CAN_REINVITE_NAT, SIP_DTMF, SIP_DTMF_AUTO, SIP_DTMF_INBAND, SIP_DTMF_INFO, SIP_DTMF_RFC2833, SIP_G726_NONSTANDARD, SIP_INSECURE_INVITE, SIP_INSECURE_PORT, SIP_NAT, SIP_NAT_ALWAYS, SIP_NAT_NEVER, SIP_NAT_RFC3581, SIP_NAT_ROUTE, SIP_PAGE2_ALLOWOVERLAP, SIP_PAGE2_ALLOWSUBSCRIBE, SIP_PAGE2_BUGGY_MWI, SIP_PAGE2_RFC2833_COMPENSATE, SIP_PAGE2_T38SUPPORT_RTP, SIP_PAGE2_T38SUPPORT_TCP, SIP_PAGE2_T38SUPPORT_UDPTL, SIP_PAGE2_VIDEOSUPPORT, SIP_PROG_INBAND, SIP_PROG_INBAND_NO, SIP_PROG_INBAND_YES, SIP_PROMISCREDIR, SIP_REINVITE, SIP_REINVITE_UPDATE, SIP_SENDRPID, SIP_TRUSTRPID, SIP_USECLIENTCODE, strsep(), and ast_variable::value.

Referenced by build_peer(), build_user(), and reload_config().

{
   int res = 1;
   static int dep_insecure_very = 0;
   static int dep_insecure_yes = 0;

   if (!strcasecmp(v->name, "trustrpid")) {
      ast_set_flag(&mask[0], SIP_TRUSTRPID);
      ast_set2_flag(&flags[0], ast_true(v->value), SIP_TRUSTRPID);
   } else if (!strcasecmp(v->name, "sendrpid")) {
      ast_set_flag(&mask[0], SIP_SENDRPID);
      ast_set2_flag(&flags[0], ast_true(v->value), SIP_SENDRPID);
   } else if (!strcasecmp(v->name, "g726nonstandard")) {
      ast_set_flag(&mask[0], SIP_G726_NONSTANDARD);
      ast_set2_flag(&flags[0], ast_true(v->value), SIP_G726_NONSTANDARD);
   } else if (!strcasecmp(v->name, "useclientcode")) {
      ast_set_flag(&mask[0], SIP_USECLIENTCODE);
      ast_set2_flag(&flags[0], ast_true(v->value), SIP_USECLIENTCODE);
   } else if (!strcasecmp(v->name, "dtmfmode")) {
      ast_set_flag(&mask[0], SIP_DTMF);
      ast_clear_flag(&flags[0], SIP_DTMF);
      if (!strcasecmp(v->value, "inband"))
         ast_set_flag(&flags[0], SIP_DTMF_INBAND);
      else if (!strcasecmp(v->value, "rfc2833"))
         ast_set_flag(&flags[0], SIP_DTMF_RFC2833);
      else if (!strcasecmp(v->value, "info"))
         ast_set_flag(&flags[0], SIP_DTMF_INFO);
      else if (!strcasecmp(v->value, "auto"))
         ast_set_flag(&flags[0], SIP_DTMF_AUTO);
      else {
         ast_log(LOG_WARNING, "Unknown dtmf mode '%s' on line %d, using rfc2833\n", v->value, v->lineno);
         ast_set_flag(&flags[0], SIP_DTMF_RFC2833);
      }
   } else if (!strcasecmp(v->name, "nat")) {
      ast_set_flag(&mask[0], SIP_NAT);
      ast_clear_flag(&flags[0], SIP_NAT);
      if (!strcasecmp(v->value, "never"))
         ast_set_flag(&flags[0], SIP_NAT_NEVER);
      else if (!strcasecmp(v->value, "route"))
         ast_set_flag(&flags[0], SIP_NAT_ROUTE);
      else if (ast_true(v->value))
         ast_set_flag(&flags[0], SIP_NAT_ALWAYS);
      else
         ast_set_flag(&flags[0], SIP_NAT_RFC3581);
   } else if (!strcasecmp(v->name, "canreinvite")) {
      ast_set_flag(&mask[0], SIP_REINVITE);
      ast_clear_flag(&flags[0], SIP_REINVITE);
      if (ast_true(v->value)) {
         ast_set_flag(&flags[0], SIP_CAN_REINVITE | SIP_CAN_REINVITE_NAT);
      } else if (!ast_false(v->value)) {
         char buf[64];
         char *word, *next = buf;

         ast_copy_string(buf, v->value, sizeof(buf));
         while ((word = strsep(&next, ","))) {
            if (!strcasecmp(word, "update")) {
               ast_set_flag(&flags[0], SIP_REINVITE_UPDATE | SIP_CAN_REINVITE);
            } else if (!strcasecmp(word, "nonat")) {
               ast_set_flag(&flags[0], SIP_CAN_REINVITE);
               ast_clear_flag(&flags[0], SIP_CAN_REINVITE_NAT);
            } else {
               ast_log(LOG_WARNING, "Unknown canreinvite mode '%s' on line %d\n", v->value, v->lineno);
            }
         }
      }
   } else if (!strcasecmp(v->name, "insecure")) {
      ast_set_flag(&mask[0], SIP_INSECURE_PORT | SIP_INSECURE_INVITE);
      ast_clear_flag(&flags[0], SIP_INSECURE_PORT | SIP_INSECURE_INVITE);
      if (!strcasecmp(v->value, "very")) {
         ast_set_flag(&flags[0], SIP_INSECURE_PORT | SIP_INSECURE_INVITE);
         if (!dep_insecure_very) {
            ast_log(LOG_WARNING, "insecure=very at line %d is deprecated; use insecure=port,invite instead\n", v->lineno);
            dep_insecure_very = 1;
         }
      }
      else if (ast_true(v->value)) {
         ast_set_flag(&flags[0], SIP_INSECURE_PORT);
         if (!dep_insecure_yes) {
            ast_log(LOG_WARNING, "insecure=%s at line %d is deprecated; use insecure=port instead\n", v->value, v->lineno);
            dep_insecure_yes = 1;
         }
      }
      else if (!ast_false(v->value)) {
         char buf[64];
         char *word, *next;

         ast_copy_string(buf, v->value, sizeof(buf));
         next = buf;
         while ((word = strsep(&next, ","))) {
            if (!strcasecmp(word, "port"))
               ast_set_flag(&flags[0], SIP_INSECURE_PORT);
            else if (!strcasecmp(word, "invite"))
               ast_set_flag(&flags[0], SIP_INSECURE_INVITE);
            else
               ast_log(LOG_WARNING, "Unknown insecure mode '%s' on line %d\n", v->value, v->lineno);
         }
      }
   } else if (!strcasecmp(v->name, "progressinband")) {
      ast_set_flag(&mask[0], SIP_PROG_INBAND);
      ast_clear_flag(&flags[0], SIP_PROG_INBAND);
      if (ast_true(v->value))
         ast_set_flag(&flags[0], SIP_PROG_INBAND_YES);
      else if (strcasecmp(v->value, "never"))
         ast_set_flag(&flags[0], SIP_PROG_INBAND_NO);
   } else if (!strcasecmp(v->name, "promiscredir")) {
      ast_set_flag(&mask[0], SIP_PROMISCREDIR);
      ast_set2_flag(&flags[0], ast_true(v->value), SIP_PROMISCREDIR);
   } else if (!strcasecmp(v->name, "videosupport")) {
      ast_set_flag(&mask[1], SIP_PAGE2_VIDEOSUPPORT);
      ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_VIDEOSUPPORT);
   } else if (!strcasecmp(v->name, "allowoverlap")) {
      ast_set_flag(&mask[1], SIP_PAGE2_ALLOWOVERLAP);
      ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_ALLOWOVERLAP);
   } else if (!strcasecmp(v->name, "allowsubscribe")) {
      ast_set_flag(&mask[1], SIP_PAGE2_ALLOWSUBSCRIBE);
      ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_ALLOWSUBSCRIBE);
   } else if (!strcasecmp(v->name, "t38pt_udptl")) {
      ast_set_flag(&mask[1], SIP_PAGE2_T38SUPPORT_UDPTL);
      ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_T38SUPPORT_UDPTL);
#ifdef WHEN_WE_HAVE_T38_FOR_OTHER_TRANSPORTS
   } else if (!strcasecmp(v->name, "t38pt_rtp")) {
      ast_set_flag(&mask[1], SIP_PAGE2_T38SUPPORT_RTP);
      ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_T38SUPPORT_RTP);
   } else if (!strcasecmp(v->name, "t38pt_tcp")) {
      ast_set_flag(&mask[1], SIP_PAGE2_T38SUPPORT_TCP);
      ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_T38SUPPORT_TCP);
#endif
   } else if (!strcasecmp(v->name, "rfc2833compensate")) {
      ast_set_flag(&mask[1], SIP_PAGE2_RFC2833_COMPENSATE);
      ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_RFC2833_COMPENSATE);
   } else if (!strcasecmp(v->name, "buggymwi")) {
      ast_set_flag(&mask[1], SIP_PAGE2_BUGGY_MWI);
      ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_BUGGY_MWI);
   } else
      res = 0;

   return res;
}

static int handle_invite_replaces	(	struct sip_pvt *	p,
		struct sip_request *	req,
		int	debug,
		int	ignore,
		int	seqno,
		struct sockaddr_in *	sin
	)			[static]

Handle the transfer part of INVITE with a replaces: header, meaning a target pickup or an attended transfer.

Definition at line 13020 of file chan_sip.c.

References ast_channel::_state, append_history, ast_bridged_channel(), AST_CAUSE_SWITCH_CONGESTION, ast_channel_masquerade(), ast_channel_unlock, ast_frfree(), ast_hangup(), ast_log(), ast_mutex_unlock(), ast_quiet_chan(), ast_read(), ast_set_flag, ast_setstate(), ast_state2str(), AST_STATE_DOWN, AST_STATE_RING, AST_STATE_RINGING, AST_STATE_UP, DEFAULT_TRANS_TIMEOUT, f, sip_pvt::flags, ast_channel::hangupcause, sip_pvt::lock, LOG_DEBUG, LOG_ERROR, LOG_NOTICE, LOG_WARNING, option_debug, sip_pvt::owner, sip_pvt::refer, sip_refer::refer_call, SIP_DEFER_BYE_ON_TRANSFER, sip_scheddestroy(), ast_channel::tech_pvt, transmit_response(), transmit_response_reliable(), transmit_response_with_sdp(), and XMIT_RELIABLE.

Referenced by handle_request_invite().

{
   struct ast_frame *f;
   int earlyreplace = 0;
   int oneleggedreplace = 0;     /* Call with no bridge, propably IVR or voice message */
   struct ast_channel *c = p->owner;   /* Our incoming call */
   struct ast_channel *replacecall = p->refer->refer_call->owner; /* The channel we're about to take over */
   struct ast_channel *targetcall;     /* The bridge to the take-over target */

   /* Check if we're in ring state */
   if (replacecall->_state == AST_STATE_RING)
      earlyreplace = 1;

   /* Check if we have a bridge */
   if (!(targetcall = ast_bridged_channel(replacecall))) {
      /* We have no bridge */
      if (!earlyreplace) {
         if (option_debug > 1)
            ast_log(LOG_DEBUG, " Attended transfer attempted to replace call with no bridge (maybe ringing). Channel %s!\n", replacecall->name);
         oneleggedreplace = 1;
      }
   } 
   if (option_debug > 3 && targetcall && targetcall->_state == AST_STATE_RINGING)
         ast_log(LOG_DEBUG, "SIP transfer: Target channel is in ringing state\n");

   if (option_debug > 3) {
      if (targetcall) 
         ast_log(LOG_DEBUG, "SIP transfer: Invite Replace incoming channel should bridge to channel %s while hanging up channel %s\n", targetcall->name, replacecall->name); 
      else
         ast_log(LOG_DEBUG, "SIP transfer: Invite Replace incoming channel should replace and hang up channel %s (one call leg)\n", replacecall->name); 
   }

   if (ignore) {
      ast_log(LOG_NOTICE, "Ignoring this INVITE with replaces in a stupid way.\n");
      /* We should answer something here. If we are here, the
         call we are replacing exists, so an accepted 
         can't harm */
      transmit_response_with_sdp(p, "200 OK", req, XMIT_RELIABLE);
      /* Do something more clever here */
      ast_channel_unlock(c);
      ast_mutex_unlock(&p->refer->refer_call->lock);
      return 1;
   } 
   if (!c) {
      /* What to do if no channel ??? */
      ast_log(LOG_ERROR, "Unable to create new channel.  Invite/replace failed.\n");
      transmit_response_reliable(p, "503 Service Unavailable", req);
      append_history(p, "Xfer", "INVITE/Replace Failed. No new channel.");
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
      ast_mutex_unlock(&p->refer->refer_call->lock);
      return 1;
   }
   append_history(p, "Xfer", "INVITE/Replace received");
   /* We have three channels to play with
      channel c: New incoming call
      targetcall: Call from PBX to target
      p->refer->refer_call: SIP pvt dialog from transferer to pbx.
      replacecall: The owner of the previous
      We need to masq C into refer_call to connect to 
      targetcall;
      If we are talking to internal audio stream, target call is null.
   */

   /* Fake call progress */
   transmit_response(p, "100 Trying", req);
   ast_setstate(c, AST_STATE_RING);

   /* Masquerade the new call into the referred call to connect to target call 
      Targetcall is not touched by the masq */

   /* Answer the incoming call and set channel to UP state */
   transmit_response_with_sdp(p, "200 OK", req, XMIT_RELIABLE);
   ast_setstate(c, AST_STATE_UP);
   
   /* Stop music on hold and other generators */
   ast_quiet_chan(replacecall);
   ast_quiet_chan(targetcall);
   if (option_debug > 3)
      ast_log(LOG_DEBUG, "Invite/Replaces: preparing to masquerade %s into %s\n", c->name, replacecall->name);
   /* Unlock clone, but not original (replacecall) */
   ast_channel_unlock(c);

   /* Unlock PVT */
   ast_mutex_unlock(&p->refer->refer_call->lock);

   /* Make sure that the masq does not free our PVT for the old call */
   ast_set_flag(&p->refer->refer_call->flags[0], SIP_DEFER_BYE_ON_TRANSFER);  /* Delay hangup */
      
   /* Prepare the masquerade - if this does not happen, we will be gone */
   if(ast_channel_masquerade(replacecall, c))
      ast_log(LOG_ERROR, "Failed to masquerade C into Replacecall\n");
   else if (option_debug > 3)
      ast_log(LOG_DEBUG, "Invite/Replaces: Going to masquerade %s into %s\n", c->name, replacecall->name);

   /* The masquerade will happen as soon as someone reads a frame from the channel */

   /* C should now be in place of replacecall */
   /* ast_read needs to lock channel */
   ast_channel_unlock(c);
   
   if (earlyreplace || oneleggedreplace ) {
      /* Force the masq to happen */
      if ((f = ast_read(replacecall))) {  /* Force the masq to happen */
         ast_frfree(f);
         f = NULL;
         if (option_debug > 3)
            ast_log(LOG_DEBUG, "Invite/Replace:  Could successfully read frame from RING channel!\n");
      } else {
         ast_log(LOG_WARNING, "Invite/Replace:  Could not read frame from RING channel \n");
      }
      c->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
      ast_channel_unlock(replacecall);
   } else { /* Bridged call, UP channel */
      if ((f = ast_read(replacecall))) {  /* Force the masq to happen */
         /* Masq ok */
         ast_frfree(f);
         f = NULL;
         if (option_debug > 2)
            ast_log(LOG_DEBUG, "Invite/Replace:  Could successfully read frame from channel! Masq done.\n");
      } else {
         ast_log(LOG_WARNING, "Invite/Replace:  Could not read frame from channel. Transfer failed\n");
      }
      ast_channel_unlock(replacecall);
   }
   ast_mutex_unlock(&p->refer->refer_call->lock);

   ast_setstate(c, AST_STATE_DOWN);
   if (option_debug > 3) {
      struct ast_channel *test;
      ast_log(LOG_DEBUG, "After transfer:----------------------------\n");
      ast_log(LOG_DEBUG, " -- C:        %s State %s\n", c->name, ast_state2str(c->_state));
      if (replacecall)
         ast_log(LOG_DEBUG, " -- replacecall:        %s State %s\n", replacecall->name, ast_state2str(replacecall->_state));
      if (p->owner) {
         ast_log(LOG_DEBUG, " -- P->owner: %s State %s\n", p->owner->name, ast_state2str(p->owner->_state));
         test = ast_bridged_channel(p->owner);
         if (test)
            ast_log(LOG_DEBUG, " -- Call bridged to P->owner: %s State %s\n", test->name, ast_state2str(test->_state));
         else
            ast_log(LOG_DEBUG, " -- No call bridged to C->owner \n");
      } else 
         ast_log(LOG_DEBUG, " -- No channel yet \n");
      ast_log(LOG_DEBUG, "End After transfer:----------------------------\n");
   }

   ast_channel_unlock(p->owner); /* Unlock new owner */
   ast_mutex_unlock(&p->lock);   /* Unlock SIP structure */

   /* The call should be down with no ast_channel, so hang it up */
   c->tech_pvt = NULL;
   ast_hangup(c);
   return 0;
}

static int handle_request	(	struct sip_pvt *	p,
		struct sip_request *	req,
		struct sockaddr_in *	sin,
		int *	recount,
		int *	nounlock
	)			[static]

Handle incoming SIP requests (methods).

Note:

This is where all incoming requests go first

Definition at line 14638 of file chan_sip.c.

References __sip_ack(), append_history, ast_inet_ntoa(), ast_log(), ast_set_flag, ast_string_field_set, ast_strlen_zero(), ast_test_flag, ast_verbose(), check_pendings(), debug, DEFAULT_TRANS_TIMEOUT, error(), extract_uri(), FALSE, find_sdp(), FLAG_RESPONSE, sip_pvt::flags, get_header(), gettag(), handle_request_bye(), handle_request_cancel(), handle_request_info(), handle_request_invite(), handle_request_message(), handle_request_notify(), handle_request_options(), handle_request_refer(), handle_request_register(), handle_request_subscribe(), handle_response(), sip_request::header, sip_request::headers, cfsip_methods::id, sip_pvt::initreq, INV_TERMINATED, len, LOG_DEBUG, LOG_ERROR, LOG_NOTICE, LOG_WARNING, sip_request::method, option_debug, process_sdp(), sip_request::rlPart1, sip_request::rlPart2, SIP_ACK, SIP_ALREADYGONE, SIP_BYE, SIP_CANCEL, sip_debug_test_pvt(), SIP_INFO, SIP_INVITE, SIP_MESSAGE, sip_methods, SIP_NEEDDESTROY, SIP_NOTIFY, SIP_OPTIONS, SIP_PKT_DEBUG, SIP_PKT_IGNORE, SIP_PKT_IGNORE_REQ, SIP_PKT_IGNORE_RESP, SIP_PKT_WITH_TOTAG, SIP_REFER, SIP_REGISTER, SIP_RESPONSE, sip_scheddestroy(), SIP_SUBSCRIBE, sip_pvt::tag, cfsip_methods::text, transmit_response(), transmit_response_reliable(), transmit_response_with_allow(), and TRUE.

{
   /* Called with p->lock held, as well as p->owner->lock if appropriate, keeping things
      relatively static */
   const char *cmd;
   const char *cseq;
   const char *useragent;
   int seqno;
   int len;
   int ignore = FALSE;
   int respid;
   int res = 0;
   int debug = sip_debug_test_pvt(p);
   char *e;
   int error = 0;

   /* Get Method and Cseq */
   cseq = get_header(req, "Cseq");
   cmd = req->header[0];

   /* Must have Cseq */
   if (ast_strlen_zero(cmd) || ast_strlen_zero(cseq)) {
      ast_log(LOG_ERROR, "Missing Cseq. Dropping this SIP message, it's incomplete.\n");
      error = 1;
   }
   if (!error && sscanf(cseq, "%d%n", &seqno, &len) != 1) {
      ast_log(LOG_ERROR, "No seqno in '%s'. Dropping incomplete message.\n", cmd);
      error = 1;
   }
   if (error) {
      if (!p->initreq.headers)   /* New call */
         ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); /* Make sure we destroy this dialog */
      return -1;
   }
   /* Get the command XXX */

   cmd = req->rlPart1;
   e = req->rlPart2;

   /* Save useragent of the client */
   useragent = get_header(req, "User-Agent");
   if (!ast_strlen_zero(useragent))
      ast_string_field_set(p, useragent, useragent);

   /* Find out SIP method for incoming request */
   if (req->method == SIP_RESPONSE) {  /* Response to our request */
      /* Response to our request -- Do some sanity checks */   
      if (!p->initreq.headers) {
         if (option_debug)
            ast_log(LOG_DEBUG, "That's odd...  Got a response on a call we dont know about. Cseq %d Cmd %s\n", seqno, cmd);
         ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
         return 0;
      } else if (p->ocseq && (p->ocseq < seqno)) {
         if (option_debug)
            ast_log(LOG_DEBUG, "Ignoring out of order response %d (expecting %d)\n", seqno, p->ocseq);
         return -1;
      } else if (p->ocseq && (p->ocseq != seqno)) {
         /* ignore means "don't do anything with it" but still have to 
            respond appropriately  */
         ignore = TRUE;
         ast_set_flag(req, SIP_PKT_IGNORE);
         ast_set_flag(req, SIP_PKT_IGNORE_RESP);
         append_history(p, "Ignore", "Ignoring this retransmit\n");
      } else if (e) {
         e = ast_skip_blanks(e);
         if (sscanf(e, "%d %n", &respid, &len) != 1) {
            ast_log(LOG_WARNING, "Invalid response: '%s'\n", e);
         } else {
            if (respid <= 0) {
               ast_log(LOG_WARNING, "Invalid SIP response code: '%d'\n", respid);
               return 0;
            }
            /* More SIP ridiculousness, we have to ignore bogus contacts in 100 etc responses */
            if ((respid == 200) || ((respid >= 300) && (respid <= 399)))
               extract_uri(p, req);
            handle_response(p, respid, e + len, req, ignore, seqno);
         }
      }
      return 0;
   }

   /* New SIP request coming in 
      (could be new request in existing SIP dialog as well...) 
    */         
   
   p->method = req->method;   /* Find out which SIP method they are using */
   if (option_debug > 3)
      ast_log(LOG_DEBUG, "**** Received %s (%d) - Command in SIP %s\n", sip_methods[p->method].text, sip_methods[p->method].id, cmd); 

   if (p->icseq && (p->icseq > seqno)) {
      if (option_debug)
         ast_log(LOG_DEBUG, "Ignoring too old SIP packet packet %d (expecting >= %d)\n", seqno, p->icseq);
      if (req->method != SIP_ACK)
         transmit_response(p, "503 Server error", req);  /* We must respond according to RFC 3261 sec 12.2 */
      return -1;
   } else if (p->icseq &&
         p->icseq == seqno &&
         req->method != SIP_ACK &&
         (p->method != SIP_CANCEL || ast_test_flag(&p->flags[0], SIP_ALREADYGONE))) {
      /* ignore means "don't do anything with it" but still have to 
         respond appropriately.  We do this if we receive a repeat of
         the last sequence number  */
      ignore = 2;
      ast_set_flag(req, SIP_PKT_IGNORE);
      ast_set_flag(req, SIP_PKT_IGNORE_REQ);
      if (option_debug > 2)
         ast_log(LOG_DEBUG, "Ignoring SIP message because of retransmit (%s Seqno %d, ours %d)\n", sip_methods[p->method].text, p->icseq, seqno);
   }
      
   if (seqno >= p->icseq)
      /* Next should follow monotonically (but not necessarily 
         incrementally -- thanks again to the genius authors of SIP --
         increasing */
      p->icseq = seqno;

   /* Find their tag if we haven't got it */
   if (ast_strlen_zero(p->theirtag)) {
      char tag[128];

      gettag(req, "From", tag, sizeof(tag));
      ast_string_field_set(p, theirtag, tag);
   }
   snprintf(p->lastmsg, sizeof(p->lastmsg), "Rx: %s", cmd);

   if (pedanticsipchecking) {
      /* If this is a request packet without a from tag, it's not
         correct according to RFC 3261  */
      /* Check if this a new request in a new dialog with a totag already attached to it,
         RFC 3261 - section 12.2 - and we don't want to mess with recovery  */
      if (!p->initreq.headers && ast_test_flag(req, SIP_PKT_WITH_TOTAG)) {
         /* If this is a first request and it got a to-tag, it is not for us */
         if (!ast_test_flag(req, SIP_PKT_IGNORE) && req->method == SIP_INVITE) {
            transmit_response_reliable(p, "481 Call/Transaction Does Not Exist", req);
            /* Will cease to exist after ACK */
         } else if (req->method != SIP_ACK) {
            transmit_response(p, "481 Call/Transaction Does Not Exist", req);
            sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
         }
         return res;
      }
   }

   if (!e && (p->method == SIP_INVITE || p->method == SIP_SUBSCRIBE || p->method == SIP_REGISTER || p->method == SIP_NOTIFY)) {
      transmit_response(p, "400 Bad request", req);
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
      return -1;
   }

   /* Handle various incoming SIP methods in requests */
   switch (p->method) {
   case SIP_OPTIONS:
      res = handle_request_options(p, req);
      break;
   case SIP_INVITE:
      res = handle_request_invite(p, req, debug, seqno, sin, recount, e);
      break;
   case SIP_REFER:
      res = handle_request_refer(p, req, debug, ignore, seqno, nounlock);
      break;
   case SIP_CANCEL:
      res = handle_request_cancel(p, req);
      break;
   case SIP_BYE:
      res = handle_request_bye(p, req);
      break;
   case SIP_MESSAGE:
      res = handle_request_message(p, req);
      break;
   case SIP_SUBSCRIBE:
      res = handle_request_subscribe(p, req, sin, seqno, e);
      break;
   case SIP_REGISTER:
      res = handle_request_register(p, req, sin, e);
      break;
   case SIP_INFO:
      if (ast_test_flag(req, SIP_PKT_DEBUG))
         ast_verbose("Receiving INFO!\n");
      if (!ignore) 
         handle_request_info(p, req);
      else  /* if ignoring, transmit response */
         transmit_response(p, "200 OK", req);
      break;
   case SIP_NOTIFY:
      res = handle_request_notify(p, req, sin, seqno, e);
      break;
   case SIP_ACK:
      /* Make sure we don't ignore this */
      if (seqno == p->pendinginvite) {
         p->invitestate = INV_TERMINATED;
         p->pendinginvite = 0;
         __sip_ack(p, seqno, FLAG_RESPONSE, 0);
         if (find_sdp(req)) {
            if (process_sdp(p, req))
               return -1;
         } 
         check_pendings(p);
      }
      /* Got an ACK that we did not match. Ignore silently */
      if (!p->lastinvite && ast_strlen_zero(p->randdata))
         ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
      break;
   default:
      transmit_response_with_allow(p, "501 Method Not Implemented", req, 0);
      ast_log(LOG_NOTICE, "Unknown SIP command '%s' from '%s'\n", 
         cmd, ast_inet_ntoa(p->sa.sin_addr));
      /* If this is some new method, and we don't have a call, destroy it now */
      if (!p->initreq.headers)
         ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
      break;
   }
   return res;
}

static int handle_request_bye	(	struct sip_pvt *	p,
		struct sip_request *	req
	)			[static]

Handle incoming BYE request.

Definition at line 14217 of file chan_sip.c.

References append_history, ast_async_goto(), ast_bridged_channel(), AST_CONTROL_UNHOLD, ast_inet_ntoa(), ast_log(), ast_queue_control(), ast_queue_hangup(), ast_rtp_get_quality(), ast_string_field_set, ast_strlen_zero(), ast_test_flag, check_via(), context, copy_request(), DEFAULT_TRANS_TIMEOUT, sip_pvt::flags, get_also_info(), get_header(), sip_pvt::initreq, INV_TERMINATED, sip_pvt::invitestate, LOG_DEBUG, LOG_NOTICE, LOG_WARNING, option_debug, sip_pvt::owner, pbx_builtin_setvar_helper(), sip_pvt::pendinginvite, sip_pvt::recv, sip_pvt::refer, sip_refer::refer_to, sip_pvt::rtp, sip_alreadygone(), SIP_NO_HISTORY, SIP_OUTGOING, SIP_PKT_IGNORE, sip_scheddestroy(), stop_media_flows(), transmit_response(), transmit_response_reliable(), and sip_pvt::vrtp.

Referenced by handle_request().

{
   struct ast_channel *c=NULL;
   int res;
   struct ast_channel *bridged_to;
   
   /* If we have an INCOMING invite that we haven't answered, terminate that transaction */
   if (p->pendinginvite && !ast_test_flag(&p->flags[0], SIP_OUTGOING) && !ast_test_flag(req, SIP_PKT_IGNORE) && !p->owner) 
      transmit_response_reliable(p, "487 Request Terminated", &p->initreq);

   p->invitestate = INV_TERMINATED;

   copy_request(&p->initreq, req);
   check_via(p, req);
   sip_alreadygone(p);

   /* Get RTCP quality before end of call */
   if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY) || p->owner) {
      char *audioqos, *videoqos;
      if (p->rtp) {
         audioqos = ast_rtp_get_quality(p->rtp, NULL);
         if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
            append_history(p, "RTCPaudio", "Quality:%s", audioqos);
         if (p->owner)
            pbx_builtin_setvar_helper(p->owner, "RTPAUDIOQOS", audioqos);
      }
      if (p->vrtp) {
         videoqos = ast_rtp_get_quality(p->vrtp, NULL);
         if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
            append_history(p, "RTCPvideo", "Quality:%s", videoqos);
         if (p->owner)
            pbx_builtin_setvar_helper(p->owner, "RTPVIDEOQOS", videoqos);
      }
   }

   stop_media_flows(p); /* Immediately stop RTP, VRTP and UDPTL as applicable */

   if (!ast_strlen_zero(get_header(req, "Also"))) {
      ast_log(LOG_NOTICE, "Client '%s' using deprecated BYE/Also transfer method.  Ask vendor to support REFER instead\n",
         ast_inet_ntoa(p->recv.sin_addr));
      if (ast_strlen_zero(p->context))
         ast_string_field_set(p, context, default_context);
      res = get_also_info(p, req);
      if (!res) {
         c = p->owner;
         if (c) {
            bridged_to = ast_bridged_channel(c);
            if (bridged_to) {
               /* Don't actually hangup here... */
               ast_queue_control(c, AST_CONTROL_UNHOLD);
               ast_async_goto(bridged_to, p->context, p->refer->refer_to,1);
            } else
               ast_queue_hangup(p->owner);
         }
      } else {
         ast_log(LOG_WARNING, "Invalid transfer information from '%s'\n", ast_inet_ntoa(p->recv.sin_addr));
         if (p->owner)
            ast_queue_hangup(p->owner);
      }
   } else if (p->owner) {
      ast_queue_hangup(p->owner);
      if (option_debug > 2)
         ast_log(LOG_DEBUG, "Received bye, issuing owner hangup\n");
   } else {
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
      if (option_debug > 2)
         ast_log(LOG_DEBUG, "Received bye, no owner, selfdestruct soon.\n");
   }
   transmit_response(p, "200 OK", req);

   return 1;
}

static int handle_request_cancel	(	struct sip_pvt *	p,
		struct sip_request *	req
	)			[static]

Handle incoming CANCEL request.

Definition at line 14129 of file chan_sip.c.

References ast_channel::_state, ast_log(), ast_queue_hangup(), AST_STATE_UP, check_via(), DEFAULT_TRANS_TIMEOUT, sip_pvt::initreq, INV_CANCELLED, sip_pvt::invitestate, sip_request::len, LOG_DEBUG, option_debug, sip_pvt::owner, sip_dual::req, sip_alreadygone(), sip_scheddestroy(), stop_media_flows(), transmit_response(), and transmit_response_reliable().

Referenced by handle_request().

{
      
   check_via(p, req);
   sip_alreadygone(p);
   p->invitestate = INV_CANCELLED;
   
   if (p->owner && p->owner->_state == AST_STATE_UP) {
      /* This call is up, cancel is ignored, we need a bye */
      transmit_response(p, "200 OK", req);
      if (option_debug)
         ast_log(LOG_DEBUG, "Got CANCEL on an answered call. Ignoring... \n");
      return 0;
   }
   stop_media_flows(p); /* Immediately stop RTP, VRTP and UDPTL as applicable */

   if (p->owner)
      ast_queue_hangup(p->owner);
   else
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
   if (p->initreq.len > 0) {
      transmit_response_reliable(p, "487 Request Terminated", &p->initreq);
      transmit_response(p, "200 OK", req);
      return 1;
   } else {
      transmit_response(p, "481 Call Leg Does Not Exist", req);
      return 0;
   }
}

static void handle_request_info	(	struct sip_pvt *	p,
		struct sip_request *	req
	)			[static]

Receive SIP INFO Message.

Note:

Doesn't read the duration of the DTMF signal

Definition at line 10775 of file chan_sip.c.

References ast_bridged_channel(), ast_cdr_setuserfield(), AST_CONTROL_FLASH, AST_CONTROL_VIDUPDATE, AST_FRAME_CONTROL, AST_FRAME_DTMF, ast_log(), ast_queue_control(), ast_queue_frame(), ast_strlen_zero(), ast_test_flag, ast_verbose(), ast_channel::cdr, DEFAULT_TRANS_TIMEOUT, event, f, sip_pvt::flags, get_body(), get_header(), LOG_WARNING, sip_pvt::owner, sip_scheddestroy(), SIP_USECLIENTCODE, sipdebug, and transmit_response().

Referenced by handle_request().

{
   char buf[1024];
   unsigned int event;
   const char *c = get_header(req, "Content-Type");

   /* Need to check the media/type */
   if (!strcasecmp(c, "application/dtmf-relay") ||
       !strcasecmp(c, "application/vnd.nortelnetworks.digits")) {
      unsigned int duration = 0;

      /* Try getting the "signal=" part */
      if (ast_strlen_zero(c = get_body(req, "Signal")) && ast_strlen_zero(c = get_body(req, "d"))) {
         ast_log(LOG_WARNING, "Unable to retrieve DTMF signal from INFO message from %s\n", p->callid);
         transmit_response(p, "200 OK", req); /* Should return error */
         return;
      } else {
         ast_copy_string(buf, c, sizeof(buf));
      }

      if (!ast_strlen_zero((c = get_body(req, "Duration"))))
         duration = atoi(c);
      if (!duration)
         duration = 100; /* 100 ms */

      if (!p->owner) {  /* not a PBX call */
         transmit_response(p, "481 Call leg/transaction does not exist", req);
         sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
         return;
      }

      if (ast_strlen_zero(buf)) {
         transmit_response(p, "200 OK", req);
         return;
      }

      if (buf[0] == '*')
         event = 10;
      else if (buf[0] == '#')
         event = 11;
      else if ((buf[0] >= 'A') && (buf[0] <= 'D'))
         event = 12 + buf[0] - 'A';
      else
         event = atoi(buf);
      if (event == 16) {
         /* send a FLASH event */
         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_FLASH, };
         ast_queue_frame(p->owner, &f);
         if (sipdebug)
            ast_verbose("* DTMF-relay event received: FLASH\n");
      } else {
         /* send a DTMF event */
         struct ast_frame f = { AST_FRAME_DTMF, };
         if (event < 10) {
            f.subclass = '0' + event;
         } else if (event < 11) {
            f.subclass = '*';
         } else if (event < 12) {
            f.subclass = '#';
         } else if (event < 16) {
            f.subclass = 'A' + (event - 12);
         }
         f.len = duration;
         ast_queue_frame(p->owner, &f);
         if (sipdebug)
            ast_verbose("* DTMF-relay event received: %c\n", f.subclass);
      }
      transmit_response(p, "200 OK", req);
      return;
   } else if (!strcasecmp(c, "application/media_control+xml")) {
      /* Eh, we'll just assume it's a fast picture update for now */
      if (p->owner)
         ast_queue_control(p->owner, AST_CONTROL_VIDUPDATE);
      transmit_response(p, "200 OK", req);
      return;
   } else if (!ast_strlen_zero(c = get_header(req, "X-ClientCode"))) {
      /* Client code (from SNOM phone) */
      if (ast_test_flag(&p->flags[0], SIP_USECLIENTCODE)) {
         if (p->owner && p->owner->cdr)
            ast_cdr_setuserfield(p->owner, c);
         if (p->owner && ast_bridged_channel(p->owner) && ast_bridged_channel(p->owner)->cdr)
            ast_cdr_setuserfield(ast_bridged_channel(p->owner), c);
         transmit_response(p, "200 OK", req);
      } else {
         transmit_response(p, "403 Unauthorized", req);
      }
      return;
   }
   /* Other type of INFO message, not really understood by Asterisk */
   /* if (get_msg_text(buf, sizeof(buf), req)) { */

   ast_log(LOG_WARNING, "Unable to parse INFO message from %s. Content %s\n", p->callid, buf);
   transmit_response(p, "415 Unsupported media type", req);
   return;
}

static int handle_request_invite	(	struct sip_pvt *	p,
		struct sip_request *	req,
		int	debug,
		int	seqno,
		struct sockaddr_in *	sin,
		int *	recount,
		char *	e
	)			[static]

Handle incoming INVITE request.

Note:

If the INVITE has a Replaces header, it is part of an attended transfer. If so, we do not go through the dial plan but tries to find the active call and masquerade into it

XXX: we should also check here does the other side supports t38 at all !!! XXX

Definition at line 13181 of file chan_sip.c.

References ast_channel::_state, append_history, ast_bridged_channel(), AST_CAUSE_CALL_REJECTED, AST_CAUSE_NORMAL_CLEARING, ast_channel_lock, ast_channel_unlock, ast_clear_flag, ast_hangup(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_null_frame, AST_PBX_CALL_LIMIT, AST_PBX_FAILED, ast_pbx_start(), AST_PBX_SUCCESS, ast_pickup_call(), ast_pickup_ext(), ast_queue_frame(), ast_rtp_setdtmf(), ast_rtp_setdtmfcompensate(), ast_setstate(), AST_STATE_DOWN, AST_STATE_RING, AST_STATE_RINGING, AST_STATE_UP, ast_strdupa, ast_string_field_free, ast_string_field_set, ast_strlen_zero(), ast_test_flag, ast_uri_decode(), ast_verbose(), AUTH_CHALLENGE_SENT, AUTH_FAKE_AUTH, sip_pvt::autokillid, build_contact(), build_route(), sip_pvt::capability, check_user(), check_via(), context, copy_request(), DEC_CALL_LIMIT, DEFAULT_TRANS_TIMEOUT, error(), exten, extract_uri(), FALSE, find_sdp(), sip_pvt::flags, get_destination(), get_header(), get_rdnis(), get_sip_pvt_byid_locked(), handle_invite_replaces(), ast_channel::hangupcause, sip_request::headers, INC_CALL_LIMIT, sip_pvt::initreq, INV_COMPLETED, INV_PROCEEDING, INV_TERMINATED, sip_pvt::invitestate, sip_pvt::jointcapability, sip_pvt::lastinvite, sip_pvt::lock, ast_channel::lock, LOG_DEBUG, LOG_NOTICE, LOG_WARNING, make_our_tag(), option_debug, sip_pvt::owner, parse_ok_contact(), parse_sip_options(), sip_pvt::pendinginvite, process_sdp(), sip_pvt::refer, sip_refer::refer_call, sip_pvt::rtp, S_OR, sip_alreadygone(), sip_cancel_destroy(), SIP_DTMF, SIP_DTMF_RFC2833, sip_handle_t38_reinvite(), SIP_INVITE, sip_new(), SIP_NO_HISTORY, SIP_OPT_REPLACES, SIP_OUTGOING, SIP_PAGE2_ALLOWOVERLAP, SIP_PAGE2_RFC2833_COMPENSATE, SIP_PKT_IGNORE, sip_refer_allocate(), sip_scheddestroy(), sip_tech, sip_tech_info, sipdebug, sip_pvt::sipoptions, t38properties::state, strcasestr(), strsep(), sip_pvt::t38, T38_DISABLED, T38_ENABLED, T38_PEER_REINVITE, sip_pvt::tag, ast_channel::tech, ast_channel::tech_pvt, transmit_fake_auth_response(), transmit_response(), transmit_response_reliable(), transmit_response_with_sdp(), transmit_response_with_t38_sdp(), transmit_response_with_unsupported(), TRUE, sip_pvt::udptl, update_call_counter(), XMIT_CRITICAL, and XMIT_RELIABLE.

Referenced by handle_request().

{
   int res = 1;
   int gotdest;
   const char *p_replaces;
   char *replace_id = NULL;
   const char *required;
   unsigned int required_profile = 0;
   struct ast_channel *c = NULL;    /* New channel */

   /* Find out what they support */
   if (!p->sipoptions) {
      const char *supported = get_header(req, "Supported");
      if (!ast_strlen_zero(supported))
         parse_sip_options(p, supported);
   }

   /* Find out what they require */
   required = get_header(req, "Require");
   if (!ast_strlen_zero(required)) {
      required_profile = parse_sip_options(NULL, required);
      if (required_profile && required_profile != SIP_OPT_REPLACES) {
         /* At this point we only support REPLACES */
         transmit_response_with_unsupported(p, "420 Bad extension (unsupported)", req, required);
         ast_log(LOG_WARNING,"Received SIP INVITE with unsupported required extension: %s\n", required);
         p->invitestate = INV_COMPLETED;
         if (!p->lastinvite)
            sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
         return -1;
      }
   }

   /* Check if this is a loop */
   if (ast_test_flag(&p->flags[0], SIP_OUTGOING) && p->owner && (p->owner->_state != AST_STATE_UP)) {
      /* This is a call to ourself.  Send ourselves an error code and stop
         processing immediately, as SIP really has no good mechanism for
         being able to call yourself */
      /* If pedantic is on, we need to check the tags. If they're different, this is
         in fact a forked call through a SIP proxy somewhere. */
      transmit_response(p, "482 Loop Detected", req);
      p->invitestate = INV_COMPLETED;
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
      return 0;
   }
   
   if (!ast_test_flag(req, SIP_PKT_IGNORE) && p->pendinginvite) {
      /* We already have a pending invite. Sorry. You are on hold. */
      transmit_response(p, "491 Request Pending", req);
      if (option_debug)
         ast_log(LOG_DEBUG, "Got INVITE on call where we already have pending INVITE, deferring that - %s\n", p->callid);
      /* Don't destroy dialog here */
      return 0;
   }

   p_replaces = get_header(req, "Replaces");
   if (!ast_strlen_zero(p_replaces)) {
      /* We have a replaces header */
      char *ptr;
      char *fromtag = NULL;
      char *totag = NULL;
      char *start, *to;
      int error = 0;

      if (p->owner) {
         if (option_debug > 2)
            ast_log(LOG_DEBUG, "INVITE w Replaces on existing call? Refusing action. [%s]\n", p->callid);
         transmit_response(p, "400 Bad request", req);   /* The best way to not not accept the transfer */
         /* Do not destroy existing call */
         return -1;
      }

      if (sipdebug && option_debug > 2)
         ast_log(LOG_DEBUG, "INVITE part of call transfer. Replaces [%s]\n", p_replaces);
      /* Create a buffer we can manipulate */
      replace_id = ast_strdupa(p_replaces);
      ast_uri_decode(replace_id);

      if (!p->refer && !sip_refer_allocate(p)) {
         transmit_response(p, "500 Server Internal Error", req);
         append_history(p, "Xfer", "INVITE/Replace Failed. Out of memory.");
         sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
         p->invitestate = INV_COMPLETED;
         return -1;
      }

      /*  Todo: (When we find phones that support this)
         if the replaces header contains ";early-only"
         we can only replace the call in early
         stage, not after it's up.

         If it's not in early mode, 486 Busy.
      */
      
      /* Skip leading whitespace */
      replace_id = ast_skip_blanks(replace_id);

      start = replace_id;
      while ( (ptr = strsep(&start, ";")) ) {
         ptr = ast_skip_blanks(ptr); /* XXX maybe unnecessary ? */
         if ( (to = strcasestr(ptr, "to-tag=") ) )
            totag = to + 7;   /* skip the keyword */
         else if ( (to = strcasestr(ptr, "from-tag=") ) ) {
            fromtag = to + 9; /* skip the keyword */
            fromtag = strsep(&fromtag, "&"); /* trim what ? */
         }
      }

      if (sipdebug && option_debug > 3) 
         ast_log(LOG_DEBUG,"Invite/replaces: Will use Replace-Call-ID : %s Fromtag: %s Totag: %s\n", replace_id, fromtag ? fromtag : "<no from tag>", totag ? totag : "<no to tag>");


      /* Try to find call that we are replacing 
         If we have a Replaces  header, we need to cancel that call if we succeed with this call 
      */
      if ((p->refer->refer_call = get_sip_pvt_byid_locked(replace_id, totag, fromtag)) == NULL) {
         ast_log(LOG_NOTICE, "Supervised transfer attempted to replace non-existent call id (%s)!\n", replace_id);
         transmit_response(p, "481 Call Leg Does Not Exist (Replaces)", req);
         error = 1;
      }

      /* At this point, bot the pvt and the owner of the call to be replaced is locked */

      /* The matched call is the call from the transferer to Asterisk .
         We want to bridge the bridged part of the call to the 
         incoming invite, thus taking over the refered call */

      if (p->refer->refer_call == p) {
         ast_log(LOG_NOTICE, "INVITE with replaces into it's own call id (%s == %s)!\n", replace_id, p->callid);
         p->refer->refer_call = NULL;
         transmit_response(p, "400 Bad request", req);   /* The best way to not not accept the transfer */
         error = 1;
      }

      if (!error && !p->refer->refer_call->owner) {
         /* Oops, someting wrong anyway, no owner, no call */
         ast_log(LOG_NOTICE, "Supervised transfer attempted to replace non-existing call id (%s)!\n", replace_id);
         /* Check for better return code */
         transmit_response(p, "481 Call Leg Does Not Exist (Replace)", req);
         error = 1;
      }

      if (!error && p->refer->refer_call->owner->_state != AST_STATE_RING && p->refer->refer_call->owner->_state != AST_STATE_UP ) {
         ast_log(LOG_NOTICE, "Supervised transfer attempted to replace non-ringing or active call id (%s)!\n", replace_id);
         transmit_response(p, "603 Declined (Replaces)", req);
         error = 1;
      }

      if (error) {   /* Give up this dialog */
         append_history(p, "Xfer", "INVITE/Replace Failed.");
         sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
         ast_mutex_unlock(&p->lock);
         if (p->refer->refer_call) {
            ast_mutex_unlock(&p->refer->refer_call->lock);
            ast_channel_unlock(p->refer->refer_call->owner);
         }
         p->invitestate = INV_COMPLETED;
         return -1;
      }
   }


   /* Check if this is an INVITE that sets up a new dialog or
      a re-invite in an existing dialog */

   if (!ast_test_flag(req, SIP_PKT_IGNORE)) {
      int newcall = (p->initreq.headers ? TRUE : FALSE);

      sip_cancel_destroy(p);
      /* This also counts as a pending invite */
      p->pendinginvite = seqno;
      check_via(p, req);

      copy_request(&p->initreq, req);     /* Save this INVITE as the transaction basis */
      if (!p->owner) {  /* Not a re-invite */
         if (debug)
            ast_verbose("Using INVITE request as basis request - %s\n", p->callid);
         if (newcall)
            append_history(p, "Invite", "New call: %s", p->callid);
         parse_ok_contact(p, req);
      } else { /* Re-invite on existing call */
         ast_clear_flag(&p->flags[0], SIP_OUTGOING);  /* This is now an inbound dialog */
         /* Handle SDP here if we already have an owner */
         if (find_sdp(req)) {
            if (process_sdp(p, req)) {
               transmit_response(p, "488 Not acceptable here", req);
               if (!p->lastinvite)
                  sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
               return -1;
            }
         } else {
            p->jointcapability = p->capability;
            if (option_debug)
               ast_log(LOG_DEBUG, "Hm....  No sdp for the moment\n");
         }
         if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY)) /* This is a response, note what it was for */
            append_history(p, "ReInv", "Re-invite received");
      }
   } else if (debug)
      ast_verbose("Ignoring this INVITE request\n");

   
   if (!p->lastinvite && !ast_test_flag(req, SIP_PKT_IGNORE) && !p->owner) {
      /* This is a new invite */
      /* Handle authentication if this is our first invite */
      res = check_user(p, req, SIP_INVITE, e, XMIT_RELIABLE, sin);
      if (res == AUTH_CHALLENGE_SENT) {
         p->invitestate = INV_COMPLETED;     /* Needs to restart in another INVITE transaction */
         return 0;
      }
      if (res < 0) { /* Something failed in authentication */
         if (res == AUTH_FAKE_AUTH) {
            ast_log(LOG_NOTICE, "Sending fake auth rejection for user %s\n", get_header(req, "From"));
            transmit_fake_auth_response(p, req, 1);
         } else {
            ast_log(LOG_NOTICE, "Failed to authenticate user %s\n", get_header(req, "From"));
            transmit_response_reliable(p, "403 Forbidden", req);
         }
         p->invitestate = INV_COMPLETED;  
         sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
         ast_string_field_free(p, theirtag);
         return 0;
      }

      /* We have a succesful authentication, process the SDP portion if there is one */
      if (find_sdp(req)) {
         if (process_sdp(p, req)) {
            /* Unacceptable codecs */
            transmit_response_reliable(p, "488 Not acceptable here", req);
            p->invitestate = INV_COMPLETED;  
            sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
            if (option_debug)
               ast_log(LOG_DEBUG, "No compatible codecs for this SIP call.\n");
            return -1;
         }
      } else { /* No SDP in invite, call control session */
         p->jointcapability = p->capability;
         if (option_debug > 1)
            ast_log(LOG_DEBUG, "No SDP in Invite, third party call control\n");
      }

      /* Queue NULL frame to prod ast_rtp_bridge if appropriate */
      /* This seems redundant ... see !p-owner above */
      if (p->owner)
         ast_queue_frame(p->owner, &ast_null_frame);


      /* Initialize the context if it hasn't been already */
      if (ast_strlen_zero(p->context))
         ast_string_field_set(p, context, default_context);


      /* Check number of concurrent calls -vs- incoming limit HERE */
      if (option_debug)
         ast_log(LOG_DEBUG, "Checking SIP call limits for device %s\n", p->username);
      if ((res = update_call_counter(p, INC_CALL_LIMIT))) {
         if (res < 0) {
            ast_log(LOG_NOTICE, "Failed to place call for user %s, too many calls\n", p->username);
            transmit_response_reliable(p, "480 Temporarily Unavailable (Call limit) ", req);
            sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
            p->invitestate = INV_COMPLETED;  
         }
         return 0;
      }
      gotdest = get_destination(p, NULL); /* Get destination right away */
      get_rdnis(p, NULL);        /* Get redirect information */
      extract_uri(p, req);       /* Get the Contact URI */
      build_contact(p);       /* Build our contact header */

      if (p->rtp) {
         ast_rtp_setdtmf(p->rtp, ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833);
         ast_rtp_setdtmfcompensate(p->rtp, ast_test_flag(&p->flags[1], SIP_PAGE2_RFC2833_COMPENSATE));
      }

      if (!replace_id && gotdest) { /* No matching extension found */
         if (gotdest == 1 && ast_test_flag(&p->flags[1], SIP_PAGE2_ALLOWOVERLAP))
            transmit_response_reliable(p, "484 Address Incomplete", req);
         else
            transmit_response_reliable(p, "404 Not Found", req);
         p->invitestate = INV_COMPLETED;  
         update_call_counter(p, DEC_CALL_LIMIT);
         sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
         return 0;
      } else {
         /* If no extension was specified, use the s one */
         /* Basically for calling to IP/Host name only */
         if (ast_strlen_zero(p->exten))
            ast_string_field_set(p, exten, "s");
         /* Initialize our tag */   

         make_our_tag(p->tag, sizeof(p->tag));
         /* First invitation - create the channel */
         c = sip_new(p, AST_STATE_DOWN, S_OR(p->username, NULL));
         *recount = 1;

         /* Save Record-Route for any later requests we make on this dialogue */
         build_route(p, req, 0);

         if (c) {
            /* Pre-lock the call */
            ast_channel_lock(c);
         }
      }
   } else {
      if (option_debug > 1 && sipdebug) {
         if (!ast_test_flag(req, SIP_PKT_IGNORE))
            ast_log(LOG_DEBUG, "Got a SIP re-invite for call %s\n", p->callid);
         else
            ast_log(LOG_DEBUG, "Got a SIP re-transmit of INVITE for call %s\n", p->callid);
      }
      c = p->owner;
   }

   if (!ast_test_flag(req, SIP_PKT_IGNORE) && p)
      p->lastinvite = seqno;

   if (replace_id) {    /* Attended transfer or call pickup - we're the target */
      /* Go and take over the target call */
      if (sipdebug && option_debug > 3)
         ast_log(LOG_DEBUG, "Sending this call to the invite/replcaes handler %s\n", p->callid);
      return handle_invite_replaces(p, req, debug, ast_test_flag(req, SIP_PKT_IGNORE), seqno, sin);
   }


   if (c) { /* We have a call  -either a new call or an old one (RE-INVITE) */
      switch(c->_state) {
      case AST_STATE_DOWN:
         if (option_debug > 1)
            ast_log(LOG_DEBUG, "%s: New call is still down.... Trying... \n", c->name);
         transmit_response(p, "100 Trying", req);
         p->invitestate = INV_PROCEEDING;
         ast_setstate(c, AST_STATE_RING);
         if (strcmp(p->exten, ast_pickup_ext())) { /* Call to extension -start pbx on this call */
            enum ast_pbx_result res;

            res = ast_pbx_start(c);

            switch(res) {
            case AST_PBX_FAILED:
               ast_log(LOG_WARNING, "Failed to start PBX :(\n");
               p->invitestate = INV_COMPLETED;
               if (ast_test_flag(req, SIP_PKT_IGNORE))
                  transmit_response(p, "503 Unavailable", req);
               else
                  transmit_response_reliable(p, "503 Unavailable", req);
               break;
            case AST_PBX_CALL_LIMIT:
               ast_log(LOG_WARNING, "Failed to start PBX (call limit reached) \n");
               p->invitestate = INV_COMPLETED;
               if (ast_test_flag(req, SIP_PKT_IGNORE))
                  transmit_response(p, "480 Temporarily Unavailable", req);
               else
                  transmit_response_reliable(p, "480 Temporarily Unavailable", req);
               break;
            case AST_PBX_SUCCESS:
               /* nothing to do */
               break;
            }

            if (res) {

               /* Unlock locks so ast_hangup can do its magic */
               ast_mutex_unlock(&c->lock);
               ast_mutex_unlock(&p->lock);
               ast_hangup(c);
               ast_mutex_lock(&p->lock);
               c = NULL;
            }
         } else { /* Pickup call in call group */
            ast_channel_unlock(c);
            if (ast_pickup_call(c)) {
               ast_log(LOG_NOTICE, "Nothing to pick up for %s\n", p->callid);
               if (ast_test_flag(req, SIP_PKT_IGNORE))
                  transmit_response(p, "503 Unavailable", req);   /* OEJ - Right answer? */
               else
                  transmit_response_reliable(p, "503 Unavailable", req);
               sip_alreadygone(p);
               /* Unlock locks so ast_hangup can do its magic */
               ast_mutex_unlock(&p->lock);
               c->hangupcause = AST_CAUSE_CALL_REJECTED;
            } else {
               ast_mutex_unlock(&p->lock);
               ast_setstate(c, AST_STATE_DOWN);
               c->hangupcause = AST_CAUSE_NORMAL_CLEARING;
            }
            p->invitestate = INV_COMPLETED;
            ast_hangup(c);
            ast_mutex_lock(&p->lock);
            c = NULL;
         }
         break;
      case AST_STATE_RING:
         transmit_response(p, "100 Trying", req);
         p->invitestate = INV_PROCEEDING;
         break;
      case AST_STATE_RINGING:
         transmit_response(p, "180 Ringing", req);
         p->invitestate = INV_PROCEEDING;
         break;
      case AST_STATE_UP:
         if (option_debug > 1)
            ast_log(LOG_DEBUG, "%s: This call is UP.... \n", c->name);

         if (p->t38.state == T38_PEER_REINVITE) {
            struct ast_channel *bridgepeer = NULL;
            struct sip_pvt *bridgepvt = NULL;
            
            if ((bridgepeer = ast_bridged_channel(p->owner))) {
               /* We have a bridge, and this is re-invite to switchover to T38 so we send re-invite with T38 SDP, to other side of bridge*/
               /*! XXX: we should also check here does the other side supports t38 at all !!! XXX */
               if (bridgepeer->tech == &sip_tech || bridgepeer->tech == &sip_tech_info) {
                  bridgepvt = (struct sip_pvt*)bridgepeer->tech_pvt;
                  if (bridgepvt->t38.state == T38_DISABLED) {
                     if (bridgepvt->udptl) { /* If everything is OK with other side's udptl struct */
                        /* Send re-invite to the bridged channel */
                        sip_handle_t38_reinvite(bridgepeer, p, 1);
                     } else { /* Something is wrong with peers udptl struct */
                        ast_log(LOG_WARNING, "Strange... The other side of the bridge don't have udptl struct\n");
                        ast_mutex_lock(&bridgepvt->lock);
                        bridgepvt->t38.state = T38_DISABLED;
                        ast_mutex_unlock(&bridgepvt->lock);
                        if (option_debug > 1)
                           ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", bridgepvt->t38.state, bridgepeer->name);
                        if (ast_test_flag(req, SIP_PKT_IGNORE))
                           transmit_response(p, "488 Not acceptable here", req);
                        else
                           transmit_response_reliable(p, "488 Not acceptable here", req);
                     
                     }
                  } else {
                     /* The other side is already setup for T.38 most likely so we need to acknowledge this too */
                     transmit_response_with_t38_sdp(p, "200 OK", req, XMIT_CRITICAL);
                     p->t38.state = T38_ENABLED;
                     if (option_debug)
                        ast_log(LOG_DEBUG, "T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
                  }
               } else {
                  /* Other side is not a SIP channel */
                  if (ast_test_flag(req, SIP_PKT_IGNORE))
                     transmit_response(p, "488 Not acceptable here", req);
                  else
                     transmit_response_reliable(p, "488 Not acceptable here", req);
                  p->t38.state = T38_DISABLED;
                  if (option_debug > 1)
                     ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");

                  if (!p->lastinvite) /* Only destroy if this is *not* a re-invite */
                     sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
               }
            } else {
               /* we are not bridged in a call */
               transmit_response_with_t38_sdp(p, "200 OK", req, XMIT_CRITICAL);
               p->t38.state = T38_ENABLED;
               if (option_debug)
                  ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
            }
         } else if (p->t38.state == T38_DISABLED) { /* Channel doesn't have T38 offered or enabled */
            int sendok = TRUE;

            /* If we are bridged to a channel that has T38 enabled than this is a case of RTP re-invite after T38 session */
            /* so handle it here (re-invite other party to RTP) */
            struct ast_channel *bridgepeer = NULL;
            struct sip_pvt *bridgepvt = NULL;
            if ((bridgepeer = ast_bridged_channel(p->owner))) {
               if (bridgepeer->tech == &sip_tech || bridgepeer->tech == &sip_tech_info) {
                  bridgepvt = (struct sip_pvt*)bridgepeer->tech_pvt;
                  /* Does the bridged peer have T38 ? */
                  if (bridgepvt->t38.state == T38_ENABLED) {
                     ast_log(LOG_WARNING, "RTP re-invite after T38 session not handled yet !\n");
                     /* Insted of this we should somehow re-invite the other side of the bridge to RTP */
                     if (ast_test_flag(req, SIP_PKT_IGNORE))
                        transmit_response(p, "488 Not Acceptable Here (unsupported)", req);
                     else
                        transmit_response_reliable(p, "488 Not Acceptable Here (unsupported)", req);
                     sendok = FALSE;
                  } 
                  /* No bridged peer with T38 enabled*/
               }
            } 
            /* Respond to normal re-invite */
            if (sendok)
               transmit_response_with_sdp(p, "200 OK", req, XMIT_CRITICAL);

         }
         p->invitestate = INV_TERMINATED;
         break;
      default:
         ast_log(LOG_WARNING, "Don't know how to handle INVITE in state %d\n", c->_state);
         transmit_response(p, "100 Trying", req);
         break;
      }
   } else {
      if (p && (p->autokillid == -1)) {
         const char *msg;

         if (!p->jointcapability)
            msg = "488 Not Acceptable Here (codec error)";
         else {
            ast_log(LOG_NOTICE, "Unable to create/find SIP channel for this INVITE\n");
            msg = "503 Unavailable";
         }
         if (ast_test_flag(req, SIP_PKT_IGNORE))
            transmit_response(p, msg, req);
         else
            transmit_response_reliable(p, msg, req);
         p->invitestate = INV_COMPLETED;
         sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
      }
   }
   return res;
}

static int handle_request_message	(	struct sip_pvt *	p,
		struct sip_request *	req
	)			[static]

Handle incoming MESSAGE request.

Definition at line 14291 of file chan_sip.c.

References ast_test_flag, ast_verbose(), receive_message(), SIP_PKT_DEBUG, SIP_PKT_IGNORE, and transmit_response().

Referenced by handle_request().

{
   if (!ast_test_flag(req, SIP_PKT_IGNORE)) {
      if (ast_test_flag(req, SIP_PKT_DEBUG))
         ast_verbose("Receiving message!\n");
      receive_message(p, req);
   } else
      transmit_response(p, "202 Accepted", req);
   return 1;
}

static int handle_request_notify	(	struct sip_pvt *	p,
		struct sip_request *	req,
		struct sockaddr_in *	sin,
		int	seqno,
		char *	e
	)			[static]

Handle incoming notifications.

Definition at line 12865 of file chan_sip.c.

References ast_log(), DEFAULT_TRANS_TIMEOUT, event, FALSE, get_header(), get_msg_text(), sip_pvt::lastinvite, LOG_DEBUG, LOG_NOTICE, LOG_WARNING, option_debug, sip_scheddestroy(), sipdebug, transmit_response(), and TRUE.

Referenced by handle_request().

{
   /* This is mostly a skeleton for future improvements */
   /* Mostly created to return proper answers on notifications on outbound REFER's */
   int res = 0;
   const char *event = get_header(req, "Event");
   char *eventid = NULL;
   char *sep;

   if( (sep = strchr(event, ';')) ) {  /* XXX bug here - overwriting string ? */
      *sep++ = '\0';
      eventid = sep;
   }
   
   if (option_debug > 1 && sipdebug)
      ast_log(LOG_DEBUG, "Got NOTIFY Event: %s\n", event);

   if (strcmp(event, "refer")) {
      /* We don't understand this event. */
      /* Here's room to implement incoming voicemail notifications :-) */
      transmit_response(p, "489 Bad event", req);
      res = -1;
   } else {
      /* Save nesting depth for now, since there might be other events we will
         support in the future */

      /* Handle REFER notifications */

      char buf[1024];
      char *cmd, *code;
      int respcode;
      int success = TRUE;

      /* EventID for each transfer... EventID is basically the REFER cseq 

       We are getting notifications on a call that we transfered
       We should hangup when we are getting a 200 OK in a sipfrag
       Check if we have an owner of this event */
      
      /* Check the content type */
      if (strncasecmp(get_header(req, "Content-Type"), "message/sipfrag", strlen("message/sipfrag"))) {
         /* We need a sipfrag */
         transmit_response(p, "400 Bad request", req);
         sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
         return -1;
      }

      /* Get the text of the attachment */
      if (get_msg_text(buf, sizeof(buf), req)) {
         ast_log(LOG_WARNING, "Unable to retrieve attachment from NOTIFY %s\n", p->callid);
         transmit_response(p, "400 Bad request", req);
         sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
         return -1;
      }

      /*
      From the RFC...
      A minimal, but complete, implementation can respond with a single
         NOTIFY containing either the body:
               SIP/2.0 100 Trying
      
         if the subscription is pending, the body:
               SIP/2.0 200 OK
         if the reference was successful, the body:
               SIP/2.0 503 Service Unavailable
         if the reference failed, or the body:
               SIP/2.0 603 Declined

         if the REFER request was accepted before approval to follow the
         reference could be obtained and that approval was subsequently denied
         (see Section 2.4.7).
      
      If there are several REFERs in the same dialog, we need to
      match the ID of the event header...
      */
      if (option_debug > 2)
         ast_log(LOG_DEBUG, "* SIP Transfer NOTIFY Attachment: \n---%s\n---\n", buf);
      cmd = ast_skip_blanks(buf);
      code = cmd;
      /* We are at SIP/2.0 */
      while(*code && (*code > 32)) {   /* Search white space */
         code++;
      }
      *code++ = '\0';
      code = ast_skip_blanks(code);
      sep = code;
      sep++;
      while(*sep && (*sep > 32)) {  /* Search white space */
         sep++;
      }
      *sep++ = '\0';       /* Response string */
      respcode = atoi(code);
      switch (respcode) {
      case 100:   /* Trying: */
      case 101:   /* dialog establishment */
         /* Don't do anything yet */
         break;
      case 183:   /* Ringing: */
         /* Don't do anything yet */
         break;
      case 200:   /* OK: The new call is up, hangup this call */
         /* Hangup the call that we are replacing */
         break;
      case 301: /* Moved permenantly */
      case 302: /* Moved temporarily */
         /* Do we get the header in the packet in this case? */
         success = FALSE;
         break;
      case 503:   /* Service Unavailable: The new call failed */
            /* Cancel transfer, continue the call */
         success = FALSE;
         break;
      case 603:   /* Declined: Not accepted */
            /* Cancel transfer, continue the current call */
         success = FALSE;
         break;
      }
      if (!success) {
         ast_log(LOG_NOTICE, "Transfer failed. Sorry. Nothing further to do with this call\n");
      }
      
      /* Confirm that we received this packet */
      transmit_response(p, "200 OK", req);
   };

   if (!p->lastinvite)
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);

   return res;
}

static int handle_request_options	(	struct sip_pvt *	p,
		struct sip_request *	req
	)			[static]

Handle incoming OPTIONS request.

Definition at line 12997 of file chan_sip.c.

References ast_string_field_set, ast_strlen_zero(), build_contact(), context, DEFAULT_TRANS_TIMEOUT, get_destination(), sip_pvt::lastinvite, sip_scheddestroy(), and transmit_response_with_allow().

Referenced by handle_request().

{
   int res;

   res = get_destination(p, req);
   build_contact(p);
   /* XXX Should we authenticate OPTIONS? XXX */
   if (ast_strlen_zero(p->context))
      ast_string_field_set(p, context, default_context);
   if (res < 0)
      transmit_response_with_allow(p, "404 Not Found", req, 0);
   else 
      transmit_response_with_allow(p, "200 OK", req, 0);
   /* Destroy if this OPTIONS was the opening request, but not if
      it's in the middle of a normal call flow. */
   if (!p->lastinvite)
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);

   return res;
}

static int handle_request_refer	(	struct sip_pvt *	p,
		struct sip_request *	req,
		int	debug,
		int	ignore,
		int	seqno,
		int *	nounlock
	)			[static]

Definition at line 13856 of file chan_sip.c.

References sip_pvt::allowtransfer, append_history, ast_async_goto(), ast_bridged_channel(), AST_CAUSE_NORMAL_CLEARING, ast_channel_unlock, ast_clear_flag, AST_CONTROL_UNHOLD, AST_LIST_EMPTY, ast_log(), ast_parking_ext(), ast_queue_control(), ast_set_flag, ast_string_field_set, ast_strlen_zero(), ast_test_flag, ast_verbose(), sip_refer::attendedtransfer, sip_dual::chan1, sip_dual::chan2, check_sip_domain(), context, copy_request(), FALSE, sip_pvt::flags, get_refer_info(), ast_channel::hangupcause, local_attended_transfer(), sip_refer::localtransfer, LOG_DEBUG, option_debug, sip_pvt::owner, pbx_builtin_setvar_helper(), sip_pvt::refer, REFER_200OK, REFER_FAILED, REFER_SENT, sip_refer::refer_to, sip_refer::refer_to_context, sip_refer::refer_to_domain, sip_refer::referred_by, sip_refer::replaces_callid, sip_refer::replaces_callid_fromtag, sip_refer::replaces_callid_totag, sip_dual::req, sip_alreadygone(), SIP_DEFER_BYE_ON_TRANSFER, SIP_GOTREFER, SIP_NEEDDESTROY, SIP_OUTGOING, sip_park(), SIP_PKT_DEBUG, SIP_PKT_IGNORE, sip_refer_allocate(), sipdebug, sip_refer::status, TRANSFER_CLOSED, transmit_notify_with_sipfrag(), transmit_response(), and TRUE.

Referenced by handle_request().

{
   struct sip_dual current;   /* Chan1: Call between asterisk and transferer */
               /* Chan2: Call between asterisk and transferee */

   int res = 0;

   if (ast_test_flag(req, SIP_PKT_DEBUG))
      ast_verbose("Call %s got a SIP call transfer from %s: (REFER)!\n", p->callid, ast_test_flag(&p->flags[0], SIP_OUTGOING) ? "callee" : "caller");

   if (!p->owner) {
      /* This is a REFER outside of an existing SIP dialog */
      /* We can't handle that, so decline it */
      if (option_debug > 2)
         ast_log(LOG_DEBUG, "Call %s: Declined REFER, outside of dialog...\n", p->callid);
      transmit_response(p, "603 Declined (No dialog)", req);
      if (!ast_test_flag(req, SIP_PKT_IGNORE)) {
         append_history(p, "Xfer", "Refer failed. Outside of dialog.");
         sip_alreadygone(p);
         ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
      }
      return 0;
   }  


   /* Check if transfer is allowed from this device */
   if (p->allowtransfer == TRANSFER_CLOSED ) {
      /* Transfer not allowed, decline */
      transmit_response(p, "603 Declined (policy)", req);
      append_history(p, "Xfer", "Refer failed. Allowtransfer == closed.");
      /* Do not destroy SIP session */
      return 0;
   }

   if(!ignore && ast_test_flag(&p->flags[0], SIP_GOTREFER)) {
      /* Already have a pending REFER */  
      transmit_response(p, "491 Request pending", req);
      append_history(p, "Xfer", "Refer failed. Request pending.");
      return 0;
   }

   /* Allocate memory for call transfer data */
   if (!p->refer && !sip_refer_allocate(p)) {
      transmit_response(p, "500 Internal Server Error", req);
      append_history(p, "Xfer", "Refer failed. Memory allocation error.");
      return -3;
   }

   res = get_refer_info(p, req); /* Extract headers */

   p->refer->status = REFER_SENT;

   if (res != 0) {
      switch (res) {
      case -2: /* Syntax error */
         transmit_response(p, "400 Bad Request (Refer-to missing)", req);
         append_history(p, "Xfer", "Refer failed. Refer-to missing.");
         if (ast_test_flag(req, SIP_PKT_DEBUG) && option_debug)
            ast_log(LOG_DEBUG, "SIP transfer to black hole can't be handled (no refer-to: )\n");
         break;
      case -3:
         transmit_response(p, "603 Declined (Non sip: uri)", req);
         append_history(p, "Xfer", "Refer failed. Non SIP uri");
         if (ast_test_flag(req, SIP_PKT_DEBUG) && option_debug)
            ast_log(LOG_DEBUG, "SIP transfer to non-SIP uri denied\n");
         break;
      default:
         /* Refer-to extension not found, fake a failed transfer */
         transmit_response(p, "202 Accepted", req);
         append_history(p, "Xfer", "Refer failed. Bad extension.");
         transmit_notify_with_sipfrag(p, seqno, "404 Not found", TRUE);
         ast_clear_flag(&p->flags[0], SIP_GOTREFER);  
         if (ast_test_flag(req, SIP_PKT_DEBUG) && option_debug)
            ast_log(LOG_DEBUG, "SIP transfer to bad extension: %s\n", p->refer->refer_to);
         break;
      } 
      return 0;
   }
   if (ast_strlen_zero(p->context))
      ast_string_field_set(p, context, default_context);

   /* If we do not support SIP domains, all transfers are local */
   if (allow_external_domains && check_sip_domain(p->refer->refer_to_domain, NULL, 0)) {
      p->refer->localtransfer = 1;
      if (sipdebug && option_debug > 2)
         ast_log(LOG_DEBUG, "This SIP transfer is local : %s\n", p->refer->refer_to_domain);
   } else if (AST_LIST_EMPTY(&domain_list)) {
      /* This PBX don't bother with SIP domains, so all transfers are local */
      p->refer->localtransfer = 1;
   } else
      if (sipdebug && option_debug > 2)
         ast_log(LOG_DEBUG, "This SIP transfer is to a remote SIP extension (remote domain %s)\n", p->refer->refer_to_domain);
   
   /* Is this a repeat of a current request? Ignore it */
   /* Don't know what else to do right now. */
   if (ignore) 
      return res;

   /* If this is a blind transfer, we have the following
      channels to work with:
      - chan1, chan2: The current call between transferer and transferee (2 channels)
      - target_channel: A new call from the transferee to the target (1 channel)
      We need to stay tuned to what happens in order to be able
      to bring back the call to the transferer */

   /* If this is a attended transfer, we should have all call legs within reach:
      - chan1, chan2: The call between the transferer and transferee (2 channels)
      - target_channel, targetcall_pvt: The call between the transferer and the target (2 channels)
   We want to bridge chan2 with targetcall_pvt!
   
      The replaces call id in the refer message points
      to the call leg between Asterisk and the transferer.
      So we need to connect the target and the transferee channel
      and hangup the two other channels silently 
   
      If the target is non-local, the call ID could be on a remote
      machine and we need to send an INVITE with replaces to the
      target. We basically handle this as a blind transfer
      and let the sip_call function catch that we need replaces
      header in the INVITE.
   */


   /* Get the transferer's channel */
   current.chan1 = p->owner;

   /* Find the other part of the bridge (2) - transferee */
   current.chan2 = ast_bridged_channel(current.chan1);
   
   if (sipdebug && option_debug > 2)
      ast_log(LOG_DEBUG, "SIP %s transfer: Transferer channel %s, transferee channel %s\n", p->refer->attendedtransfer ? "attended" : "blind", current.chan1->name, current.chan2 ? current.chan2->name : "<none>");

   if (!current.chan2 && !p->refer->attendedtransfer) {
      /* No bridged channel, propably IVR or echo or similar... */
      /* Guess we should masquerade or something here */
      /* Until we figure it out, refuse transfer of such calls */
      if (sipdebug && option_debug > 2)
         ast_log(LOG_DEBUG,"Refused SIP transfer on non-bridged channel.\n");
      p->refer->status = REFER_FAILED;
      append_history(p, "Xfer", "Refer failed. Non-bridged channel.");
      transmit_response(p, "603 Declined", req);
      return -1;
   }

   if (current.chan2) {
      if (sipdebug && option_debug > 3)
         ast_log(LOG_DEBUG, "Got SIP transfer, applying to bridged peer '%s'\n", current.chan2->name);

      ast_queue_control(current.chan1, AST_CONTROL_UNHOLD);
   }

   ast_set_flag(&p->flags[0], SIP_GOTREFER); 

   /* Attended transfer: Find all call legs and bridge transferee with target*/
   if (p->refer->attendedtransfer) {
      if ((res = local_attended_transfer(p, &current, req, seqno)))
         return res; /* We're done with the transfer */
      /* Fall through for remote transfers that we did not find locally */
      if (sipdebug && option_debug > 3)
         ast_log(LOG_DEBUG, "SIP attended transfer: Still not our call - generating INVITE with replaces\n");
      /* Fallthrough if we can't find the call leg internally */
   }


   /* Parking a call */
   if (p->refer->localtransfer && !strcmp(p->refer->refer_to, ast_parking_ext())) {
      /* Must release c's lock now, because it will not longer be accessible after the transfer! */
      *nounlock = 1;
      ast_channel_unlock(current.chan1);
      copy_request(&current.req, req);
      ast_clear_flag(&p->flags[0], SIP_GOTREFER);  
      p->refer->status = REFER_200OK;
      append_history(p, "Xfer", "REFER to call parking.");
      if (sipdebug && option_debug > 3)
         ast_log(LOG_DEBUG, "SIP transfer to parking: trying to park %s. Parked by %s\n", current.chan2->name, current.chan1->name);
      sip_park(current.chan2, current.chan1, req, seqno);
      return res;
   } 

   /* Blind transfers and remote attended xfers */
   transmit_response(p, "202 Accepted", req);

   if (current.chan1 && current.chan2) {
      if (option_debug > 2)
         ast_log(LOG_DEBUG, "chan1->name: %s\n", current.chan1->name);
      pbx_builtin_setvar_helper(current.chan1, "BLINDTRANSFER", current.chan2->name);
   }
   if (current.chan2) {
      pbx_builtin_setvar_helper(current.chan2, "BLINDTRANSFER", current.chan1->name);
      pbx_builtin_setvar_helper(current.chan2, "SIPDOMAIN", p->refer->refer_to_domain);
      pbx_builtin_setvar_helper(current.chan2, "SIPTRANSFER", "yes");
      /* One for the new channel */
      pbx_builtin_setvar_helper(current.chan2, "_SIPTRANSFER", "yes");
      /* Attended transfer to remote host, prepare headers for the INVITE */
      if (p->refer->referred_by) 
         pbx_builtin_setvar_helper(current.chan2, "_SIPTRANSFER_REFERER", p->refer->referred_by);
   }
   /* Generate a Replaces string to be used in the INVITE during attended transfer */
   if (p->refer->replaces_callid && !ast_strlen_zero(p->refer->replaces_callid)) {
      char tempheader[BUFSIZ];
      snprintf(tempheader, sizeof(tempheader), "%s%s%s%s%s", p->refer->replaces_callid, 
            p->refer->replaces_callid_totag ? ";to-tag=" : "", 
            p->refer->replaces_callid_totag, 
            p->refer->replaces_callid_fromtag ? ";from-tag=" : "",
            p->refer->replaces_callid_fromtag);
      if (current.chan2)
         pbx_builtin_setvar_helper(current.chan2, "_SIPTRANSFER_REPLACES", tempheader);
   }
   /* Must release lock now, because it will not longer
         be accessible after the transfer! */
   *nounlock = 1;
   ast_channel_unlock(current.chan1);
   ast_channel_unlock(current.chan2);

   /* Connect the call */

   /* FAKE ringing if not attended transfer */
   if (!p->refer->attendedtransfer)
      transmit_notify_with_sipfrag(p, seqno, "183 Ringing", FALSE); 
      
   /* For blind transfer, this will lead to a new call */
   /* For attended transfer to remote host, this will lead to
         a new SIP call with a replaces header, if the dial plan allows it 
   */
   if (!current.chan2) {
      /* We have no bridge, so we're talking with Asterisk somehow */
      /* We need to masquerade this call */
      /* What to do to fix this situation:
         * Set up the new call in a new channel 
         * Let the new channel masq into this channel
         Please add that code here :-)
      */
      p->refer->status = REFER_FAILED;
      transmit_notify_with_sipfrag(p, seqno, "503 Service Unavailable (can't handle one-legged xfers)", TRUE);
      ast_clear_flag(&p->flags[0], SIP_GOTREFER);  
      append_history(p, "Xfer", "Refer failed (only bridged calls).");
      return -1;
   }
   ast_set_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER);   /* Delay hangup */

   /* For blind transfers, move the call to the new extensions. For attended transfers on multiple
      servers - generate an INVITE with Replaces. Either way, let the dial plan decided  */
   res = ast_async_goto(current.chan2, p->refer->refer_to_context, p->refer->refer_to, 1);

   if (!res) {
      /* Success  - we have a new channel */
      if (option_debug > 2)
         ast_log(LOG_DEBUG, "%s transfer succeeded. Telling transferer.\n", p->refer->attendedtransfer? "Attended" : "Blind");
      transmit_notify_with_sipfrag(p, seqno, "200 Ok", TRUE);
      if (p->refer->localtransfer)
         p->refer->status = REFER_200OK;
      if (p->owner)
         p->owner->hangupcause = AST_CAUSE_NORMAL_CLEARING;
      append_history(p, "Xfer", "Refer succeeded.");
      ast_clear_flag(&p->flags[0], SIP_GOTREFER);  
      /* Do not hangup call, the other side do that when we say 200 OK */
      /* We could possibly implement a timer here, auto congestion */
      res = 0;
   } else {
      ast_clear_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER); /* Don't delay hangup */
      if (option_debug > 2)
         ast_log(LOG_DEBUG, "%s transfer failed. Resuming original call.\n", p->refer->attendedtransfer? "Attended" : "Blind");
      append_history(p, "Xfer", "Refer failed.");
      /* Failure of some kind */
      p->refer->status = REFER_FAILED;
      transmit_notify_with_sipfrag(p, seqno, "503 Service Unavailable", TRUE);
      ast_clear_flag(&p->flags[0], SIP_GOTREFER);  
      res = -1;
   }
   return res;
}

static int handle_request_register	(	struct sip_pvt *	p,
		struct sip_request *	req,
		struct sockaddr_in *	sin,
		char *	e
	)			[static]

Handle incoming REGISTER request.

Definition at line 14594 of file chan_sip.c.

References append_history, ast_inet_ntoa(), ast_log(), ast_test_flag, ast_verbose(), AUTH_NOT_FOUND, AUTH_SECRET_FAILED, AUTH_UNKNOWN_DOMAIN, AUTH_USERNAME_MISMATCH, check_via(), copy_request(), DEFAULT_TRANS_TIMEOUT, get_header(), sip_pvt::initreq, LOG_NOTICE, register_verify(), SIP_PKT_DEBUG, and sip_scheddestroy().

Referenced by handle_request().

{
   enum check_auth_result res;

   /* Use this as the basis */
   if (ast_test_flag(req, SIP_PKT_DEBUG))
      ast_verbose("Using latest REGISTER request as basis request\n");
   copy_request(&p->initreq, req);
   check_via(p, req);
   if ((res = register_verify(p, sin, req, e)) < 0) {
      const char *reason = "";

      switch (res) {
      case AUTH_SECRET_FAILED:
         reason = "Wrong password";
         break;
      case AUTH_USERNAME_MISMATCH:
         reason = "Username/auth name mismatch";
         break;
      case AUTH_NOT_FOUND:
         reason = "No matching peer found";
         break;
      case AUTH_UNKNOWN_DOMAIN:
         reason = "Not a local domain";
         break;
      default:
         break;
      }
      ast_log(LOG_NOTICE, "Registration from '%s' failed for '%s' - %s\n",
         get_header(req, "To"), ast_inet_ntoa(sin->sin_addr),
         reason);
   }
   if (res < 1) {
      /* Destroy the session, but keep us around for just a bit in case they don't
         get our 200 OK */
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
   }
   append_history(p, "RegRequest", "%s : Account %s", res ? "Failed": "Succeeded", get_header(req, "To"));
   return res;
}

static int handle_request_subscribe	(	struct sip_pvt *	p,
		struct sip_request *	req,
		struct sockaddr_in *	sin,
		int	seqno,
		char *	e
	)			[static]

Handle incoming SUBSCRIBE request.

Definition at line 14303 of file chan_sip.c.

References append_history, AST_EXTENSION_REMOVED, ast_extension_state(), ast_extension_state2str(), ast_extension_state_add(), ast_inet_ntoa(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_set_flag, ast_strdupa, ast_string_field_build, ast_string_field_set, ast_strlen_zero(), ast_test_flag, ast_verbose(), ASTOBJ_UNLOCK, ASTOBJ_UNREF, ASTOBJ_WRLOCK, AUTH_CHALLENGE_SENT, AUTH_FAKE_AUTH, sip_pvt::autokillid, build_contact(), cb_extensionstate(), check_user_full(), check_via(), context, copy_request(), CPIM_PIDF_XML, DIALOG_INFO_XML, sip_pvt::dialogver, event, sip_pvt::expiry, FALSE, sip_pvt::flags, get_destination(), get_header(), sip_request::headers, iflist, sip_pvt::initreq, sip_pvt::lastinvite, sip_pvt::laststate, sip_pvt::lock, LOG_DEBUG, LOG_NOTICE, LOG_WARNING, sip_peer::mailbox, make_our_tag(), sip_request::method, sip_peer::mwipvt, sip_pvt::next, NONE, option_debug, parse_ok_contact(), PIDF_XML, sip_pvt::relatedpeer, sip_pvt::sa, sip_cancel_destroy(), sip_destroy(), sip_destroy_peer(), sip_methods, SIP_NEEDDESTROY, SIP_PAGE2_ALLOWSUBSCRIBE, SIP_PKT_DEBUG, SIP_PKT_IGNORE, sip_scheddestroy(), sip_send_mwi_to_peer(), SIP_SUBSCRIBE, sipdebug, sip_pvt::stateid, sip_pvt::subscribed, sip_pvt::tag, cfsip_methods::text, transmit_fake_auth_response(), transmit_response(), transmit_response_reliable(), transmit_state_notify(), and XPIDF_XML.

Referenced by handle_request().

{
   int gotdest;
   int res = 0;
   int firststate = AST_EXTENSION_REMOVED;
   struct sip_peer *authpeer = NULL;
   const char *eventheader = get_header(req, "Event");   /* Get Event package name */
   const char *accept = get_header(req, "Accept");
   int resubscribe = (p->subscribed != NONE);
   char *temp, *event;

   if (p->initreq.headers) {  
      /* We already have a dialog */
      if (p->initreq.method != SIP_SUBSCRIBE) {
         /* This is a SUBSCRIBE within another SIP dialog, which we do not support */
         /* For transfers, this could happen, but since we haven't seen it happening, let us just refuse this */
         transmit_response(p, "403 Forbidden (within dialog)", req);
         /* Do not destroy session, since we will break the call if we do */
         if (option_debug)
            ast_log(LOG_DEBUG, "Got a subscription within the context of another call, can't handle that - %s (Method %s)\n", p->callid, sip_methods[p->initreq.method].text);
         return 0;
      } else if (ast_test_flag(req, SIP_PKT_DEBUG)) {
         if (option_debug) {
            if (resubscribe)
               ast_log(LOG_DEBUG, "Got a re-subscribe on existing subscription %s\n", p->callid);
            else
               ast_log(LOG_DEBUG, "Got a new subscription %s (possibly with auth)\n", p->callid);
         }
      }
   }

   /* Check if we have a global disallow setting on subscriptions. 
      if so, we don't have to check peer/user settings after auth, which saves a lot of processing
   */
   if (!global_allowsubscribe) {
      transmit_response(p, "403 Forbidden (policy)", req);
      ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
      return 0;
   }

   if (!ast_test_flag(req, SIP_PKT_IGNORE) && !resubscribe) {  /* Set up dialog, new subscription */
      /* Use this as the basis */
      if (ast_test_flag(req, SIP_PKT_DEBUG))
         ast_verbose("Creating new subscription\n");

      copy_request(&p->initreq, req);
      check_via(p, req);
   } else if (ast_test_flag(req, SIP_PKT_DEBUG) && ast_test_flag(req, SIP_PKT_IGNORE))
      ast_verbose("Ignoring this SUBSCRIBE request\n");

   /* Find parameters to Event: header value and remove them for now */
   if (ast_strlen_zero(eventheader)) {
      transmit_response(p, "489 Bad Event", req);
      if (option_debug > 1)
         ast_log(LOG_DEBUG, "Received SIP subscribe for unknown event package: <none>\n");
      ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
      return 0;
   }

   if ( (strchr(eventheader, ';'))) {
      event = ast_strdupa(eventheader);   /* Since eventheader is a const, we can't change it */
      temp = strchr(event, ';');       
      *temp = '\0';           /* Remove any options for now */
                     /* We might need to use them later :-) */
   } else
      event = (char *) eventheader;    /* XXX is this legal ? */

   /* Handle authentication */
   res = check_user_full(p, req, SIP_SUBSCRIBE, e, 0, sin, &authpeer);
   /* if an authentication response was sent, we are done here */
   if (res == AUTH_CHALLENGE_SENT) {
      if (authpeer)
         ASTOBJ_UNREF(authpeer, sip_destroy_peer);
      return 0;
   }
   if (res < 0) {
      if (res == AUTH_FAKE_AUTH) {
         ast_log(LOG_NOTICE, "Sending fake auth rejection for user %s\n", get_header(req, "From"));
         transmit_fake_auth_response(p, req, 1);
      } else {
         ast_log(LOG_NOTICE, "Failed to authenticate user %s for SUBSCRIBE\n", get_header(req, "From"));
         transmit_response_reliable(p, "403 Forbidden", req);
      }
      ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
      if (authpeer)
         ASTOBJ_UNREF(authpeer, sip_destroy_peer);
      return 0;
   }

   /* Check if this user/peer is allowed to subscribe at all */
   if (!ast_test_flag(&p->flags[1], SIP_PAGE2_ALLOWSUBSCRIBE)) {
      transmit_response(p, "403 Forbidden (policy)", req);
      ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
      if (authpeer)
         ASTOBJ_UNREF(authpeer, sip_destroy_peer);
      return 0;
   }

   /* Get destination right away */
   gotdest = get_destination(p, NULL);

   /* Initialize the context if it hasn't been already;
      note this is done _after_ handling any domain lookups,
      because the context specified there is for calls, not
      subscriptions
   */
   if (!ast_strlen_zero(p->subscribecontext))
      ast_string_field_set(p, context, p->subscribecontext);
   else if (ast_strlen_zero(p->context))
      ast_string_field_set(p, context, default_context);

   /* Get full contact header - this needs to be used as a request URI in NOTIFY's */
   parse_ok_contact(p, req);

   build_contact(p);
   if (gotdest) {
      transmit_response(p, "404 Not Found", req);
      ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
      if (authpeer)
         ASTOBJ_UNREF(authpeer, sip_destroy_peer);
      return 0;
   }

   /* Initialize tag for new subscriptions */   
   if (ast_strlen_zero(p->tag))
      make_our_tag(p->tag, sizeof(p->tag));

   if (!strcmp(event, "presence") || !strcmp(event, "dialog")) { /* Presence, RFC 3842 */
      if (authpeer)  /* No need for authpeer here */
         ASTOBJ_UNREF(authpeer, sip_destroy_peer);

      /* Header from Xten Eye-beam Accept: multipart/related, application/rlmi+xml, application/pidf+xml, application/xpidf+xml */
      /* Polycom phones only handle xpidf+xml, even if they say they can
         handle pidf+xml as well
      */
      if (strstr(p->useragent, "Polycom")) {
         p->subscribed = XPIDF_XML;
      } else if (strstr(accept, "application/pidf+xml")) {
         p->subscribed = PIDF_XML;         /* RFC 3863 format */
      } else if (strstr(accept, "application/dialog-info+xml")) {
         p->subscribed = DIALOG_INFO_XML;
         /* IETF draft: draft-ietf-sipping-dialog-package-05.txt */
      } else if (strstr(accept, "application/cpim-pidf+xml")) {
         p->subscribed = CPIM_PIDF_XML;    /* RFC 3863 format */
      } else if (strstr(accept, "application/xpidf+xml")) {
         p->subscribed = XPIDF_XML;        /* Early pre-RFC 3863 format with MSN additions (Microsoft Messenger) */
      } else if (ast_strlen_zero(accept)) {
         if (p->subscribed == NONE) { /* if the subscribed field is not already set, and there is no accept header... */
            transmit_response(p, "489 Bad Event", req);
  
            ast_log(LOG_WARNING,"SUBSCRIBE failure: no Accept header: pvt: stateid: %d, laststate: %d, dialogver: %d, subscribecont: '%s', subscribeuri: '%s'\n",
               p->stateid, p->laststate, p->dialogver, p->subscribecontext, p->subscribeuri);
            ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
            return 0;
         }
         /* if p->subscribed is non-zero, then accept is not obligatory; according to rfc 3265 section 3.1.3, at least.
            so, we'll just let it ride, keeping the value from a previous subscription, and not abort the subscription */
      } else {
         /* Can't find a format for events that we know about */
         char mybuf[200];
         snprintf(mybuf,sizeof(mybuf),"489 Bad Event (format %s)", accept);
         transmit_response(p, mybuf, req);
 
         ast_log(LOG_WARNING,"SUBSCRIBE failure: unrecognized format: '%s' pvt: subscribed: %d, stateid: %d, laststate: %d, dialogver: %d, subscribecont: '%s', subscribeuri: '%s'\n",
            accept, (int)p->subscribed, p->stateid, p->laststate, p->dialogver, p->subscribecontext, p->subscribeuri);
         ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
         return 0;
      }
   } else if (!strcmp(event, "message-summary")) { 
      if (!ast_strlen_zero(accept) && strcmp(accept, "application/simple-message-summary")) {
         /* Format requested that we do not support */
         transmit_response(p, "406 Not Acceptable", req);
         if (option_debug > 1)
            ast_log(LOG_DEBUG, "Received SIP mailbox subscription for unknown format: %s\n", accept);
         ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
         if (authpeer)  /* No need for authpeer here */
            ASTOBJ_UNREF(authpeer, sip_destroy_peer);
         return 0;
      }
      /* Looks like they actually want a mailbox status 
        This version of Asterisk supports mailbox subscriptions
        The subscribed URI needs to exist in the dial plan
        In most devices, this is configurable to the voicemailmain extension you use
      */
      if (!authpeer || ast_strlen_zero(authpeer->mailbox)) {
         transmit_response(p, "404 Not found (no mailbox)", req);
         ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
         ast_log(LOG_NOTICE, "Received SIP subscribe for peer without mailbox: %s\n", authpeer->name);
         if (authpeer)  /* No need for authpeer here */
            ASTOBJ_UNREF(authpeer, sip_destroy_peer);
         return 0;
      }

      p->subscribed = MWI_NOTIFICATION;
      if (authpeer->mwipvt && authpeer->mwipvt != p)  /* Destroy old PVT if this is a new one */
         /* We only allow one subscription per peer */
         sip_destroy(authpeer->mwipvt);
      authpeer->mwipvt = p;      /* Link from peer to pvt */
      p->relatedpeer = authpeer; /* Link from pvt to peer */
   } else { /* At this point, Asterisk does not understand the specified event */
      transmit_response(p, "489 Bad Event", req);
      if (option_debug > 1)
         ast_log(LOG_DEBUG, "Received SIP subscribe for unknown event package: %s\n", event);
      ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
      if (authpeer)  /* No need for authpeer here */
         ASTOBJ_UNREF(authpeer, sip_destroy_peer);
      return 0;
   }

   if (p->subscribed != MWI_NOTIFICATION && !resubscribe)
      p->stateid = ast_extension_state_add(p->context, p->exten, cb_extensionstate, p);

   if (!ast_test_flag(req, SIP_PKT_IGNORE) && p)
      p->lastinvite = seqno;
   if (p && !ast_test_flag(&p->flags[0], SIP_NEEDDESTROY)) {
      p->expiry = atoi(get_header(req, "Expires"));

      /* check if the requested expiry-time is within the approved limits from sip.conf */
      if (p->expiry > max_expiry)
         p->expiry = max_expiry;
      if (p->expiry < min_expiry && p->expiry > 0)
         p->expiry = min_expiry;

      if (sipdebug || option_debug > 1) {
         if (p->subscribed == MWI_NOTIFICATION && p->relatedpeer)
            ast_log(LOG_DEBUG, "Adding subscription for mailbox notification - peer %s Mailbox %s\n", p->relatedpeer->name, p->relatedpeer->mailbox);
         else
            ast_log(LOG_DEBUG, "Adding subscription for extension %s context %s for peer %s\n", p->exten, p->context, p->username);
      }
      if (p->autokillid > -1)
         sip_cancel_destroy(p);  /* Remove subscription expiry for renewals */
      if (p->expiry > 0)
         sip_scheddestroy(p, (p->expiry + 10) * 1000);   /* Set timer for destruction of call at expiration */

      if (p->subscribed == MWI_NOTIFICATION) {
         transmit_response(p, "200 OK", req);
         if (p->relatedpeer) {   /* Send first notification */
            ASTOBJ_WRLOCK(p->relatedpeer);
            sip_send_mwi_to_peer(p->relatedpeer);
            ASTOBJ_UNLOCK(p->relatedpeer);
         }
      } else {
         struct sip_pvt *p_old;

         if ((firststate = ast_extension_state(NULL, p->context, p->exten)) < 0) {

            ast_log(LOG_NOTICE, "Got SUBSCRIBE for extension %s@%s from %s, but there is no hint for that extension.\n", p->exten, p->context, ast_inet_ntoa(p->sa.sin_addr));
            transmit_response(p, "404 Not found", req);
            ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
            return 0;
         }

         transmit_response(p, "200 OK", req);
         transmit_state_notify(p, firststate, 1, FALSE); /* Send first notification */
         append_history(p, "Subscribestatus", "%s", ast_extension_state2str(firststate));
         /* hide the 'complete' exten/context in the refer_to field for later display */
         ast_string_field_build(p, subscribeuri, "%s@%s", p->exten, p->context);

         /* remove any old subscription from this peer for the same exten/context,
         as the peer has obviously forgotten about it and it's wasteful to wait
         for it to expire and send NOTIFY messages to the peer only to have them
         ignored (or generate errors)
         */
         ast_mutex_lock(&iflock);
         for (p_old = iflist; p_old; p_old = p_old->next) {
            if (p_old == p)
               continue;
            if (p_old->initreq.method != SIP_SUBSCRIBE)
               continue;
            if (p_old->subscribed == NONE)
               continue;
            ast_mutex_lock(&p_old->lock);
            if (!strcmp(p_old->username, p->username)) {
               if (!strcmp(p_old->exten, p->exten) &&
                   !strcmp(p_old->context, p->context)) {
                  ast_set_flag(&p_old->flags[0], SIP_NEEDDESTROY);
                  ast_mutex_unlock(&p_old->lock);
                  break;
               }
            }
            ast_mutex_unlock(&p_old->lock);
         }
         ast_mutex_unlock(&iflock);
      }
      if (!p->expiry)
         ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
   }
   return 1;
}

static void handle_response	(	struct sip_pvt *	p,
		int	resp,
		char *	rest,
		struct sip_request *	req,
		int	ignore,
		int	seqno
	)			[static]

Handle SIP response in dialogue.

Definition at line 12205 of file chan_sip.c.

References __sip_ack(), __sip_semi_ack(), AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_PROGRESS, ast_inet_ntoa(), ast_log(), ast_queue_control(), ast_queue_hangup(), ast_set_flag, ast_string_field_build, ast_string_field_set, ast_strlen_zero(), ast_test_flag, ast_verbose(), do_proxy_auth(), FALSE, find_sdp(), find_sip_method(), sip_pvt::flags, get_header(), gettag(), handle_response_invite(), handle_response_peerpoke(), handle_response_refer(), handle_response_register(), hangup_sip2cause(), ast_channel::hangupcause, LOG_DEBUG, LOG_NOTICE, LOG_WARNING, MAX_AUTHTRIES, sip_pvt::method, NONE, option_debug, option_verbose, sip_pvt::owner, parse_moved_contact(), process_sdp(), sip_pvt::refer, sip_pvt::relatedpeer, SIP_ACK, sip_alreadygone(), SIP_BYE, SIP_CANCEL, sip_cancel_destroy(), SIP_INFO, SIP_INVITE, SIP_MESSAGE, sip_methods, SIP_NEEDDESTROY, SIP_NOTIFY, SIP_OPTIONS, SIP_OUTGOING, SIP_PKT_DEBUG, SIP_PKT_IGNORE, SIP_REFER, SIP_REGISTER, sipdebug, stop_media_flows(), sip_pvt::subscribed, text, transmit_request(), VERBOSE_PREFIX_3, and XMIT_UNRELIABLE.

{
   struct ast_channel *owner;
   int sipmethod;
   int res = 1;
   const char *c = get_header(req, "Cseq");
   const char *msg = strchr(c, ' ');

   if (!msg)
      msg = "";
   else
      msg++;
   sipmethod = find_sip_method(msg);

   owner = p->owner;
   if (owner) 
      owner->hangupcause = hangup_sip2cause(resp);

   /* Acknowledge whatever it is destined for */
   if ((resp >= 100) && (resp <= 199))
      __sip_semi_ack(p, seqno, 0, sipmethod);
   else
      __sip_ack(p, seqno, 0, sipmethod);

   /* Get their tag if we haven't already */
   if (ast_strlen_zero(p->theirtag) || (resp >= 200)) {
      char tag[128];

      gettag(req, "To", tag, sizeof(tag));
      ast_string_field_set(p, theirtag, tag);
   }
   if (p->relatedpeer && p->method == SIP_OPTIONS) {
      /* We don't really care what the response is, just that it replied back. 
         Well, as long as it's not a 100 response...  since we might
         need to hang around for something more "definitive" */
      if (resp != 100)
         handle_response_peerpoke(p, resp, req);
   } else if (ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
      switch(resp) {
      case 100:   /* 100 Trying */
      case 101:   /* 101 Dialog establishment */
         if (sipmethod == SIP_INVITE) 
            handle_response_invite(p, resp, rest, req, seqno);
         break;
      case 183:   /* 183 Session Progress */
         if (sipmethod == SIP_INVITE) 
            handle_response_invite(p, resp, rest, req, seqno);
         break;
      case 180:   /* 180 Ringing */
         if (sipmethod == SIP_INVITE) 
            handle_response_invite(p, resp, rest, req, seqno);
         break;
      case 200:   /* 200 OK */
         p->authtries = 0; /* Reset authentication counter */
         if (sipmethod == SIP_MESSAGE || sipmethod == SIP_INFO) {
            /* We successfully transmitted a message 
               or a video update request in INFO */
            /* Nothing happens here - the message is inside a dialog */
         } else if (sipmethod == SIP_INVITE) {
            handle_response_invite(p, resp, rest, req, seqno);
         } else if (sipmethod == SIP_NOTIFY) {
            /* They got the notify, this is the end */
            if (p->owner) {
               if (!p->refer) {
                  ast_log(LOG_WARNING, "Notify answer on an owned channel? - %s\n", p->owner->name);
                  ast_queue_hangup(p->owner);
               } else if (option_debug > 3) 
                  ast_log(LOG_DEBUG, "Got OK on REFER Notify message\n");
            } else {
               if (p->subscribed == NONE) 
                  ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
            }
         } else if (sipmethod == SIP_REGISTER) 
            res = handle_response_register(p, resp, rest, req, ignore, seqno);
         else if (sipmethod == SIP_BYE)      /* Ok, we're ready to go */
            ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
         break;
      case 202:   /* Transfer accepted */
         if (sipmethod == SIP_REFER) 
            handle_response_refer(p, resp, rest, req, seqno);
         break;
      case 401: /* Not www-authorized on SIP method */
         if (sipmethod == SIP_INVITE)
            handle_response_invite(p, resp, rest, req, seqno);
         else if (sipmethod == SIP_REFER)
            handle_response_refer(p, resp, rest, req, seqno);
         else if (p->registry && sipmethod == SIP_REGISTER)
            res = handle_response_register(p, resp, rest, req, ignore, seqno);
         else {
            ast_log(LOG_WARNING, "Got authentication request (401) on unknown %s to '%s'\n", sip_methods[sipmethod].text, get_header(req, "To"));
            ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
         }
         break;
      case 403: /* Forbidden - we failed authentication */
         if (sipmethod == SIP_INVITE)
            handle_response_invite(p, resp, rest, req, seqno);
         else if (p->registry && sipmethod == SIP_REGISTER) 
            res = handle_response_register(p, resp, rest, req, ignore, seqno);
         else {
            ast_log(LOG_WARNING, "Forbidden - maybe wrong password on authentication for %s\n", msg);
            ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
         }
         break;
      case 404: /* Not found */
         if (p->registry && sipmethod == SIP_REGISTER)
            res = handle_response_register(p, resp, rest, req, ignore, seqno);
         else if (sipmethod == SIP_INVITE)
            handle_response_invite(p, resp, rest, req, seqno);
         else if (owner)
            ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
         break;
      case 407: /* Proxy auth required */
         if (sipmethod == SIP_INVITE)
            handle_response_invite(p, resp, rest, req, seqno);
         else if (sipmethod == SIP_REFER)
            handle_response_refer(p, resp, rest, req, seqno);
         else if (p->registry && sipmethod == SIP_REGISTER)
            res = handle_response_register(p, resp, rest, req, ignore, seqno);
         else if (sipmethod == SIP_BYE) {
            if (ast_strlen_zero(p->authname))
               ast_log(LOG_WARNING, "Asked to authenticate %s, to %s:%d but we have no matching peer!\n",
                     msg, ast_inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));
               ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
            if ((p->authtries == MAX_AUTHTRIES) || do_proxy_auth(p, req, "Proxy-Authenticate", "Proxy-Authorization", sipmethod, 0)) {
               ast_log(LOG_NOTICE, "Failed to authenticate on %s to '%s'\n", msg, get_header(&p->initreq, "From"));
               ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
            }
         } else   /* We can't handle this, giving up in a bad way */
            ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 

         break;
      case 481: /* Call leg does not exist */
         if (sipmethod == SIP_INVITE) {
            handle_response_invite(p, resp, rest, req, seqno);
         } else if (sipmethod == SIP_REFER) {
            handle_response_refer(p, resp, rest, req, seqno);
         } else if (sipmethod == SIP_BYE) {
            /* The other side has no transaction to bye,
            just assume it's all right then */
            ast_log(LOG_WARNING, "Remote host can't match request %s to call '%s'. Giving up.\n", sip_methods[sipmethod].text, p->callid);
         } else if (sipmethod == SIP_CANCEL) {
            /* The other side has no transaction to cancel,
            just assume it's all right then */
            ast_log(LOG_WARNING, "Remote host can't match request %s to call '%s'. Giving up.\n", sip_methods[sipmethod].text, p->callid);
         } else {
            ast_log(LOG_WARNING, "Remote host can't match request %s to call '%s'. Giving up.\n", sip_methods[sipmethod].text, p->callid);
            /* Guessing that this is not an important request */
         }
         break;
      case 487:
         if (sipmethod == SIP_INVITE)
            handle_response_invite(p, resp, rest, req, seqno);
         break;
      case 488: /* Not acceptable here - codec error */
         if (sipmethod == SIP_INVITE)
            handle_response_invite(p, resp, rest, req, seqno);
         break;
      case 491: /* Pending */
         if (sipmethod == SIP_INVITE)
            handle_response_invite(p, resp, rest, req, seqno);
         else {
            if (option_debug)
               ast_log(LOG_DEBUG, "Got 491 on %s, unspported. Call ID %s\n", sip_methods[sipmethod].text, p->callid);
            ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
         }
         break;
      case 501: /* Not Implemented */
         if (sipmethod == SIP_INVITE)
            handle_response_invite(p, resp, rest, req, seqno);
         else if (sipmethod == SIP_REFER)
            handle_response_refer(p, resp, rest, req, seqno);
         else
            ast_log(LOG_WARNING, "Host '%s' does not implement '%s'\n", ast_inet_ntoa(p->sa.sin_addr), msg);
         break;
      case 603:   /* Declined transfer */
         if (sipmethod == SIP_REFER) {
            handle_response_refer(p, resp, rest, req, seqno);
            break;
         }
         /* Fallthrough */
      default:
         if ((resp >= 300) && (resp < 700)) {
            /* Fatal response */
            if ((option_verbose > 2) && (resp != 487))
               ast_verbose(VERBOSE_PREFIX_3 "Got SIP response %d \"%s\" back from %s\n", resp, rest, ast_inet_ntoa(p->sa.sin_addr));
   
            if (sipmethod == SIP_INVITE)
               stop_media_flows(p); /* Immediately stop RTP, VRTP and UDPTL as applicable */

            /* XXX Locking issues?? XXX */
            switch(resp) {
            case 300: /* Multiple Choices */
            case 301: /* Moved permenantly */
            case 302: /* Moved temporarily */
            case 305: /* Use Proxy */
               parse_moved_contact(p, req);
               /* Fall through */
            case 486: /* Busy here */
            case 600: /* Busy everywhere */
            case 603: /* Decline */
               if (p->owner)
                  ast_queue_control(p->owner, AST_CONTROL_BUSY);
               break;
            case 482: /*
               \note SIP is incapable of performing a hairpin call, which
               is yet another failure of not having a layer 2 (again, YAY
                IETF for thinking ahead).  So we treat this as a call
                forward and hope we end up at the right place... */
               if (option_debug)
                  ast_log(LOG_DEBUG, "Hairpin detected, setting up call forward for what it's worth\n");
               if (p->owner)
                  ast_string_field_build(p->owner, call_forward,
                               "Local/%s@%s", p->username, p->context);
               /* Fall through */
            case 480: /* Temporarily Unavailable */
            case 404: /* Not Found */
            case 410: /* Gone */
            case 400: /* Bad Request */
            case 500: /* Server error */
               if (sipmethod == SIP_REFER) {
                  handle_response_refer(p, resp, rest, req, seqno);
                  break;
               }
               /* Fall through */
            case 503: /* Service Unavailable */
            case 504: /* Server Timeout */
               if (owner)
                  ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
               break;
            default:
               /* Send hangup */ 
               if (owner && sipmethod != SIP_MESSAGE && sipmethod != SIP_INFO)
                  ast_queue_hangup(p->owner);
               break;
            }
            /* ACK on invite */
            if (sipmethod == SIP_INVITE) 
               transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
            if (sipmethod != SIP_MESSAGE && sipmethod != SIP_INFO) 
               sip_alreadygone(p);
            if (!p->owner)
               ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
         } else if ((resp >= 100) && (resp < 200)) {
            if (sipmethod == SIP_INVITE) {
               if (!ast_test_flag(req, SIP_PKT_IGNORE))
                  sip_cancel_destroy(p);
               if (find_sdp(req))
                  process_sdp(p, req);
               if (p->owner) {
                  /* Queue a progress frame */
                  ast_queue_control(p->owner, AST_CONTROL_PROGRESS);
               }
            }
         } else
            ast_log(LOG_NOTICE, "Dont know how to handle a %d %s response from %s\n", resp, rest, p->owner ? p->owner->name : ast_inet_ntoa(p->sa.sin_addr));
      }
   } else { 
      /* Responses to OUTGOING SIP requests on INCOMING calls 
         get handled here. As well as out-of-call message responses */
      if (ast_test_flag(req, SIP_PKT_DEBUG))
         ast_verbose("SIP Response message for INCOMING dialog %s arrived\n", msg);

      if (sipmethod == SIP_INVITE && resp == 200) {
         /* Tags in early session is replaced by the tag in 200 OK, which is 
         the final reply to our INVITE */
         char tag[128];

         gettag(req, "To", tag, sizeof(tag));
         ast_string_field_set(p, theirtag, tag);
      }

      switch(resp) {
      case 200:
         if (sipmethod == SIP_INVITE) {
            handle_response_invite(p, resp, rest, req, seqno);
         } else if (sipmethod == SIP_CANCEL) {
            if (option_debug)
               ast_log(LOG_DEBUG, "Got 200 OK on CANCEL\n");

            /* Wait for 487, then destroy */
         } else if (sipmethod == SIP_NOTIFY) {
            /* They got the notify, this is the end */
            if (p->owner) {
               if (p->refer) {
                  if (option_debug)
                     ast_log(LOG_DEBUG, "Got 200 OK on NOTIFY for transfer\n");
               } else
                  ast_log(LOG_WARNING, "Notify answer on an owned channel?\n");
               /* ast_queue_hangup(p->owner); Disabled */
            } else {
               if (!p->subscribed && !p->refer)
                  ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
            }
         } else if (sipmethod == SIP_BYE)
            ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
         else if (sipmethod == SIP_MESSAGE || sipmethod == SIP_INFO)
            /* We successfully transmitted a message or
               a video update request in INFO */
            ;
         else if (sipmethod == SIP_BYE) 
            /* Ok, we're ready to go */
            ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
         break;
      case 202:   /* Transfer accepted */
         if (sipmethod == SIP_REFER) 
            handle_response_refer(p, resp, rest, req, seqno);
         break;
      case 401:   /* www-auth */
      case 407:
         if (sipmethod == SIP_REFER)
            handle_response_refer(p, resp, rest, req, seqno);
         else if (sipmethod == SIP_INVITE) 
            handle_response_invite(p, resp, rest, req, seqno);
         else if (sipmethod == SIP_BYE) {
            char *auth, *auth2;

            auth = (resp == 407 ? "Proxy-Authenticate" : "WWW-Authenticate");
            auth2 = (resp == 407 ? "Proxy-Authorization" : "Authorization");
            if ((p->authtries == MAX_AUTHTRIES) || do_proxy_auth(p, req, auth, auth2, sipmethod, 0)) {
               ast_log(LOG_NOTICE, "Failed to authenticate on %s to '%s'\n", msg, get_header(&p->initreq, "From"));
               ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
            }
         }
         break;
      case 481:   /* Call leg does not exist */
         if (sipmethod == SIP_INVITE) {
            /* Re-invite failed */
            handle_response_invite(p, resp, rest, req, seqno);
         } else if (sipmethod == SIP_BYE) {
            ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
         } else if (sipdebug) {
            ast_log  (LOG_DEBUG, "Remote host can't match request %s to call '%s'. Giving up\n", sip_methods[sipmethod].text, p->callid);
         }
         break;
      case 501: /* Not Implemented */
         if (sipmethod == SIP_INVITE) 
            handle_response_invite(p, resp, rest, req, seqno);
         else if (sipmethod == SIP_REFER) 
            handle_response_refer(p, resp, rest, req, seqno);
         break;
      case 603:   /* Declined transfer */
         if (sipmethod == SIP_REFER) {
            handle_response_refer(p, resp, rest, req, seqno);
            break;
         }
         /* Fallthrough */
      default: /* Errors without handlers */
         if ((resp >= 100) && (resp < 200)) {
            if (sipmethod == SIP_INVITE) {   /* re-invite */
               if (!ast_test_flag(req, SIP_PKT_IGNORE))
                  sip_cancel_destroy(p);
            }
         }
         if ((resp >= 300) && (resp < 700)) {
            if ((option_verbose > 2) && (resp != 487))
               ast_verbose(VERBOSE_PREFIX_3 "Incoming call: Got SIP response %d \"%s\" back from %s\n", resp, rest, ast_inet_ntoa(p->sa.sin_addr));
            switch(resp) {
            case 488: /* Not acceptable here - codec error */
            case 603: /* Decline */
            case 500: /* Server error */
            case 503: /* Service Unavailable */
            case 504: /* Server timeout */

               if (sipmethod == SIP_INVITE) {   /* re-invite failed */
                  sip_cancel_destroy(p);
               }
               break;
            }
         }
         break;
      }
   }
}

static void handle_response_invite	(	struct sip_pvt *	p,
		int	resp,
		char *	rest,
		struct sip_request *	req,
		int	seqno
	)			[static]

Handle SIP response to INVITE dialogue.

Bug:

Is there any way we can go back to the audio call on both sides here?

Definition at line 11663 of file chan_sip.c.

References ast_channel::_state, ast_bridged_channel(), AST_CONTROL_ANSWER, AST_CONTROL_CONGESTION, AST_CONTROL_PROGRESS, AST_CONTROL_RINGING, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_null_frame, ast_queue_control(), ast_queue_frame(), ast_queue_hangup(), ast_rtp_set_rtptimers_onhold(), ast_sched_del(), ast_set_flag, ast_setstate(), AST_STATE_RINGING, AST_STATE_UP, ast_string_field_free, ast_test_flag, authenticate(), build_route(), check_pendings(), DEC_CALL_LIMIT, DEC_CALL_RINGING, DEFAULT_TRANS_TIMEOUT, do_proxy_auth(), FALSE, find_sdp(), sip_pvt::flags, get_header(), sip_pvt::initid, INV_CALLING, INV_COMPLETED, INV_EARLY_MEDIA, INV_PROCEEDING, INV_TERMINATED, sip_pvt::invitestate, sip_pvt::lock, LOG_DEBUG, LOG_ERROR, LOG_NOTICE, LOG_WARNING, MAX_AUTHTRIES, option_debug, sip_pvt::owner, parse_ok_contact(), process_sdp(), PROXY_AUTH, sched, set_address_from_contact(), SIP_ACK, sip_alreadygone(), SIP_ALREADYGONE, sip_cancel_destroy(), sip_handle_t38_reinvite(), SIP_INVITE, SIP_NEEDDESTROY, SIP_OUTGOING, SIP_PENDINGBYE, SIP_PKT_IGNORE, sip_scheddestroy(), sip_tech, sip_tech_info, t38properties::state, sip_pvt::t38, T38_DISABLED, T38_ENABLED, T38_LOCAL_DIRECT, T38_LOCAL_REINVITE, T38_PEER_REINVITE, ast_channel::tech, ast_channel::tech_pvt, transmit_request(), TRUE, ast_channel_tech::type, sip_pvt::udptl, update_call_counter(), WWW_AUTH, and XMIT_UNRELIABLE.

Referenced by handle_response().

{
   int outgoing = ast_test_flag(&p->flags[0], SIP_OUTGOING);
   int res = 0;
   int reinvite = (p->owner && p->owner->_state == AST_STATE_UP);
   struct ast_channel *bridgepeer = NULL;
   
   if (option_debug > 3) {
      if (reinvite)
         ast_log(LOG_DEBUG, "SIP response %d to RE-invite on %s call %s\n", resp, outgoing ? "outgoing" : "incoming", p->callid);
      else
         ast_log(LOG_DEBUG, "SIP response %d to standard invite\n", resp);
   }

   if (ast_test_flag(&p->flags[0], SIP_ALREADYGONE)) { /* This call is already gone */
      if (option_debug)
         ast_log(LOG_DEBUG, "Got response on call that is already terminated: %s (ignoring)\n", p->callid);
      return;
   }

   /* Acknowledge sequence number - This only happens on INVITE from SIP-call */
   if (p->initid > -1) {
      /* Don't auto congest anymore since we've gotten something useful back */
      ast_sched_del(sched, p->initid);
      p->initid = -1;
   }

   /* RFC3261 says we must treat every 1xx response (but not 100)
      that we don't recognize as if it was 183.
   */
   if (resp > 100 && resp < 200 && resp!=101 && resp != 180 && resp != 183)
      resp = 183;

   /* Any response between 100 and 199 is PROCEEDING */
   if (resp >= 100 && resp < 200 && p->invitestate == INV_CALLING)
      p->invitestate = INV_PROCEEDING;
 
   /* Final response, not 200 ? */
   if (resp >= 300 && (p->invitestate == INV_CALLING || p->invitestate == INV_PROCEEDING || p->invitestate == INV_EARLY_MEDIA ))
      p->invitestate = INV_COMPLETED;
      

   switch (resp) {
   case 100:   /* Trying */
   case 101:   /* Dialog establishment */
      if (!ast_test_flag(req, SIP_PKT_IGNORE))
         sip_cancel_destroy(p);
      check_pendings(p);
      break;

   case 180:   /* 180 Ringing */
      if (!ast_test_flag(req, SIP_PKT_IGNORE))
         sip_cancel_destroy(p);
      if (!ast_test_flag(req, SIP_PKT_IGNORE) && p->owner) {
         ast_queue_control(p->owner, AST_CONTROL_RINGING);
         if (p->owner->_state != AST_STATE_UP) {
            ast_setstate(p->owner, AST_STATE_RINGING);
         }
      }
      if (find_sdp(req)) {
         p->invitestate = INV_EARLY_MEDIA;
         res = process_sdp(p, req);
         if (!ast_test_flag(req, SIP_PKT_IGNORE) && p->owner) {
            /* Queue a progress frame only if we have SDP in 180 */
            ast_queue_control(p->owner, AST_CONTROL_PROGRESS);
         }
      }
      check_pendings(p);
      break;

   case 183:   /* Session progress */
      if (!ast_test_flag(req, SIP_PKT_IGNORE))
         sip_cancel_destroy(p);
      /* Ignore 183 Session progress without SDP */
      if (find_sdp(req)) {
         p->invitestate = INV_EARLY_MEDIA;
         res = process_sdp(p, req);
         if (!ast_test_flag(req, SIP_PKT_IGNORE) && p->owner) {
            /* Queue a progress frame */
            ast_queue_control(p->owner, AST_CONTROL_PROGRESS);
         }
      }
      check_pendings(p);
      break;

   case 200:   /* 200 OK on invite - someone's answering our call */
      if (!ast_test_flag(req, SIP_PKT_IGNORE))
         sip_cancel_destroy(p);
      p->authtries = 0;
      if (find_sdp(req)) {
         if ((res = process_sdp(p, req)) && !ast_test_flag(req, SIP_PKT_IGNORE))
            if (!reinvite)
               /* This 200 OK's SDP is not acceptable, so we need to ack, then hangup */
               /* For re-invites, we try to recover */
               ast_set_flag(&p->flags[0], SIP_PENDINGBYE);  
      }

      /* Parse contact header for continued conversation */
      /* When we get 200 OK, we know which device (and IP) to contact for this call */
      /* This is important when we have a SIP proxy between us and the phone */
      if (outgoing) {
         update_call_counter(p, DEC_CALL_RINGING);
         parse_ok_contact(p, req);
         if(set_address_from_contact(p)) {
            /* Bad contact - we don't know how to reach this device */
            /* We need to ACK, but then send a bye */
            /* OEJ: Possible issue that may need a check:
               If we have a proxy route between us and the device,
               should we care about resolving the contact
               or should we just send it?
            */
            if (!ast_test_flag(req, SIP_PKT_IGNORE))
               ast_set_flag(&p->flags[0], SIP_PENDINGBYE);  
         } 

         /* Save Record-Route for any later requests we make on this dialogue */
         build_route(p, req, 1);
      }
      
      if (p->owner && (p->owner->_state == AST_STATE_UP) && (bridgepeer = ast_bridged_channel(p->owner))) { /* if this is a re-invite */
         struct sip_pvt *bridgepvt = NULL;

         if (!bridgepeer->tech) {
            ast_log(LOG_WARNING, "Ooooh.. no tech!  That's REALLY bad\n");
            break;
         }
         if (bridgepeer->tech == &sip_tech || bridgepeer->tech == &sip_tech_info) {
            bridgepvt = (struct sip_pvt*)(bridgepeer->tech_pvt);
            if (bridgepvt->udptl) {
               if (p->t38.state == T38_PEER_REINVITE) {
                  sip_handle_t38_reinvite(bridgepeer, p, 0);
                  ast_rtp_set_rtptimers_onhold(p->rtp);
                  if (p->vrtp)
                     ast_rtp_set_rtptimers_onhold(p->vrtp); /* Turn off RTP timers while we send fax */
               } else if (p->t38.state == T38_DISABLED && bridgepeer && (bridgepvt->t38.state == T38_ENABLED)) {
                  ast_log(LOG_WARNING, "RTP re-inivte after T38 session not handled yet !\n");
                  /* Insted of this we should somehow re-invite the other side of the bridge to RTP */
                  /* XXXX Should we really destroy this session here, without any response at all??? */
                  sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
               }
            } else {
               if (option_debug > 1)
                  ast_log(LOG_DEBUG, "Strange... The other side of the bridge does not have a udptl struct\n");
               ast_mutex_lock(&bridgepvt->lock);
               bridgepvt->t38.state = T38_DISABLED;
               ast_mutex_unlock(&bridgepvt->lock);
               if (option_debug)
                  ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", bridgepvt->t38.state, bridgepeer->tech->type);
               p->t38.state = T38_DISABLED;
               if (option_debug > 1)
                  ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
            }
         } else {
            /* Other side is not a SIP channel */
            if (option_debug > 1)
               ast_log(LOG_DEBUG, "Strange... The other side of the bridge is not a SIP channel\n");
            p->t38.state = T38_DISABLED;
            if (option_debug > 1)
               ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
         }
      }
      if ((p->t38.state == T38_LOCAL_REINVITE) || (p->t38.state == T38_LOCAL_DIRECT)) {
         /* If there was T38 reinvite and we are supposed to answer with 200 OK than this should set us to T38 negotiated mode */
         p->t38.state = T38_ENABLED;
         if (option_debug)
            ast_log(LOG_DEBUG, "T38 changed state to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
      }

      if (!ast_test_flag(req, SIP_PKT_IGNORE) && p->owner) {
         if (!reinvite) {
            ast_queue_control(p->owner, AST_CONTROL_ANSWER);
         } else { /* RE-invite */
            ast_queue_frame(p->owner, &ast_null_frame);
         }
      } else {
          /* It's possible we're getting an 200 OK after we've tried to disconnect
              by sending CANCEL */
         /* First send ACK, then send bye */
         if (!ast_test_flag(req, SIP_PKT_IGNORE))
            ast_set_flag(&p->flags[0], SIP_PENDINGBYE);  
      }
      /* If I understand this right, the branch is different for a non-200 ACK only */
      p->invitestate = INV_TERMINATED;
      transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, TRUE);
      check_pendings(p);
      break;
   case 407: /* Proxy authentication */
   case 401: /* Www auth */
      /* First we ACK */
      transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
      if (p->options)
         p->options->auth_type = (resp == 401 ? WWW_AUTH : PROXY_AUTH);

      /* Then we AUTH */
      ast_string_field_free(p, theirtag); /* forget their old tag, so we don't match tags when getting response */
      if (!ast_test_flag(req, SIP_PKT_IGNORE)) {
         char *authenticate = (resp == 401 ? "WWW-Authenticate" : "Proxy-Authenticate");
         char *authorization = (resp == 401 ? "Authorization" : "Proxy-Authorization");
         if (p->authtries < MAX_AUTHTRIES)
            p->invitestate = INV_CALLING;
         if ((p->authtries == MAX_AUTHTRIES) || do_proxy_auth(p, req, authenticate, authorization, SIP_INVITE, 1)) {
            ast_log(LOG_NOTICE, "Failed to authenticate on INVITE to '%s'\n", get_header(&p->initreq, "From"));
            ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
            sip_alreadygone(p);
            if (p->owner)
               ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
         }
      }
      break;

   case 403: /* Forbidden */
      /* First we ACK */
      transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
      ast_log(LOG_WARNING, "Received response: \"Forbidden\" from '%s'\n", get_header(&p->initreq, "From"));
      if (!ast_test_flag(req, SIP_PKT_IGNORE) && p->owner)
         ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
      ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
      sip_alreadygone(p);
      break;

   case 404: /* Not found */
      transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
      if (p->owner && !ast_test_flag(req, SIP_PKT_IGNORE))
         ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
      sip_alreadygone(p);
      break;

   case 481: /* Call leg does not exist */
      /* Could be REFER caused INVITE with replaces */
      ast_log(LOG_WARNING, "Re-invite to non-existing call leg on other UA. SIP dialog '%s'. Giving up.\n", p->callid);
      transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
      if (p->owner)
         ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
      break;
   case 487: /* Cancelled transaction */
      /* We have sent CANCEL on an outbound INVITE 
         This transaction is already scheduled to be killed by sip_hangup().
      */
      transmit_request(p, SIP_ACK, seqno, 0, 0);
      if (p->owner && !ast_test_flag(req, SIP_PKT_IGNORE))
         ast_queue_hangup(p->owner);
      else if (!ast_test_flag(req, SIP_PKT_IGNORE))
         update_call_counter(p, DEC_CALL_LIMIT);
      break;
   case 488: /* Not acceptable here */
      transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
      if (reinvite && p->udptl) {
         /* If this is a T.38 call, we should go back to 
            audio. If this is an audio call - something went
            terribly wrong since we don't renegotiate codecs,
            only IP/port .
         */
         p->t38.state = T38_DISABLED;
         /* Try to reset RTP timers */
         ast_rtp_set_rtptimers_onhold(p->rtp);
         ast_log(LOG_ERROR, "Got error on T.38 re-invite. Bad configuration. Peer needs to have T.38 disabled.\n");

         /*! \bug Is there any way we can go back to the audio call on both
            sides here? 
         */
         /* While figuring that out, hangup the call */
         if (p->owner && !ast_test_flag(req, SIP_PKT_IGNORE))
            ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
         ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
      } else {
         /* We can't set up this call, so give up */
         if (p->owner && !ast_test_flag(req, SIP_PKT_IGNORE))
            ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
         ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
      }
      break;
   case 491: /* Pending */
      /* we really should have to wait a while, then retransmit */
         /* We should support the retry-after at some point */
      /* At this point, we treat this as a congestion */
      transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
      if (p->owner && !ast_test_flag(req, SIP_PKT_IGNORE))
         ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
      ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
      break;

   case 501: /* Not implemented */
      transmit_request(p, SIP_ACK, seqno, 0, 0);
      if (p->owner)
         ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
      break;
   }
}

static void handle_response_peerpoke	(	struct sip_pvt *	p,
		int	resp,
		struct sip_request *	req
	)			[static]

Handle qualification responses (OPTIONS).

Definition at line 12145 of file chan_sip.c.

References ast_device_state_changed(), ast_log(), ast_sched_add(), ast_sched_del(), ast_set_flag, sip_peer::call, DEFAULT_FREQ_NOTOK, DEFAULT_FREQ_OK, EVENT_FLAG_SYSTEM, sip_pvt::flags, sip_peer::lastms, LOG_NOTICE, manager_event(), sip_peer::maxms, sip_peer::pokeexpire, sip_peer::ps, sip_pvt::relatedpeer, s, sched, SIP_NEEDDESTROY, and sip_poke_peer_s().

Referenced by handle_response().

{
   struct sip_peer *peer = p->relatedpeer;
   int statechanged, is_reachable, was_reachable;
   int pingtime = ast_tvdiff_ms(ast_tvnow(), peer->ps);

   /*
    * Compute the response time to a ping (goes in peer->lastms.)
    * -1 means did not respond, 0 means unknown,
    * 1..maxms is a valid response, >maxms means late response.
    */
   if (pingtime < 1) /* zero = unknown, so round up to 1 */
      pingtime = 1;

   /* Now determine new state and whether it has changed.
    * Use some helper variables to simplify the writing
    * of the expressions.
    */
   was_reachable = peer->lastms > 0 && peer->lastms <= peer->maxms;
   is_reachable = pingtime <= peer->maxms;
   statechanged = peer->lastms == 0 /* yes, unknown before */
      || was_reachable != is_reachable;

   peer->lastms = pingtime;
   peer->call = NULL;
   if (statechanged) {
      const char *s = is_reachable ? "Reachable" : "Lagged";

      ast_log(LOG_NOTICE, "Peer '%s' is now %s. (%dms / %dms)\n",
         peer->name, s, pingtime, peer->maxms);
      ast_device_state_changed("SIP/%s", peer->name);
      manager_event(EVENT_FLAG_SYSTEM, "PeerStatus",
         "Peer: SIP/%s\r\nPeerStatus: %s\r\nTime: %d\r\n",
         peer->name, s, pingtime);
   }

   if (peer->pokeexpire > -1)
      ast_sched_del(sched, peer->pokeexpire);
   ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 

   /* Try again eventually */
   peer->pokeexpire = ast_sched_add(sched,
      is_reachable ? DEFAULT_FREQ_OK : DEFAULT_FREQ_NOTOK,
      sip_poke_peer_s, peer);
}

static void handle_response_refer	(	struct sip_pvt *	p,
		int	resp,
		char *	rest,
		struct sip_request *	req,
		int	seqno
	)			[static]

Definition at line 11956 of file chan_sip.c.

References AST_CONTROL_CONGESTION, ast_inet_ntoa(), ast_log(), ast_queue_control(), ast_set_flag, ast_strlen_zero(), sip_pvt::authtries, do_proxy_auth(), sip_pvt::flags, get_header(), sip_pvt::initreq, LOG_DEBUG, LOG_NOTICE, LOG_WARNING, option_debug, sip_pvt::owner, sip_pvt::recv, sip_pvt::refer, REFER_ACCEPTED, REFER_FAILED, REFER_NOAUTH, sip_refer::refer_to, SIP_NEEDDESTROY, SIP_REFER, and sip_refer::status.

Referenced by handle_response().

{
   char *auth = "Proxy-Authenticate";
   char *auth2 = "Proxy-Authorization";

   /* If no refer structure exists, then do nothing */
   if (!p->refer)
      return;

   switch (resp) {
   case 202:   /* Transfer accepted */
      /* We need  to do something here */
      /* The transferee is now sending INVITE to target */
      p->refer->status = REFER_ACCEPTED;
      /* Now wait for next message */
      if (option_debug > 2)
         ast_log(LOG_DEBUG, "Got 202 accepted on transfer\n");
      /* We should hang along, waiting for NOTIFY's here */
      break;

   case 401:   /* Not www-authorized on SIP method */
   case 407:   /* Proxy auth */
      if (ast_strlen_zero(p->authname)) {
         ast_log(LOG_WARNING, "Asked to authenticate REFER to %s:%d but we have no matching peer or realm auth!\n",
            ast_inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));
         ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
      }
      if (resp == 401) {
         auth = "WWW-Authenticate";
         auth2 = "Authorization";
      }
      if ((p->authtries > 1) || do_proxy_auth(p, req, auth, auth2, SIP_REFER, 0)) {
         ast_log(LOG_NOTICE, "Failed to authenticate on REFER to '%s'\n", get_header(&p->initreq, "From"));
         p->refer->status = REFER_NOAUTH;
         ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
      }
      break;
   case 481: /* Call leg does not exist */

      /* A transfer with Replaces did not work */
      /* OEJ: We should Set flag, cancel the REFER, go back
      to original call - but right now we can't */
      ast_log(LOG_WARNING, "Remote host can't match REFER request to call '%s'. Giving up.\n", p->callid);
      if (p->owner)
         ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
      ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
      break;

   case 500:   /* Server error */
   case 501:   /* Method not implemented */
      /* Return to the current call onhold */
      /* Status flag needed to be reset */
      ast_log(LOG_NOTICE, "SIP transfer to %s failed, call miserably fails. \n", p->refer->refer_to);
      ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
      p->refer->status = REFER_FAILED;
      break;
   case 603:   /* Transfer declined */
      ast_log(LOG_NOTICE, "SIP transfer to %s declined, call miserably fails. \n", p->refer->refer_to);
      p->refer->status = REFER_FAILED;
      ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
      break;
   }
}

static int handle_response_register	(	struct sip_pvt *	p,
		int	resp,
		char *	rest,
		struct sip_request *	req,
		int	ignore,
		int	seqno
	)			[static]

Handle responses on REGISTER to services.

Definition at line 12021 of file chan_sip.c.

References __get_header(), ast_log(), ast_sched_add(), ast_sched_del(), ast_set_flag, ast_strlen_zero(), ASTOBJ_UNREF, sip_pvt::authtries, sip_registry::call, DEFAULT_TRANS_TIMEOUT, do_register_auth(), EVENT_FLAG_SYSTEM, sip_registry::expire, EXPIRY_GUARD_LIMIT, EXPIRY_GUARD_MIN, EXPIRY_GUARD_PCT, EXPIRY_GUARD_SECS, sip_pvt::flags, get_header(), sip_pvt::initreq, LOG_DEBUG, LOG_NOTICE, LOG_WARNING, manager_event(), MAX, MAX_AUTHTRIES, option_debug, sip_registry::refresh, REG_STATE_REGISTERED, sip_registry::regattempts, sip_pvt::registry, sip_registry::regstate, regstate2str(), sip_registry::regtime, sched, SIP_NEEDDESTROY, sip_registry_destroy(), sip_reregister(), sip_scheddestroy(), sipdebug, strcasestr(), and sip_registry::timeout.

Referenced by handle_response().

{
   int expires, expires_ms;
   struct sip_registry *r;
   r=p->registry;

   switch (resp) {
   case 401:   /* Unauthorized */
      if ((p->authtries == MAX_AUTHTRIES) || do_register_auth(p, req, "WWW-Authenticate", "Authorization")) {
         ast_log(LOG_NOTICE, "Failed to authenticate on REGISTER to '%s@%s' (Tries %d)\n", p->registry->username, p->registry->hostname, p->authtries);
         ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
         }
      break;
   case 403:   /* Forbidden */
      ast_log(LOG_WARNING, "Forbidden - wrong password on authentication for REGISTER for '%s' to '%s'\n", p->registry->username, p->registry->hostname);
      if (global_regattempts_max)
         p->registry->regattempts = global_regattempts_max+1;
      ast_sched_del(sched, r->timeout);
      r->timeout = -1;
      ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
      break;
   case 404:   /* Not found */
      ast_log(LOG_WARNING, "Got 404 Not found on SIP register to service %s@%s, giving up\n", p->registry->username,p->registry->hostname);
      if (global_regattempts_max)
         p->registry->regattempts = global_regattempts_max+1;
      ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
      r->call = NULL;
      ast_sched_del(sched, r->timeout);
      r->timeout = -1;
      break;
   case 407:   /* Proxy auth */
      if ((p->authtries == MAX_AUTHTRIES) || do_register_auth(p, req, "Proxy-Authenticate", "Proxy-Authorization")) {
         ast_log(LOG_NOTICE, "Failed to authenticate on REGISTER to '%s' (tries '%d')\n", get_header(&p->initreq, "From"), p->authtries);
         ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
      }
      break;
   case 479:   /* SER: Not able to process the URI - address is wrong in register*/
      ast_log(LOG_WARNING, "Got error 479 on register to %s@%s, giving up (check config)\n", p->registry->username,p->registry->hostname);
      if (global_regattempts_max)
         p->registry->regattempts = global_regattempts_max+1;
      ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
      r->call = NULL;
      ast_sched_del(sched, r->timeout);
      r->timeout = -1;
      break;
   case 200:   /* 200 OK */
      if (!r) {
         ast_log(LOG_WARNING, "Got 200 OK on REGISTER that isn't a register\n");
         ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
         return 0;
      }

      r->regstate = REG_STATE_REGISTERED;
      r->regtime = time(NULL);      /* Reset time of last succesful registration */
      manager_event(EVENT_FLAG_SYSTEM, "Registry", "ChannelDriver: SIP\r\nDomain: %s\r\nStatus: %s\r\n", r->hostname, regstate2str(r->regstate));
      r->regattempts = 0;
      if (option_debug)
         ast_log(LOG_DEBUG, "Registration successful\n");
      if (r->timeout > -1) {
         if (option_debug)
            ast_log(LOG_DEBUG, "Cancelling timeout %d\n", r->timeout);
         ast_sched_del(sched, r->timeout);
      }
      r->timeout=-1;
      r->call = NULL;
      p->registry = NULL;
      /* Let this one hang around until we have all the responses */
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
      /* ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); */

      /* set us up for re-registering */
      /* figure out how long we got registered for */
      if (r->expire > -1)
         ast_sched_del(sched, r->expire);
      /* according to section 6.13 of RFC, contact headers override
         expires headers, so check those first */
      expires = 0;

      /* XXX todo: try to save the extra call */
      if (!ast_strlen_zero(get_header(req, "Contact"))) {
         const char *contact = NULL;
         const char *tmptmp = NULL;
         int start = 0;
         for(;;) {
            contact = __get_header(req, "Contact", &start);
            /* this loop ensures we get a contact header about our register request */
            if(!ast_strlen_zero(contact)) {
               if( (tmptmp=strstr(contact, p->our_contact))) {
                  contact=tmptmp;
                  break;
               }
            } else
               break;
         }
         tmptmp = strcasestr(contact, "expires=");
         if (tmptmp) {
            if (sscanf(tmptmp + 8, "%d;", &expires) != 1)
               expires = 0;
         }

      }
      if (!expires) 
         expires=atoi(get_header(req, "expires"));
      if (!expires)
         expires=default_expiry;

      expires_ms = expires * 1000;
      if (expires <= EXPIRY_GUARD_LIMIT)
         expires_ms -= MAX((expires_ms * EXPIRY_GUARD_PCT),EXPIRY_GUARD_MIN);
      else
         expires_ms -= EXPIRY_GUARD_SECS * 1000;
      if (sipdebug)
         ast_log(LOG_NOTICE, "Outbound Registration: Expiry for %s is %d sec (Scheduling reregistration in %d s)\n", r->hostname, expires, expires_ms/1000); 

      r->refresh= (int) expires_ms / 1000;

      /* Schedule re-registration before we expire */
      r->expire=ast_sched_add(sched, expires_ms, sip_reregister, r); 
      ASTOBJ_UNREF(r, sip_registry_destroy);
   }
   return 1;
}

static const char * hangup_cause2sip

(

int

cause

)

[static]

Convert Asterisk hangup causes to SIP codes.

 Possible values from causes.h
        AST_CAUSE_NOTDEFINED    AST_CAUSE_NORMAL        AST_CAUSE_BUSY
        AST_CAUSE_FAILURE       AST_CAUSE_CONGESTION    AST_CAUSE_UNALLOCATED

	In addition to these, a lot of PRI codes is defined in causes.h 
	...should we take care of them too ?
	
	Quote RFC 3398

   ISUP Cause value                        SIP response
   ----------------                        ------------
   1  unallocated number                   404 Not Found
   2  no route to network                  404 Not found
   3  no route to destination              404 Not found
   16 normal call clearing                 --- (*)
   17 user busy                            486 Busy here
   18 no user responding                   408 Request Timeout
   19 no answer from the user              480 Temporarily unavailable
   20 subscriber absent                    480 Temporarily unavailable
   21 call rejected                        403 Forbidden (+)
   22 number changed (w/o diagnostic)      410 Gone
   22 number changed (w/ diagnostic)       301 Moved Permanently
   23 redirection to new destination       410 Gone
   26 non-selected user clearing           404 Not Found (=)
   27 destination out of order             502 Bad Gateway
   28 address incomplete                   484 Address incomplete
   29 facility rejected                    501 Not implemented
   31 normal unspecified                   480 Temporarily unavailable

Definition at line 3228 of file chan_sip.c.

References AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, AST_CAUSE_CALL_REJECTED, AST_CAUSE_CHAN_NOT_IMPLEMENTED, AST_CAUSE_CONGESTION, AST_CAUSE_DESTINATION_OUT_OF_ORDER, AST_CAUSE_FACILITY_REJECTED, AST_CAUSE_FAILURE, AST_CAUSE_INVALID_NUMBER_FORMAT, AST_CAUSE_NO_ANSWER, AST_CAUSE_NO_ROUTE_DESTINATION, AST_CAUSE_NO_ROUTE_TRANSIT_NET, AST_CAUSE_NO_USER_RESPONSE, AST_CAUSE_NORMAL_UNSPECIFIED, AST_CAUSE_NOTDEFINED, AST_CAUSE_NUMBER_CHANGED, AST_CAUSE_SWITCH_CONGESTION, AST_CAUSE_UNALLOCATED, AST_CAUSE_USER_BUSY, ast_log(), LOG_DEBUG, and option_debug.

Referenced by sip_hangup().

{
   switch (cause) {
      case AST_CAUSE_UNALLOCATED:      /* 1 */
      case AST_CAUSE_NO_ROUTE_DESTINATION:   /* 3 IAX2: Can't find extension in context */
      case AST_CAUSE_NO_ROUTE_TRANSIT_NET:   /* 2 */
         return "404 Not Found";
      case AST_CAUSE_CONGESTION:    /* 34 */
      case AST_CAUSE_SWITCH_CONGESTION:   /* 42 */
         return "503 Service Unavailable";
      case AST_CAUSE_NO_USER_RESPONSE: /* 18 */
         return "408 Request Timeout";
      case AST_CAUSE_NO_ANSWER:     /* 19 */
         return "480 Temporarily unavailable";
      case AST_CAUSE_CALL_REJECTED:    /* 21 */
         return "403 Forbidden";
      case AST_CAUSE_NUMBER_CHANGED:      /* 22 */
         return "410 Gone";
      case AST_CAUSE_NORMAL_UNSPECIFIED:  /* 31 */
         return "480 Temporarily unavailable";
      case AST_CAUSE_INVALID_NUMBER_FORMAT:
         return "484 Address incomplete";
      case AST_CAUSE_USER_BUSY:
         return "486 Busy here";
      case AST_CAUSE_FAILURE:
         return "500 Server internal failure";
      case AST_CAUSE_FACILITY_REJECTED:   /* 29 */
         return "501 Not Implemented";
      case AST_CAUSE_CHAN_NOT_IMPLEMENTED:
         return "503 Service Unavailable";
      /* Used in chan_iax2 */
      case AST_CAUSE_DESTINATION_OUT_OF_ORDER:
         return "502 Bad Gateway";
      case AST_CAUSE_BEARERCAPABILITY_NOTAVAIL: /* Can't find codec to connect to host */
         return "488 Not Acceptable Here";
         
      case AST_CAUSE_NOTDEFINED:
      default:
         if (option_debug)
            ast_log(LOG_DEBUG, "AST hangup cause %d (no match found in SIP)\n", cause);
         return NULL;
   }

   /* Never reached */
   return 0;
}

static int hangup_sip2cause

(

int

cause

)

[static]

Convert SIP hangup causes to Asterisk hangup causes.

Definition at line 3116 of file chan_sip.c.

References AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, AST_CAUSE_BUSY, AST_CAUSE_CALL_REJECTED, AST_CAUSE_CONGESTION, AST_CAUSE_DESTINATION_OUT_OF_ORDER, AST_CAUSE_FACILITY_REJECTED, AST_CAUSE_FAILURE, AST_CAUSE_INTERWORKING, AST_CAUSE_INVALID_NUMBER_FORMAT, AST_CAUSE_NO_ANSWER, AST_CAUSE_NO_ROUTE_DESTINATION, AST_CAUSE_NO_USER_RESPONSE, AST_CAUSE_NORMAL, AST_CAUSE_NORMAL_TEMPORARY_FAILURE, AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE, AST_CAUSE_UNALLOCATED, and AST_CAUSE_USER_BUSY.

Referenced by handle_response().

{
   /* Possible values taken from causes.h */

   switch(cause) {
      case 401:   /* Unauthorized */
         return AST_CAUSE_CALL_REJECTED;
      case 403:   /* Not found */
         return AST_CAUSE_CALL_REJECTED;
      case 404:   /* Not found */
         return AST_CAUSE_UNALLOCATED;
      case 405:   /* Method not allowed */
         return AST_CAUSE_INTERWORKING;
      case 407:   /* Proxy authentication required */
         return AST_CAUSE_CALL_REJECTED;
      case 408:   /* No reaction */
         return AST_CAUSE_NO_USER_RESPONSE;
      case 409:   /* Conflict */
         return AST_CAUSE_NORMAL_TEMPORARY_FAILURE;
      case 410:   /* Gone */
         return AST_CAUSE_UNALLOCATED;
      case 411:   /* Length required */
         return AST_CAUSE_INTERWORKING;
      case 413:   /* Request entity too large */
         return AST_CAUSE_INTERWORKING;
      case 414:   /* Request URI too large */
         return AST_CAUSE_INTERWORKING;
      case 415:   /* Unsupported media type */
         return AST_CAUSE_INTERWORKING;
      case 420:   /* Bad extension */
         return AST_CAUSE_NO_ROUTE_DESTINATION;
      case 480:   /* No answer */
         return AST_CAUSE_NO_ANSWER;
      case 481:   /* No answer */
         return AST_CAUSE_INTERWORKING;
      case 482:   /* Loop detected */
         return AST_CAUSE_INTERWORKING;
      case 483:   /* Too many hops */
         return AST_CAUSE_NO_ANSWER;
      case 484:   /* Address incomplete */
         return AST_CAUSE_INVALID_NUMBER_FORMAT;
      case 485:   /* Ambigous */
         return AST_CAUSE_UNALLOCATED;
      case 486:   /* Busy everywhere */
         return AST_CAUSE_BUSY;
      case 487:   /* Request terminated */
         return AST_CAUSE_INTERWORKING;
      case 488:   /* No codecs approved */
         return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
      case 491:   /* Request pending */
         return AST_CAUSE_INTERWORKING;
      case 493:   /* Undecipherable */
         return AST_CAUSE_INTERWORKING;
      case 500:   /* Server internal failure */
         return AST_CAUSE_FAILURE;
      case 501:   /* Call rejected */
         return AST_CAUSE_FACILITY_REJECTED;
      case 502:   
         return AST_CAUSE_DESTINATION_OUT_OF_ORDER;
      case 503:   /* Service unavailable */
         return AST_CAUSE_CONGESTION;
      case 504:   /* Gateway timeout */
         return AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE;
      case 505:   /* SIP version not supported */
         return AST_CAUSE_INTERWORKING;
      case 600:   /* Busy everywhere */
         return AST_CAUSE_USER_BUSY;
      case 603:   /* Decline */
         return AST_CAUSE_CALL_REJECTED;
      case 604:   /* Does not exist anywhere */
         return AST_CAUSE_UNALLOCATED;
      case 606:   /* Not acceptable */
         return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
      default:
         return AST_CAUSE_NORMAL;
   }
   /* Never reached */
   return 0;
}

static int init_req	(	struct sip_request *	req,
		int	sipmethod,
		const char *	recip
	)			[static]

Initialize SIP request.

Definition at line 5571 of file chan_sip.c.

References sip_methods, and cfsip_methods::text.

{
   /* Initialize a request */
   memset(req, 0, sizeof(*req));
        req->method = sipmethod;
   req->header[0] = req->data;
   snprintf(req->header[0], sizeof(req->data), "%s %s SIP/2.0\r\n", sip_methods[sipmethod].text, recip);
   req->len = strlen(req->header[0]);
   req->headers++;
   return 0;
}

static int init_resp	(	struct sip_request *	resp,
		const char *	msg
	)			[static]

Initialize SIP response, based on SIP request.

Definition at line 5558 of file chan_sip.c.

References SIP_RESPONSE.

{
   /* Initialize a response */
   memset(resp, 0, sizeof(*resp));
   resp->method = SIP_RESPONSE;
   resp->header[0] = resp->data;
   snprintf(resp->header[0], sizeof(resp->data), "SIP/2.0 %s\r\n", msg);
   resp->len = strlen(resp->header[0]);
   resp->headers++;
   return 0;
}

static void initialize_initreq	(	struct sip_pvt *	p,
		struct sip_request *	req
	)			[static]

Initialize the initital request packet in the pvt structure. This packet is used for creating replies and future requests in a dialog.

Definition at line 1619 of file chan_sip.c.

References ast_log(), ast_test_flag, ast_verbose(), copy_request(), sip_request::headers, sip_pvt::initreq, sip_request::lines, LOG_DEBUG, option_debug, parse_request(), and SIP_PKT_DEBUG.

Referenced by transmit_invite(), transmit_notify_with_mwi(), transmit_notify_with_sipfrag(), transmit_register(), transmit_reinvite_with_sdp(), transmit_reinvite_with_t38_sdp(), and transmit_sip_request().

{
   if (p->initreq.headers && option_debug) {
      ast_log(LOG_DEBUG, "Initializing already initialized SIP dialog %s (presumably reinvite)\n", p->callid);
   }
   /* Use this as the basis */
   copy_request(&p->initreq, req);
   parse_request(&p->initreq);
   if (ast_test_flag(req, SIP_PKT_DEBUG))
      ast_verbose("%d headers, %d lines\n", p->initreq.headers, p->initreq.lines);
}

static void initreqprep	(	struct sip_request *	req,
		struct sip_pvt *	p,
		int	sipmethod
	)			[static]

Initiate new SIP request to peer/user.

Definition at line 6647 of file chan_sip.c.

References add_header(), ast_build_string(), AST_DIGIT_ANYNUM, ast_inet_ntoa(), AST_PRES_ALLOWED, AST_PRES_RESTRICTION, ast_string_field_set, ast_strlen_zero(), ast_test_flag, ast_uri_encode(), build_contact(), build_rpid(), CALLERID_UNKNOWN, sip_pvt::callingpres, ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, DEFAULT_MAX_FORWARDS, exten, sip_pvt::flags, init_req(), sip_pvt::lastmsg, sip_pvt::ocseq, sip_pvt::options, sip_pvt::ourip, ourport, sip_pvt::owner, s, S_OR, sip_pvt::sa, SIP_INVITE, sip_methods, SIP_NOTIFY, SIP_SENDRPID, SIP_USEREQPHONE, STANDARD_SIP_PORT, sip_pvt::tag, cfsip_methods::text, sip_invite_param::uri_options, and sip_invite_param::vxml_url.

Referenced by sip_notify(), transmit_invite(), and transmit_notify_with_mwi().

{
   char invite_buf[256] = "";
   char *invite = invite_buf;
   size_t invite_max = sizeof(invite_buf);
   char from[256];
   char to[256];
   char tmp[BUFSIZ/2];
   char tmp2[BUFSIZ/2];
   const char *l = NULL, *n = NULL;
   const char *urioptions = "";

   if (ast_test_flag(&p->flags[0], SIP_USEREQPHONE)) {
      const char *s = p->username;  /* being a string field, cannot be NULL */

      /* Test p->username against allowed characters in AST_DIGIT_ANY
         If it matches the allowed characters list, then sipuser = ";user=phone"
         If not, then sipuser = ""
      */
      /* + is allowed in first position in a tel: uri */
      if (*s == '+')
         s++;
      for (; *s; s++) {
         if (!strchr(AST_DIGIT_ANYNUM, *s) )
            break;
      }
      /* If we have only digits, add ;user=phone to the uri */
      if (*s)
         urioptions = ";user=phone";
   }


   snprintf(p->lastmsg, sizeof(p->lastmsg), "Init: %s", sip_methods[sipmethod].text);

   if (p->owner) {
      l = p->owner->cid.cid_num;
      n = p->owner->cid.cid_name;
   }
   /* if we are not sending RPID and user wants his callerid restricted */
   if (!ast_test_flag(&p->flags[0], SIP_SENDRPID) &&
       ((p->callingpres & AST_PRES_RESTRICTION) != AST_PRES_ALLOWED)) {
      l = CALLERID_UNKNOWN;
      n = l;
   }
   if (ast_strlen_zero(l))
      l = default_callerid;
   if (ast_strlen_zero(n))
      n = l;
   /* Allow user to be overridden */
   if (!ast_strlen_zero(p->fromuser))
      l = p->fromuser;
   else /* Save for any further attempts */
      ast_string_field_set(p, fromuser, l);

   /* Allow user to be overridden */
   if (!ast_strlen_zero(p->fromname))
      n = p->fromname;
   else /* Save for any further attempts */
      ast_string_field_set(p, fromname, n);

   if (pedanticsipchecking) {
      ast_uri_encode(n, tmp, sizeof(tmp), 0);
      n = tmp;
      ast_uri_encode(l, tmp2, sizeof(tmp2), 0);
      l = tmp2;
   }

   if (ourport != STANDARD_SIP_PORT && ast_strlen_zero(p->fromdomain))
      snprintf(from, sizeof(from), "\"%s\" <sip:%s@%s:%d>;tag=%s", n, l, S_OR(p->fromdomain, ast_inet_ntoa(p->ourip)), ourport, p->tag);
   else
      snprintf(from, sizeof(from), "\"%s\" <sip:%s@%s>;tag=%s", n, l, S_OR(p->fromdomain, ast_inet_ntoa(p->ourip)), p->tag);

   /* If we're calling a registered SIP peer, use the fullcontact to dial to the peer */
   if (!ast_strlen_zero(p->fullcontact)) {
      /* If we have full contact, trust it */
      ast_build_string(&invite, &invite_max, "%s", p->fullcontact);
   } else {
      /* Otherwise, use the username while waiting for registration */
      ast_build_string(&invite, &invite_max, "sip:");
      if (!ast_strlen_zero(p->username)) {
         n = p->username;
         if (pedanticsipchecking) {
            ast_uri_encode(n, tmp, sizeof(tmp), 0);
            n = tmp;
         }
         ast_build_string(&invite, &invite_max, "%s@", n);
      }
      ast_build_string(&invite, &invite_max, "%s", p->tohost);
      if (ntohs(p->sa.sin_port) != STANDARD_SIP_PORT)
         ast_build_string(&invite, &invite_max, ":%d", ntohs(p->sa.sin_port));
      ast_build_string(&invite, &invite_max, "%s", urioptions);
   }

   /* If custom URI options have been provided, append them */
   if (p->options && p->options->uri_options)
      ast_build_string(&invite, &invite_max, ";%s", p->options->uri_options);
   
   ast_string_field_set(p, uri, invite_buf);

   if (sipmethod == SIP_NOTIFY && !ast_strlen_zero(p->theirtag)) { 
      /* If this is a NOTIFY, use the From: tag in the subscribe (RFC 3265) */
      snprintf(to, sizeof(to), "<sip:%s>;tag=%s", p->uri, p->theirtag);
   } else if (p->options && p->options->vxml_url) {
      /* If there is a VXML URL append it to the SIP URL */
      snprintf(to, sizeof(to), "<%s>;%s", p->uri, p->options->vxml_url);
   } else 
      snprintf(to, sizeof(to), "<%s>", p->uri);
   
   init_req(req, sipmethod, p->uri);
   snprintf(tmp, sizeof(tmp), "%d %s", ++p->ocseq, sip_methods[sipmethod].text);

   add_header(req, "Via", p->via);
   /* SLD: FIXME?: do Route: here too?  I think not cos this is the first request.
    * OTOH, then we won't have anything in p->route anyway */
   /* Build Remote Party-ID and From */
   if (ast_test_flag(&p->flags[0], SIP_SENDRPID) && (sipmethod == SIP_INVITE)) {
      build_rpid(p);
      add_header(req, "From", p->rpid_from);
   } else 
      add_header(req, "From", from);
   add_header(req, "To", to);
   ast_string_field_set(p, exten, l);
   build_contact(p);
   add_header(req, "Contact", p->our_contact);
   add_header(req, "Call-ID", p->callid);
   add_header(req, "CSeq", tmp);
   if (!ast_strlen_zero(global_useragent))
      add_header(req, "User-Agent", global_useragent);
   add_header(req, "Max-Forwards", DEFAULT_MAX_FORWARDS);
   if (!ast_strlen_zero(p->rpid))
      add_header(req, "Remote-Party-ID", p->rpid);
}

static const char * insecure2str	(	int	port,
		int	invite
	)			const [static]

Convert Insecure setting to printable string.

Definition at line 9724 of file chan_sip.c.

Referenced by _sip_show_peer().

{
   if (port && invite)
      return "port,invite";
   else if (port)
      return "port";
   else if (invite)
      return "invite";
   else
      return "no";
}

static void list_route

(

struct sip_route *

route

)

[static]

List all routes - mostly for debugging.

Definition at line 7922 of file chan_sip.c.

References ast_verbose(), sip_route::hop, and sip_route::next.

Referenced by build_route().

{
   if (!route)
      ast_verbose("list_route: no route\n");
   else {
      for (;route; route = route->next)
         ast_verbose("list_route: hop: <%s>\n", route->hop);
   }
}

static int load_module

(

void

)

[static]

PBX load module - initialization.

Definition at line 17400 of file chan_sip.c.

References ast_channel_register(), ast_cli_register_multiple(), ast_custom_function_register(), ast_log(), ast_manager_register2(), AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_SUCCESS, ast_register_application(), ast_rtp_proto_register(), ast_udptl_proto_register(), ASTOBJ_CONTAINER_INIT, CHANNEL_MODULE_LOAD, checksipdomain_function, cli_sip, EVENT_FLAG_SYSTEM, io, io_context_create(), io_context_destroy(), LOG_ERROR, manager_sip_show_peer(), manager_sip_show_peers(), peerl, regl, reload_config(), restart_monitor(), sched, sched_context_create(), sched_context_destroy(), sip_addheader(), sip_dtmfmode(), sip_header_function, sip_poke_all_peers(), sip_rtp, sip_send_all_registers(), sip_tech, sip_udptl, sipchaninfo_function, sippeer_function, and userl.

{
   ASTOBJ_CONTAINER_INIT(&userl);   /* User object list */
   ASTOBJ_CONTAINER_INIT(&peerl);   /* Peer object list */
   ASTOBJ_CONTAINER_INIT(&regl); /* Registry object list */

   if (!(sched = sched_context_create())) {
      ast_log(LOG_ERROR, "Unable to create scheduler context\n");
      return AST_MODULE_LOAD_FAILURE;
   }

   if (!(io = io_context_create())) {
      ast_log(LOG_ERROR, "Unable to create I/O context\n");
      sched_context_destroy(sched);
      return AST_MODULE_LOAD_FAILURE;
   }

   sip_reloadreason = CHANNEL_MODULE_LOAD;

   if(reload_config(sip_reloadreason)) /* Load the configuration from sip.conf */
      return AST_MODULE_LOAD_DECLINE;

   /* Make sure we can register our sip channel type */
   if (ast_channel_register(&sip_tech)) {
      ast_log(LOG_ERROR, "Unable to register channel type 'SIP'\n");
      io_context_destroy(io);
      sched_context_destroy(sched);
      return AST_MODULE_LOAD_FAILURE;
   }

   /* Register all CLI functions for SIP */
   ast_cli_register_multiple(cli_sip, sizeof(cli_sip)/ sizeof(struct ast_cli_entry));

   /* Tell the RTP subdriver that we're here */
   ast_rtp_proto_register(&sip_rtp);

   /* Tell the UDPTL subdriver that we're here */
   ast_udptl_proto_register(&sip_udptl);

   /* Register dialplan applications */
   ast_register_application(app_dtmfmode, sip_dtmfmode, synopsis_dtmfmode, descrip_dtmfmode);
   ast_register_application(app_sipaddheader, sip_addheader, synopsis_sipaddheader, descrip_sipaddheader);

   /* Register dialplan functions */
   ast_custom_function_register(&sip_header_function);
   ast_custom_function_register(&sippeer_function);
   ast_custom_function_register(&sipchaninfo_function);
   ast_custom_function_register(&checksipdomain_function);

   /* Register manager commands */
   ast_manager_register2("SIPpeers", EVENT_FLAG_SYSTEM, manager_sip_show_peers,
         "List SIP peers (text format)", mandescr_show_peers);
   ast_manager_register2("SIPshowpeer", EVENT_FLAG_SYSTEM, manager_sip_show_peer,
         "Show SIP peer (text format)", mandescr_show_peer);

   sip_poke_all_peers();   
   sip_send_all_registers();
   
   /* And start the monitor for the first time */
   restart_monitor();

   return AST_MODULE_LOAD_SUCCESS;
}

static int local_attended_transfer	(	struct sip_pvt *	transferer,
		struct sip_dual *	current,
		struct sip_request *	req,
		int	seqno
	)			[static]

Find all call legs and bridge transferee with target called from handle_request_refer.

Definition at line 13694 of file chan_sip.c.

References ast_channel::_state, append_history, ast_bridged_channel(), ast_channel_unlock, ast_clear_flag, ast_hangup(), ast_log(), ast_mutex_unlock(), ast_set_flag, ast_state2str(), AST_STATE_RING, AST_STATE_RINGING, AST_STATE_UP, attempt_transfer(), sip_dual::chan1, sip_dual::chan2, sip_pvt::flags, get_sip_pvt_byid_locked(), sip_refer::localtransfer, sip_pvt::lock, LOG_DEBUG, option_debug, sip_pvt::owner, sip_pvt::refer, REFER_200OK, REFER_FAILED, sip_refer::replaces_callid, sip_refer::replaces_callid_fromtag, sip_refer::replaces_callid_totag, SIP_DEFER_BYE_ON_TRANSFER, SIP_GOTREFER, sipdebug, sip_refer::status, transmit_notify_with_sipfrag(), transmit_response(), and TRUE.

Referenced by handle_request_refer().

{
   struct sip_dual target;    /* Chan 1: Call from tranferer to Asterisk */
               /* Chan 2: Call from Asterisk to target */
   int res = 0;
   struct sip_pvt *targetcall_pvt;

   /* Check if the call ID of the replaces header does exist locally */
   if (!(targetcall_pvt = get_sip_pvt_byid_locked(transferer->refer->replaces_callid, transferer->refer->replaces_callid_totag, 
      transferer->refer->replaces_callid_fromtag))) {
      if (transferer->refer->localtransfer) {
         /* We did not find the refered call. Sorry, can't accept then */
         transmit_response(transferer, "202 Accepted", req);
         /* Let's fake a response from someone else in order
            to follow the standard */
         transmit_notify_with_sipfrag(transferer, seqno, "481 Call leg/transaction does not exist", TRUE);
         append_history(transferer, "Xfer", "Refer failed");
         ast_clear_flag(&transferer->flags[0], SIP_GOTREFER);  
         transferer->refer->status = REFER_FAILED;
         return -1;
      }
      /* Fall through for remote transfers that we did not find locally */
      if (option_debug > 2)
         ast_log(LOG_DEBUG, "SIP attended transfer: Not our call - generating INVITE with replaces\n");
      return 0;
   }

   /* Ok, we can accept this transfer */
   transmit_response(transferer, "202 Accepted", req);
   append_history(transferer, "Xfer", "Refer accepted");
   if (!targetcall_pvt->owner) { /* No active channel */
      if (option_debug > 3)
         ast_log(LOG_DEBUG, "SIP attended transfer: Error: No owner of target call\n");
      /* Cancel transfer */
      transmit_notify_with_sipfrag(transferer, seqno, "503 Service Unavailable", TRUE);
      append_history(transferer, "Xfer", "Refer failed");
      ast_clear_flag(&transferer->flags[0], SIP_GOTREFER);
      transferer->refer->status = REFER_FAILED;
      ast_mutex_unlock(&targetcall_pvt->lock);
      ast_channel_unlock(current->chan1);
      ast_channel_unlock(targetcall_pvt->owner);
      return -1;
   }

   /* We have a channel, find the bridge */
   target.chan1 = targetcall_pvt->owner;           /* Transferer to Asterisk */
   target.chan2 = ast_bridged_channel(targetcall_pvt->owner);  /* Asterisk to target */

   if (!target.chan2 || !(target.chan2->_state == AST_STATE_UP || target.chan2->_state == AST_STATE_RINGING) ) {
      /* Wrong state of new channel */
      if (option_debug > 3) {
         if (target.chan2) 
            ast_log(LOG_DEBUG, "SIP attended transfer: Error: Wrong state of target call: %s\n", ast_state2str(target.chan2->_state));
         else if (target.chan1->_state != AST_STATE_RING)
            ast_log(LOG_DEBUG, "SIP attended transfer: Error: No target channel\n");
         else
            ast_log(LOG_DEBUG, "SIP attended transfer: Attempting transfer in ringing state\n");
      }
   }

   /* Transfer */
   if (option_debug > 3 && sipdebug) {
      if (current->chan2)  /* We have two bridges */
         ast_log(LOG_DEBUG, "SIP attended transfer: trying to bridge %s and %s\n", target.chan1->name, current->chan2->name);
      else        /* One bridge, propably transfer of IVR/voicemail etc */
         ast_log(LOG_DEBUG, "SIP attended transfer: trying to make %s take over (masq) %s\n", target.chan1->name, current->chan1->name);
   }

   ast_set_flag(&transferer->flags[0], SIP_DEFER_BYE_ON_TRANSFER);   /* Delay hangup */

   /* Perform the transfer */
   res = attempt_transfer(current, &target);
   ast_mutex_unlock(&targetcall_pvt->lock);
   if (res) {
      /* Failed transfer */
      /* Could find better message, but they will get the point */
      transmit_notify_with_sipfrag(transferer, seqno, "486 Busy", TRUE);
      append_history(transferer, "Xfer", "Refer failed");
      if (targetcall_pvt->owner)
         ast_channel_unlock(targetcall_pvt->owner);
      /* Right now, we have to hangup, sorry. Bridge is destroyed */
      ast_hangup(transferer->owner);
   } else {
      /* Transfer succeeded! */

      /* Tell transferer that we're done. */
      transmit_notify_with_sipfrag(transferer, seqno, "200 OK", TRUE);
      append_history(transferer, "Xfer", "Refer succeeded");
      transferer->refer->status = REFER_200OK;
      if (targetcall_pvt->owner) {
         if (option_debug)
            ast_log(LOG_DEBUG, "SIP attended transfer: Unlocking channel %s\n", targetcall_pvt->owner->name);
         ast_channel_unlock(targetcall_pvt->owner);
      }
   }
   return 1;
}

static int lws2sws	(	char *	msgbuf,
		int	len
	)			[static]

Parse multiline SIP headers into one header This is enabled if pedanticsipchecking is enabled.

Definition at line 4524 of file chan_sip.c.

References t.

Referenced by sipsock_read().

{
   int h = 0, t = 0; 
   int lws = 0; 

   for (; h < len;) { 
      /* Eliminate all CRs */ 
      if (msgbuf[h] == '\r') { 
         h++; 
         continue; 
      } 
      /* Check for end-of-line */ 
      if (msgbuf[h] == '\n') { 
         /* Check for end-of-message */ 
         if (h + 1 == len) 
            break; 
         /* Check for a continuation line */ 
         if (msgbuf[h + 1] == ' ' || msgbuf[h + 1] == '\t') { 
            /* Merge continuation line */ 
            h++; 
            continue; 
         } 
         /* Propagate LF and start new line */ 
         msgbuf[t++] = msgbuf[h++]; 
         lws = 0;
         continue; 
      } 
      if (msgbuf[h] == ' ' || msgbuf[h] == '\t') { 
         if (lws) { 
            h++; 
            continue; 
         } 
         msgbuf[t++] = msgbuf[h++]; 
         lws = 1; 
         continue; 
      } 
      msgbuf[t++] = msgbuf[h++]; 
      if (lws) 
         lws = 0; 
   } 
   msgbuf[t] = '\0'; 
   return t; 
}

static void make_our_tag	(	char *	tagbuf,
		size_t	len
	)			[static]

Make our SIP dialog tag.

Definition at line 4196 of file chan_sip.c.

References ast_random().

Referenced by handle_request_invite(), handle_request_subscribe(), sip_alloc(), transmit_register(), and transmit_response_using_temp().

{
   snprintf(tagbuf, len, "as%08lx", ast_random());
}

static int manager_sip_show_peer	(	struct mansession *	s,
		const struct message *	m
	)			[static]

Show SIP peers in the manager API.

Definition at line 9969 of file chan_sip.c.

References _sip_show_peer(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), and s.

Referenced by load_module().

{
   const char *a[4];
   const char *peer;
   int ret;

   peer = astman_get_header(m,"Peer");
   if (ast_strlen_zero(peer)) {
      astman_send_error(s, m, "Peer: <name> missing.\n");
      return 0;
   }
   a[0] = "sip";
   a[1] = "show";
   a[2] = "peer";
   a[3] = peer;

   ret = _sip_show_peer(1, -1, s, m, 4, a);
   astman_append(s, "\r\n\r\n" );
   return ret;
}

static int manager_sip_show_peers	(	struct mansession *	s,
		const struct message *	m
	)			[static]

Show SIP peers in the manager API.

Definition at line 9520 of file chan_sip.c.

References _sip_show_peers(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_ack(), s, and total.

Referenced by load_module().

{
   const char *id = astman_get_header(m,"ActionID");
   const char *a[] = {"sip", "show", "peers"};
   char idtext[256] = "";
   int total = 0;

   if (!ast_strlen_zero(id))
      snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);

   astman_send_ack(s, m, "Peer status list will follow");
   /* List the peers in separate manager events */
   _sip_show_peers(-1, &total, s, m, 3, a);
   /* Send final confirmation */
   astman_append(s,
   "Event: PeerlistComplete\r\n"
   "ListItems: %d\r\n"
   "%s"
   "\r\n", total, idtext);
   return 0;
}

static int method_match	(	enum sipmethod	id,
		const char *	name
	)			[static]

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

Definition at line 1645 of file chan_sip.c.

References len, sip_methods, and text.

Referenced by __sip_semi_ack(), and find_sip_method().

{
   int len = strlen(sip_methods[id].text);
   int l_name = name ? strlen(name) : 0;
   /* true if the string is long enough, and ends with whitespace, and matches */
   return (l_name >= len && name[len] < 33 &&
      !strncasecmp(sip_methods[id].text, name, len));
}

static char * nat2str

(

int

nat

)

const [static]

Convert NAT setting to text string.

Definition at line 9423 of file chan_sip.c.

References SIP_NAT_ALWAYS, SIP_NAT_NEVER, SIP_NAT_RFC3581, and SIP_NAT_ROUTE.

Referenced by _sip_show_peer(), sip_show_channel(), sip_show_settings(), and sip_show_users().

{
   switch(nat) {
   case SIP_NAT_NEVER:
      return "No";
   case SIP_NAT_ROUTE:
      return "Route";
   case SIP_NAT_ALWAYS:
      return "Always";
   case SIP_NAT_RFC3581:
      return "RFC3581";
   default:
      return "Unknown";
   }
}

static void parse_copy	(	struct sip_request *	dst,
		const struct sip_request *	src
	)			[static]

Copy SIP request, parse it.

Definition at line 2138 of file chan_sip.c.

References sip_request::data, sip_request::len, and parse_request().

Referenced by send_request(), and send_response().

{
   memset(dst, 0, sizeof(*dst));
   memcpy(dst->data, src->data, sizeof(dst->data));
   dst->len = src->len;
   parse_request(dst);
}

static void parse_moved_contact	(	struct sip_pvt *	p,
		struct sip_request *	req
	)			[static]

Parse 302 Moved temporalily response.

Definition at line 11598 of file chan_sip.c.

References ast_log(), ast_string_field_build, ast_string_field_set, ast_test_flag, sip_pvt::flags, get_header(), get_in_brackets(), LOG_DEBUG, option_debug, sip_pvt::owner, pbx_builtin_setvar_helper(), s, SIP_PROMISCREDIR, and strsep().

Referenced by handle_response().

{
   char tmp[BUFSIZ];
   char *s, *e;
   char *domain;

   ast_copy_string(tmp, get_header(req, "Contact"), sizeof(tmp));
   s = get_in_brackets(tmp);
   s = strsep(&s, ";"); /* strip ; and beyond */
   if (ast_test_flag(&p->flags[0], SIP_PROMISCREDIR)) {
      if (!strncasecmp(s, "sip:", 4))
         s += 4;
      e = strchr(s, '/');
      if (e)
         *e = '\0';
      if (option_debug)
         ast_log(LOG_DEBUG, "Found promiscuous redirection to 'SIP/%s'\n", s);
      if (p->owner)
         ast_string_field_build(p->owner, call_forward, "SIP/%s", s);
   } else {
      e = strchr(tmp, '@');
      if (e) {
         *e++ = '\0';
         domain = e;
      } else {
         /* No username part */
         domain = tmp;
      }
      e = strchr(tmp, '/');
      if (e)
         *e = '\0';
      if (!strncasecmp(s, "sip:", 4))
         s += 4;
      if (option_debug > 1)
         ast_log(LOG_DEBUG, "Received 302 Redirect to extension '%s' (domain %s)\n", s, domain);
      if (p->owner) {
         pbx_builtin_setvar_helper(p->owner, "SIPDOMAIN", domain);
         ast_string_field_set(p->owner, call_forward, s);
      }
   }
}

static int parse_ok_contact	(	struct sip_pvt *	pvt,
		struct sip_request *	req
	)			[static]

Save contact header for 200 OK on INVITE.

Definition at line 7677 of file chan_sip.c.

References ast_string_field_set, get_header(), get_in_brackets(), and TRUE.

Referenced by handle_request_invite(), handle_request_subscribe(), and handle_response_invite().

{
   char contact[BUFSIZ]; 
   char *c;

   /* Look for brackets */
   ast_copy_string(contact, get_header(req, "Contact"), sizeof(contact));
   c = get_in_brackets(contact);

   /* Save full contact to call pvt for later bye or re-invite */
   ast_string_field_set(pvt, fullcontact, c);

   /* Save URI for later ACKs, BYE or RE-invites */
   ast_string_field_set(pvt, okcontacturi, c);

   /* We should return false for URI:s we can't handle,
      like sips:, tel:, mailto:,ldap: etc */
   return TRUE;      
}

static enum parse_register_result parse_register_contact	(	struct sip_pvt *	pvt,
		struct sip_peer *	p,
		struct sip_request *	req
	)			[static]

Parse contact header and save registration (peer registration).

Definition at line 7760 of file chan_sip.c.

References sip_peer::addr, ahp, ast_db_put(), ast_gethostbyname(), ast_inet_ntoa(), ast_log(), ast_sched_add(), ast_sched_del(), ast_sched_when(), ast_string_field_build, ast_strlen_zero(), ast_test_flag, ast_verbose(), destroy_association(), EVENT_FLAG_SYSTEM, sip_peer::expire, expire_register(), sip_pvt::expiry, sip_peer::flags, sip_peer::fullcontact, get_header(), get_in_brackets(), hp, inaddrcmp(), sip_peer::lastms, LOG_NOTICE, LOG_WARNING, manager_event(), option_verbose, PARSE_REGISTER_FAILED, PARSE_REGISTER_QUERY, PARSE_REGISTER_UPDATE, sip_pvt::recv, register_peer_exten(), sched, SIP_NAT_ROUTE, SIP_PAGE2_RT_FROMCONTACT, sip_poke_peer(), SIP_REALTIME, sip_pvt::sipoptions, sip_peer::sipoptions, STANDARD_SIP_PORT, strcasestr(), strsep(), sip_peer::useragent, sip_peer::username, and VERBOSE_PREFIX_3.

Referenced by register_verify().

{
   char contact[BUFSIZ]; 
   char data[BUFSIZ];
   const char *expires = get_header(req, "Expires");
   int expiry = atoi(expires);
   char *curi, *n, *pt;
   int port;
   const char *useragent;
   struct hostent *hp;
   struct ast_hostent ahp;
   struct sockaddr_in oldsin;

   ast_copy_string(contact, get_header(req, "Contact"), sizeof(contact));

   if (ast_strlen_zero(expires)) {  /* No expires header */
      expires = strcasestr(contact, ";expires=");
      if (expires) {
         /* XXX bug here, we overwrite the string */
         expires = strsep((char **) &expires, ";"); /* trim ; and beyond */
         if (sscanf(expires + 9, "%d", &expiry) != 1)
            expiry = default_expiry;
      } else {
         /* Nothing has been specified */
         expiry = default_expiry;
      }
   }

   /* Look for brackets */
   curi = contact;
   if (strchr(contact, '<') == NULL)   /* No <, check for ; and strip it */
      strsep(&curi, ";");  /* This is Header options, not URI options */
   curi = get_in_brackets(contact);

   /* if they did not specify Contact: or Expires:, they are querying
      what we currently have stored as their contact address, so return
      it
   */
   if (ast_strlen_zero(curi) && ast_strlen_zero(expires)) {
      /* If we have an active registration, tell them when the registration is going to expire */
      if (peer->expire > -1 && !ast_strlen_zero(peer->fullcontact))
         pvt->expiry = ast_sched_when(sched, peer->expire);
      return PARSE_REGISTER_QUERY;
   } else if (!strcasecmp(curi, "*") || !expiry) { /* Unregister this peer */
      /* This means remove all registrations and return OK */
      memset(&peer->addr, 0, sizeof(peer->addr));
      if (peer->expire > -1)
         ast_sched_del(sched, peer->expire);
      peer->expire = -1;

      destroy_association(peer);
      
      register_peer_exten(peer, 0); /* Add extension from regexten= setting in sip.conf */
      peer->fullcontact[0] = '\0';
      peer->useragent[0] = '\0';
      peer->sipoptions = 0;
      peer->lastms = 0;

      if (option_verbose > 2)
         ast_verbose(VERBOSE_PREFIX_3 "Unregistered SIP '%s'\n", peer->name);
         manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "Peer: SIP/%s\r\nPeerStatus: Unregistered\r\n", peer->name);
      return PARSE_REGISTER_UPDATE;
   }

   /* Store whatever we got as a contact from the client */
   ast_copy_string(peer->fullcontact, curi, sizeof(peer->fullcontact));

   /* For the 200 OK, we should use the received contact */
   ast_string_field_build(pvt, our_contact, "<%s>", curi);

   /* Make sure it's a SIP URL */
   if (strncasecmp(curi, "sip:", 4)) {
      ast_log(LOG_NOTICE, "'%s' is not a valid SIP contact (missing sip:) trying to use anyway\n", curi);
   } else
      curi += 4;
   /* Ditch q */
   curi = strsep(&curi, ";");
   /* Grab host */
   n = strchr(curi, '@');
   if (!n) {
      n = curi;
      curi = NULL;
   } else
      *n++ = '\0';
   pt = strchr(n, ':');
   if (pt) {
      *pt++ = '\0';
      port = atoi(pt);
   } else
      port = STANDARD_SIP_PORT;
   oldsin = peer->addr;
   if (!ast_test_flag(&peer->flags[0], SIP_NAT_ROUTE)) {
      /* XXX This could block for a long time XXX */
      hp = ast_gethostbyname(n, &ahp);
      if (!hp)  {
         ast_log(LOG_WARNING, "Invalid host '%s'\n", n);
         return PARSE_REGISTER_FAILED;
      }
      peer->addr.sin_family = AF_INET;
      memcpy(&peer->addr.sin_addr, hp->h_addr, sizeof(peer->addr.sin_addr));
      peer->addr.sin_port = htons(port);
   } else {
      /* Don't trust the contact field.  Just use what they came to us
         with */
      peer->addr = pvt->recv;
   }

   /* Save SIP options profile */
   peer->sipoptions = pvt->sipoptions;

   if (curi)   /* Overwrite the default username from config at registration */
      ast_copy_string(peer->username, curi, sizeof(peer->username));
   else
      peer->username[0] = '\0';

   if (peer->expire > -1) {
      ast_sched_del(sched, peer->expire);
      peer->expire = -1;
   }
   if (expiry > max_expiry)
      expiry = max_expiry;
   if (expiry < min_expiry)
      expiry = min_expiry;
   peer->expire = ast_test_flag(&peer->flags[0], SIP_REALTIME) ? -1 :
      ast_sched_add(sched, (expiry + 10) * 1000, expire_register, peer);
   pvt->expiry = expiry;
   snprintf(data, sizeof(data), "%s:%d:%d:%s:%s", ast_inet_ntoa(peer->addr.sin_addr), ntohs(peer->addr.sin_port), expiry, peer->username, peer->fullcontact);
   if (!ast_test_flag(&peer->flags[1], SIP_PAGE2_RT_FROMCONTACT)) 
      ast_db_put("SIP/Registry", peer->name, data);
   manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "Peer: SIP/%s\r\nPeerStatus: Registered\r\n", peer->name);

   /* Is this a new IP address for us? */
   if (inaddrcmp(&peer->addr, &oldsin)) {
      sip_poke_peer(peer);
      if (option_verbose > 2)
         ast_verbose(VERBOSE_PREFIX_3 "Registered SIP '%s' at %s port %d expires %d\n", peer->name, ast_inet_ntoa(peer->addr.sin_addr), ntohs(peer->addr.sin_port), expiry);
      register_peer_exten(peer, 1);
   }
   
   /* Save User agent */
   useragent = get_header(req, "User-Agent");
   if (strcasecmp(useragent, peer->useragent)) {   /* XXX copy if they are different ? */
      ast_copy_string(peer->useragent, useragent, sizeof(peer->useragent));
      if (option_verbose > 3)
         ast_verbose(VERBOSE_PREFIX_3 "Saved useragent \"%s\" for peer %s\n", peer->useragent, peer->name);  
   }
   return PARSE_REGISTER_UPDATE;
}

static void parse_request

(

struct sip_request *

req

)

[static]

Parse a SIP message.

Note:

this function is used both on incoming and outgoing packets

Definition at line 4571 of file chan_sip.c.

References ast_log(), ast_strlen_zero(), sip_request::data, determine_firstline_parts(), f, sip_request::header, sip_request::headers, sip_request::line, sip_request::lines, LOG_DEBUG, LOG_WARNING, option_debug, SIP_MAX_HEADERS, SIP_MAX_LINES, and sipdebug.

Referenced by initialize_initreq(), parse_copy(), and sipsock_read().

{
   /* Divide fields by NULL's */
   char *c;
   int f = 0;

   c = req->data;

   /* First header starts immediately */
   req->header[f] = c;
   while(*c) {
      if (*c == '\n') {
         /* We've got a new header */
         *c = 0;

         if (sipdebug && option_debug > 3)
            ast_log(LOG_DEBUG, "Header %d: %s (%d)\n", f, req->header[f], (int) strlen(req->header[f]));
         if (ast_strlen_zero(req->header[f])) {
            /* Line by itself means we're now in content */
            c++;
            break;
         }
         if (f >= SIP_MAX_HEADERS - 1) {
            ast_log(LOG_WARNING, "Too many SIP headers. Ignoring.\n");
         } else
            f++;
         req->header[f] = c + 1;
      } else if (*c == '\r') {
         /* Ignore but eliminate \r's */
         *c = 0;
      }
      c++;
   }
   /* Check for last header */
   if (!ast_strlen_zero(req->header[f])) {
      if (sipdebug && option_debug > 3)
         ast_log(LOG_DEBUG, "Header %d: %s (%d)\n", f, req->header[f], (int) strlen(req->header[f]));
      f++;
   }
   req->headers = f;
   /* Now we process any mime content */
   f = 0;
   req->line[f] = c;
   while(*c) {
      if (*c == '\n') {
         /* We've got a new line */
         *c = 0;
         if (sipdebug && option_debug > 3)
            ast_log(LOG_DEBUG, "Line: %s (%d)\n", req->line[f], (int) strlen(req->line[f]));
         if (f >= SIP_MAX_LINES - 1) {
            ast_log(LOG_WARNING, "Too many SDP lines. Ignoring.\n");
         } else
            f++;
         req->line[f] = c + 1;
      } else if (*c == '\r') {
         /* Ignore and eliminate \r's */
         *c = 0;
      }
      c++;
   }
   /* Check for last line */
   if (!ast_strlen_zero(req->line[f])) 
      f++;
   req->lines = f;
   if (*c) 
      ast_log(LOG_WARNING, "Odd content, extra stuff left over ('%s')\n", c);
   /* Split up the first line parts */
   determine_firstline_parts(req);
}

static unsigned int parse_sip_options	(	struct sip_pvt *	pvt,
		const char *	supported
	)			[static]

Parse supported header in incoming packet.

Definition at line 1669 of file chan_sip.c.

References ast_log(), ast_strdupa, ast_strlen_zero(), FALSE, LOG_DEBUG, ast_udptl_protocol::next, option_debug, sip_options, sipdebug, sip_pvt::sipoptions, text, and TRUE.

Referenced by handle_request_invite().

{
   char *next, *sep;
   char *temp;
   unsigned int profile = 0;
   int i, found;

   if (ast_strlen_zero(supported) )
      return 0;
   temp = ast_strdupa(supported);

   if (option_debug > 2 && sipdebug)
      ast_log(LOG_DEBUG, "Begin: parsing SIP \"Supported: %s\"\n", supported);

   for (next = temp; next; next = sep) {
      found = FALSE;
      if ( (sep = strchr(next, ',')) != NULL)
         *sep++ = '\0';
      next = ast_skip_blanks(next);
      if (option_debug > 2 && sipdebug)
         ast_log(LOG_DEBUG, "Found SIP option: -%s-\n", next);
      for (i=0; i < (sizeof(sip_options) / sizeof(sip_options[0])); i++) {
         if (!strcasecmp(next, sip_options[i].text)) {
            profile |= sip_options[i].id;
            found = TRUE;
            if (option_debug > 2 && sipdebug)
               ast_log(LOG_DEBUG, "Matched SIP option: %s\n", next);
            break;
         }
      }
      if (!found && option_debug > 2 && sipdebug) {
         if (!strncasecmp(next, "x-", 2))
            ast_log(LOG_DEBUG, "Found private SIP option, not supported: %s\n", next);
         else
            ast_log(LOG_DEBUG, "Found no match for SIP option: %s (Please file bug report!)\n", next);
      }
   }

   if (pvt)
      pvt->sipoptions = profile;
   return profile;
}

static int peer_status	(	struct sip_peer *	peer,
		char *	status,
		int	statuslen
	)			[static]

Report Peer status in character string.

Returns:

0 if peer is unreachable, 1 if peer is online, -1 if unmonitored

Definition at line 9442 of file chan_sip.c.

References sip_peer::lastms, and sip_peer::maxms.

{
   int res = 0;
   if (peer->maxms) {
      if (peer->lastms < 0) {
         ast_copy_string(status, "UNREACHABLE", statuslen);
      } else if (peer->lastms > peer->maxms) {
         snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
         res = 1;
      } else if (peer->lastms) {
         snprintf(status, statuslen, "OK (%d ms)", peer->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;
}

static void print_codec_to_cli	(	int	fd,
		struct ast_codec_pref *	pref
	)			[static]

Print codec list from preference to CLI/manager.

Definition at line 9910 of file chan_sip.c.

References ast_cli(), ast_codec_pref_index(), ast_getformatname(), and ast_codec_pref::framing.

Referenced by _sip_show_peer(), sip_show_settings(), and sip_show_user().

{
   int x, codec;

   for(x = 0; x < 32 ; x++) {
      codec = ast_codec_pref_index(pref, x);
      if (!codec)
         break;
      ast_cli(fd, "%s", ast_getformatname(codec));
      ast_cli(fd, ":%d", pref->framing[x]);
      if (x < 31 && ast_codec_pref_index(pref, x + 1))
         ast_cli(fd, ",");
   }
   if (!x)
      ast_cli(fd, "none");
}

static void print_group	(	int	fd,
		ast_group_t	group,
		int	crlf
	)			[static]

Print call group and pickup group.

Definition at line 9701 of file chan_sip.c.

References ast_cli(), and ast_print_group().

Referenced by _sip_show_peer(), and sip_show_user().

{
   char buf[256];
   ast_cli(fd, crlf ? "%s\r\n" : "%s\n", ast_print_group(buf, sizeof(buf), group) );
}

static int process_sdp	(	struct sip_pvt *	p,
		struct sip_request *	req
	)			[static]

Process SIP SDP offer, select formats and activate RTP channels If offer is rejected, we will not change any properties of the call Return 0 on success, a negative value on errors. Must be called after find_sdp().

< RTP Audio port number

< RTP Video port number

< media socket address

< Video socket address

< RTP Audio host IP

< RTP video host IP

Definition at line 4720 of file chan_sip.c.

References append_history, ast_clear_flag, ast_codec_choose(), ast_codec_pref_setsize(), AST_CONTROL_HOLD, AST_CONTROL_UNHOLD, AST_FORMAT_AUDIO_MASK, ast_getformatname_multiple(), ast_gethostbyname(), ast_inet_ntoa(), ast_log(), ast_null_frame, ast_queue_control(), ast_queue_control_data(), ast_queue_frame(), ast_rtp_alloc_size(), ast_rtp_codec_getformat(), ast_rtp_codec_getpref(), ast_rtp_codec_setpref(), AST_RTP_DTMF, ast_rtp_get_current_formats(), ast_rtp_lookup_mime_multiple(), ast_rtp_new_init(), AST_RTP_OPT_G726_NONSTANDARD, ast_rtp_pt_clear(), ast_rtp_pt_copy(), ast_rtp_set_m_type(), ast_rtp_set_peer(), ast_rtp_set_rtpmap_type(), ast_rtp_setdtmf(), ast_rtp_setdtmfcompensate(), ast_rtp_stop(), ast_set_flag, ast_set_read_format(), ast_set_write_format(), ast_strdupa, ast_strlen_zero(), ast_test_flag, ast_udptl_set_error_correction_scheme(), ast_udptl_set_far_max_datagram(), ast_udptl_set_local_max_datagram(), ast_udptl_set_peer(), ast_udptl_stop(), ast_verbose(), sip_pvt::autoframing, sip_pvt::capability, t38properties::capability, sip_request::data, debug, EVENT_FLAG_CALL, FALSE, sip_pvt::flags, format, get_sdp(), get_sdp_iterate(), hp, sip_pvt::jointcapability, t38properties::jointcapability, sip_pvt::jointnoncodeccapability, sip_pvt::lastinvite, sip_pvt::lastrtprx, sip_pvt::lastrtptx, len, LOG_DEBUG, LOG_ERROR, LOG_NOTICE, LOG_WARNING, LONG_MAX, LONG_MIN, manager_event(), ast_channel::nativeformats, sip_pvt::noncodeccapability, option_debug, sip_pvt::owner, sip_pvt::peercapability, t38properties::peercapability, portno, sip_pvt::prefs, ast_channel::readformat, sip_pvt::rtp, s, S_OR, sip_request::sdp_start, sip_debug_test_pvt(), SIP_DTMF, SIP_DTMF_AUTO, SIP_DTMF_INBAND, SIP_DTMF_RFC2833, SIP_G726_NONSTANDARD, SIP_NOVIDEO, SIP_PAGE2_CALL_ONHOLD, SIP_PAGE2_CALL_ONHOLD_INACTIVE, SIP_PAGE2_CALL_ONHOLD_ONEDIR, SIP_PAGE2_RFC2833_COMPENSATE, sip_peer_hold(), t38properties::state, sip_pvt::t38, T38_DISABLED, T38_PEER_DIRECT, T38_PEER_REINVITE, T38FAX_FILL_BIT_REMOVAL, T38FAX_RATE_12000, T38FAX_RATE_14400, T38FAX_RATE_2400, T38FAX_RATE_4800, T38FAX_RATE_7200, T38FAX_RATE_9600, T38FAX_RATE_MANAGEMENT_LOCAL_TCF, T38FAX_RATE_MANAGEMENT_TRANSFERED_TCF, T38FAX_TRANSCODING_JBIG, T38FAX_TRANSCODING_MMR, T38FAX_UDP_EC_FEC, T38FAX_UDP_EC_NONE, T38FAX_UDP_EC_REDUNDANCY, T38FAX_VERSION_0, T38FAX_VERSION_1, TRUE, sip_pvt::udptl, UDPTL_ERROR_CORRECTION_FEC, UDPTL_ERROR_CORRECTION_NONE, UDPTL_ERROR_CORRECTION_REDUNDANCY, sip_pvt::vrtp, and ast_channel::writeformat.

{
   const char *m;    /* SDP media offer */
   const char *c;
   const char *a;
   char host[258];
   int len = -1;
   int portno = -1;     /*!< RTP Audio port number */
   int vportno = -1;    /*!< RTP Video port number */
   int udptlportno = -1;
   int peert38capability = 0;
   char s[256];
   int old = 0;

   /* Peer capability is the capability in the SDP, non codec is RFC2833 DTMF (101) */ 
   int peercapability = 0, peernoncodeccapability = 0;
   int vpeercapability = 0, vpeernoncodeccapability = 0;
   struct sockaddr_in sin;    /*!< media socket address */
   struct sockaddr_in vsin;   /*!< Video socket address */

   const char *codecs;
   struct hostent *hp;     /*!< RTP Audio host IP */
   struct hostent *vhp = NULL;   /*!< RTP video host IP */
   struct ast_hostent audiohp;
   struct ast_hostent videohp;
   int codec;
   int destiterator = 0;
   int iterator;
   int sendonly = -1;
   int numberofports;
   struct ast_rtp *newaudiortp, *newvideortp;   /* Buffers for codec handling */
   int newjointcapability;          /* Negotiated capability */
   int newpeercapability;
   int newnoncodeccapability;
   int numberofmediastreams = 0;
   int debug = sip_debug_test_pvt(p);
      
   int found_rtpmap_codecs[32];
   int last_rtpmap_codec=0;

   if (!p->rtp) {
      ast_log(LOG_ERROR, "Got SDP but have no RTP session allocated.\n");
      return -1;
   }

   /* Initialize the temporary RTP structures we use to evaluate the offer from the peer */
   newaudiortp = alloca(ast_rtp_alloc_size());
   memset(newaudiortp, 0, ast_rtp_alloc_size());
   ast_rtp_new_init(newaudiortp);
   ast_rtp_pt_clear(newaudiortp);

   newvideortp = alloca(ast_rtp_alloc_size());
   memset(newvideortp, 0, ast_rtp_alloc_size());
   ast_rtp_new_init(newvideortp);
   ast_rtp_pt_clear(newvideortp);

   /* Update our last rtprx when we receive an SDP, too */
   p->lastrtprx = p->lastrtptx = time(NULL); /* XXX why both ? */


   /* Try to find first media stream */
   m = get_sdp(req, "m");
   destiterator = req->sdp_start;
   c = get_sdp_iterate(&destiterator, req, "c");
   if (ast_strlen_zero(m) || ast_strlen_zero(c)) {
      ast_log(LOG_WARNING, "Insufficient information for SDP (m = '%s', c = '%s')\n", m, c);
      return -1;
   }

   /* Check for IPv4 address (not IPv6 yet) */
   if (sscanf(c, "IN IP4 %256s", host) != 1) {
      ast_log(LOG_WARNING, "Invalid host in c= line, '%s'\n", c);
      return -1;
   }

   /* XXX This could block for a long time, and block the main thread! XXX */
   hp = ast_gethostbyname(host, &audiohp);
   if (!hp) {
      ast_log(LOG_WARNING, "Unable to lookup host in c= line, '%s'\n", c);
      return -1;
   }
   vhp = hp;   /* Copy to video address as default too */
   
   iterator = req->sdp_start;
   ast_set_flag(&p->flags[0], SIP_NOVIDEO);  


   /* Find media streams in this SDP offer */
   while ((m = get_sdp_iterate(&iterator, req, "m"))[0] != '\0') {
      int x;
      int audio = FALSE;

      numberofports = 1;
      if ((sscanf(m, "audio %d/%d RTP/AVP %n", &x, &numberofports, &len) == 2) ||
          (sscanf(m, "audio %d RTP/AVP %n", &x, &len) == 1)) {
         audio = TRUE;
         numberofmediastreams++;
         /* Found audio stream in this media definition */
         portno = x;
         /* Scan through the RTP payload types specified in a "m=" line: */
         for (codecs = m + len; !ast_strlen_zero(codecs); codecs = ast_skip_blanks(codecs + len)) {
            if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
               ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
               return -1;
            }
            if (debug)
               ast_verbose("Found RTP audio format %d\n", codec);
            ast_rtp_set_m_type(newaudiortp, codec);
         }
      } else if ((sscanf(m, "video %d/%d RTP/AVP %n", &x, &numberofports, &len) == 2) ||
          (sscanf(m, "video %d RTP/AVP %n", &x, &len) == 1)) {
         /* If it is not audio - is it video ? */
         ast_clear_flag(&p->flags[0], SIP_NOVIDEO);   
         numberofmediastreams++;
         vportno = x;
         /* Scan through the RTP payload types specified in a "m=" line: */
         for (codecs = m + len; !ast_strlen_zero(codecs); codecs = ast_skip_blanks(codecs + len)) {
            if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
               ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
               return -1;
            }
            if (debug)
               ast_verbose("Found RTP video format %d\n", codec);
            ast_rtp_set_m_type(newvideortp, codec);
         }
      } else if (p->udptl && ( (sscanf(m, "image %d udptl t38%n", &x, &len) == 1) || 
       (sscanf(m, "image %d UDPTL t38%n", &x, &len) == 1) )) {
         if (debug)
            ast_verbose("Got T.38 offer in SDP in dialog %s\n", p->callid);
         udptlportno = x;
         numberofmediastreams++;
         
         if (p->owner && p->lastinvite) {
            p->t38.state = T38_PEER_REINVITE; /* T38 Offered in re-invite from remote party */
            if (option_debug > 1)
               ast_log(LOG_DEBUG, "T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>" );
         } else {
            p->t38.state = T38_PEER_DIRECT; /* T38 Offered directly from peer in first invite */
            if (option_debug > 1)
               ast_log(LOG_DEBUG, "T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
         }
      } else 
         ast_log(LOG_WARNING, "Unsupported SDP media type in offer: %s\n", m);
      if (numberofports > 1)
         ast_log(LOG_WARNING, "SDP offered %d ports for media, not supported by Asterisk. Will try anyway...\n", numberofports);
      

      /* Check for Media-description-level-address for audio */
      c = get_sdp_iterate(&destiterator, req, "c");
      if (!ast_strlen_zero(c)) {
         if (sscanf(c, "IN IP4 %256s", host) != 1) {
            ast_log(LOG_WARNING, "Invalid secondary host in c= line, '%s'\n", c);
         } else {
            /* XXX This could block for a long time, and block the main thread! XXX */
            if (audio) {
               if ( !(hp = ast_gethostbyname(host, &audiohp))) {
                  ast_log(LOG_WARNING, "Unable to lookup RTP Audio host in secondary c= line, '%s'\n", c);
                  return -2;
               }
            } else if (!(vhp = ast_gethostbyname(host, &videohp))) {
               ast_log(LOG_WARNING, "Unable to lookup RTP video host in secondary c= line, '%s'\n", c);
               return -2;
            }
         }

      }
   }
   if (portno == -1 && vportno == -1 && udptlportno == -1)
      /* No acceptable offer found in SDP  - we have no ports */
      /* Do not change RTP or VRTP if this is a re-invite */
      return -2;

   if (numberofmediastreams > 2)
      /* We have too many fax, audio and/or video media streams, fail this offer */
      return -3;

   /* RTP addresses and ports for audio and video */
   sin.sin_family = AF_INET;
   vsin.sin_family = AF_INET;
   memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
   if (vhp)
      memcpy(&vsin.sin_addr, vhp->h_addr, sizeof(vsin.sin_addr));

   /* Setup UDPTL port number */
   if (p->udptl) {
      if (udptlportno > 0) {
         sin.sin_port = htons(udptlportno);
         ast_udptl_set_peer(p->udptl, &sin);
         if (debug)
            ast_log(LOG_DEBUG,"Peer T.38 UDPTL is at port %s:%d\n",ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
      } else {
         ast_udptl_stop(p->udptl);
         if (debug)
            ast_log(LOG_DEBUG, "Peer doesn't provide T.38 UDPTL\n");
      }
   }

      
   if (p->rtp) {
      if (portno > 0) {
         sin.sin_port = htons(portno);
         ast_rtp_set_peer(p->rtp, &sin);
         if (debug)
            ast_verbose("Peer audio RTP is at port %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
      } else {
         if (udptlportno > 0) {
            if (debug)
               ast_verbose("Got T.38 Re-invite without audio. Keeping RTP active during T.38 session. Callid %s\n", p->callid);
         } else {
            ast_rtp_stop(p->rtp);
            if (debug)
               ast_verbose("Peer doesn't provide audio. Callid %s\n", p->callid);
         }
      }
   }
   /* Setup video port number */
   if (vportno != -1)
      vsin.sin_port = htons(vportno);

   /* Next, scan through each "a=rtpmap:" line, noting each
    * specified RTP payload type (with corresponding MIME subtype):
    */
   /* XXX This needs to be done per media stream, since it's media stream specific */
   iterator = req->sdp_start;
   while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
      char* mimeSubtype = ast_strdupa(a); /* ensures we have enough space */
      if (option_debug > 1) {
         int breakout = FALSE;
      
         /* If we're debugging, check for unsupported sdp options */
         if (!strncasecmp(a, "rtcp:", (size_t) 5)) {
            if (debug)
               ast_verbose("Got unsupported a:rtcp in SDP offer \n");
            breakout = TRUE;
         } else if (!strncasecmp(a, "fmtp:", (size_t) 5)) {
            /* Format parameters:  Not supported */
            /* Note: This is used for codec parameters, like bitrate for
               G722 and video formats for H263 and H264 
               See RFC2327 for an example */
            if (debug)
               ast_verbose("Got unsupported a:fmtp in SDP offer \n");
            breakout = TRUE;
         } else if (!strncasecmp(a, "framerate:", (size_t) 10)) {
            /* Video stuff:  Not supported */
            if (debug)
               ast_verbose("Got unsupported a:framerate in SDP offer \n");
            breakout = TRUE;
         } else if (!strncasecmp(a, "maxprate:", (size_t) 9)) {
            /* Video stuff:  Not supported */
            if (debug)
               ast_verbose("Got unsupported a:maxprate in SDP offer \n");
            breakout = TRUE;
         } else if (!strncasecmp(a, "crypto:", (size_t) 7)) {
            /* SRTP stuff, not yet supported */
            if (debug)
               ast_verbose("Got unsupported a:crypto in SDP offer \n");
            breakout = TRUE;
         }
         if (breakout)  /* We have a match, skip to next header */
            continue;
      }
      if (!strcasecmp(a, "sendonly")) {
         if (sendonly == -1)
            sendonly = 1;
         continue;
      } else if (!strcasecmp(a, "inactive")) {
         if (sendonly == -1)
            sendonly = 2;
         continue;
      }  else if (!strcasecmp(a, "sendrecv")) {
         if (sendonly == -1)
            sendonly = 0;
         continue;
      } else if (strlen(a) > 5 && !strncasecmp(a, "ptime", 5)) {
         char *tmp = strrchr(a, ':');
         long int framing = 0;
         if (tmp) {
            tmp++;
            framing = strtol(tmp, NULL, 10);
            if (framing == LONG_MIN || framing == LONG_MAX) {
               framing = 0;
               if (option_debug)
                  ast_log(LOG_DEBUG, "Can't read framing from SDP: %s\n", a);
            }
         }
         if (framing && last_rtpmap_codec) {
            if (p->autoframing) {
               struct ast_codec_pref *pref = ast_rtp_codec_getpref(p->rtp);
               int codec_n;
               int format = 0;
               for (codec_n = 0; codec_n < last_rtpmap_codec; codec_n++) {
                  format = ast_rtp_codec_getformat(found_rtpmap_codecs[codec_n]);
                  if (!format)   /* non-codec or not found */
                     continue;
                  if (option_debug)
                     ast_log(LOG_DEBUG, "Setting framing for %d to %ld\n", format, framing);
                  ast_codec_pref_setsize(pref, format, framing);
               }
               ast_rtp_codec_setpref(p->rtp, pref);
            }
         }
         memset(&found_rtpmap_codecs, 0, sizeof(found_rtpmap_codecs));
         last_rtpmap_codec = 0;
         continue;
      } else if (sscanf(a, "rtpmap: %u %[^/]/", &codec, mimeSubtype) == 2) {
         /* We have a rtpmap to handle */
         if (debug)
            ast_verbose("Found description format %s for ID %d\n", mimeSubtype, codec);
         found_rtpmap_codecs[last_rtpmap_codec] = codec;
         last_rtpmap_codec++;

         /* Note: should really look at the 'freq' and '#chans' params too */
         ast_rtp_set_rtpmap_type(newaudiortp, codec, "audio", mimeSubtype,
               ast_test_flag(&p->flags[0], SIP_G726_NONSTANDARD) ? AST_RTP_OPT_G726_NONSTANDARD : 0);
         if (p->vrtp)
            ast_rtp_set_rtpmap_type(newvideortp, codec, "video", mimeSubtype, 0);
      }
   }
   
   if (udptlportno != -1) {
      int found = 0, x;
      
      old = 0;
      
      /* Scan trough the a= lines for T38 attributes and set apropriate fileds */
      iterator = req->sdp_start;
      while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
         if ((sscanf(a, "T38FaxMaxBuffer:%d", &x) == 1)) {
            found = 1;
            if (option_debug > 2)
               ast_log(LOG_DEBUG, "MaxBufferSize:%d\n",x);
         } else if ((sscanf(a, "T38MaxBitRate:%d", &x) == 1)) {
            found = 1;
            if (option_debug > 2)
               ast_log(LOG_DEBUG,"T38MaxBitRate: %d\n",x);
            switch (x) {
            case 14400:
               peert38capability |= T38FAX_RATE_14400 | T38FAX_RATE_12000 | T38FAX_RATE_9600 | T38FAX_RATE_7200 | T38FAX_RATE_4800 | T38FAX_RATE_2400;
               break;
            case 12000:
               peert38capability |= T38FAX_RATE_12000 | T38FAX_RATE_9600 | T38FAX_RATE_7200 | T38FAX_RATE_4800 | T38FAX_RATE_2400;
               break;
            case 9600:
               peert38capability |= T38FAX_RATE_9600 | T38FAX_RATE_7200 | T38FAX_RATE_4800 | T38FAX_RATE_2400;
               break;
            case 7200:
               peert38capability |= T38FAX_RATE_7200 | T38FAX_RATE_4800 | T38FAX_RATE_2400;
               break;
            case 4800:
               peert38capability |= T38FAX_RATE_4800 | T38FAX_RATE_2400;
               break;
            case 2400:
               peert38capability |= T38FAX_RATE_2400;
               break;
            }
         } else if ((sscanf(a, "T38FaxVersion:%d", &x) == 1)) {
            found = 1;
            if (option_debug > 2)
               ast_log(LOG_DEBUG, "FaxVersion: %d\n",x);
            if (x == 0)
               peert38capability |= T38FAX_VERSION_0;
            else if (x == 1)
               peert38capability |= T38FAX_VERSION_1;
         } else if ((sscanf(a, "T38FaxMaxDatagram:%d", &x) == 1)) {
            found = 1;
            if (option_debug > 2)
               ast_log(LOG_DEBUG, "FaxMaxDatagram: %d\n",x);
            ast_udptl_set_far_max_datagram(p->udptl, x);
            ast_udptl_set_local_max_datagram(p->udptl, x);
         } else if ((sscanf(a, "T38FaxFillBitRemoval:%d", &x) == 1)) {
            found = 1;
            if (option_debug > 2)
               ast_log(LOG_DEBUG, "FillBitRemoval: %d\n",x);
            if (x == 1)
               peert38capability |= T38FAX_FILL_BIT_REMOVAL;
         } else if ((sscanf(a, "T38FaxTranscodingMMR:%d", &x) == 1)) {
            found = 1;
            if (option_debug > 2)
               ast_log(LOG_DEBUG, "Transcoding MMR: %d\n",x);
            if (x == 1)
               peert38capability |= T38FAX_TRANSCODING_MMR;
         }
         if ((sscanf(a, "T38FaxTranscodingJBIG:%d", &x) == 1)) {
            found = 1;
            if (option_debug > 2)
               ast_log(LOG_DEBUG, "Transcoding JBIG: %d\n",x);
            if (x == 1)
               peert38capability |= T38FAX_TRANSCODING_JBIG;
         } else if ((sscanf(a, "T38FaxRateManagement:%255s", s) == 1)) {
            found = 1;
            if (option_debug > 2)
               ast_log(LOG_DEBUG, "RateManagement: %s\n", s);
            if (!strcasecmp(s, "localTCF"))
               peert38capability |= T38FAX_RATE_MANAGEMENT_LOCAL_TCF;
            else if (!strcasecmp(s, "transferredTCF"))
               peert38capability |= T38FAX_RATE_MANAGEMENT_TRANSFERED_TCF;
         } else if ((sscanf(a, "T38FaxUdpEC:%255s", s) == 1)) {
            found = 1;
            if (option_debug > 2)
               ast_log(LOG_DEBUG, "UDP EC: %s\n", s);
            if (!strcasecmp(s, "t38UDPRedundancy")) {
               peert38capability |= T38FAX_UDP_EC_REDUNDANCY;
               ast_udptl_set_error_correction_scheme(p->udptl, UDPTL_ERROR_CORRECTION_REDUNDANCY);
            } else if (!strcasecmp(s, "t38UDPFEC")) {
               peert38capability |= T38FAX_UDP_EC_FEC;
               ast_udptl_set_error_correction_scheme(p->udptl, UDPTL_ERROR_CORRECTION_FEC);
            } else {
               peert38capability |= T38FAX_UDP_EC_NONE;
               ast_udptl_set_error_correction_scheme(p->udptl, UDPTL_ERROR_CORRECTION_NONE);
            }
         }
      }
      if (found) { /* Some cisco equipment returns nothing beside c= and m= lines in 200 OK T38 SDP */
         p->t38.peercapability = peert38capability;
         p->t38.jointcapability = (peert38capability & 255); /* Put everything beside supported speeds settings */
         peert38capability &= (T38FAX_RATE_14400 | T38FAX_RATE_12000 | T38FAX_RATE_9600 | T38FAX_RATE_7200 | T38FAX_RATE_4800 | T38FAX_RATE_2400);
         p->t38.jointcapability |= (peert38capability & p->t38.capability); /* Put the lower of our's and peer's speed */
      }
      if (debug)
         ast_log(LOG_DEBUG, "Our T38 capability = (%d), peer T38 capability (%d), joint T38 capability (%d)\n",
            p->t38.capability,
            p->t38.peercapability,
            p->t38.jointcapability);
   } else {
      p->t38.state = T38_DISABLED;
      if (option_debug > 2)
         ast_log(LOG_DEBUG, "T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
   }

   /* Now gather all of the codecs that we are asked for: */
   ast_rtp_get_current_formats(newaudiortp, &peercapability, &peernoncodeccapability);
   ast_rtp_get_current_formats(newvideortp, &vpeercapability, &vpeernoncodeccapability);

   newjointcapability = p->capability & (peercapability | vpeercapability);
   newpeercapability = (peercapability | vpeercapability);
   newnoncodeccapability = p->noncodeccapability & peernoncodeccapability;
      
      
   if (debug) {
      /* shame on whoever coded this.... */
      char s1[BUFSIZ], s2[BUFSIZ], s3[BUFSIZ], s4[BUFSIZ];

      ast_verbose("Capabilities: us - %s, peer - audio=%s/video=%s, combined - %s\n",
             ast_getformatname_multiple(s1, BUFSIZ, p->capability),
             ast_getformatname_multiple(s2, BUFSIZ, newpeercapability),
             ast_getformatname_multiple(s3, BUFSIZ, vpeercapability),
             ast_getformatname_multiple(s4, BUFSIZ, newjointcapability));

      ast_verbose("Non-codec capabilities (dtmf): us - %s, peer - %s, combined - %s\n",
             ast_rtp_lookup_mime_multiple(s1, BUFSIZ, p->noncodeccapability, 0, 0),
             ast_rtp_lookup_mime_multiple(s2, BUFSIZ, peernoncodeccapability, 0, 0),
             ast_rtp_lookup_mime_multiple(s3, BUFSIZ, newnoncodeccapability, 0, 0));
   }
   if (!newjointcapability) {
      /* If T.38 was not negotiated either, totally bail out... */
      if (!p->t38.jointcapability) {
         ast_log(LOG_NOTICE, "No compatible codecs, not accepting this offer!\n");
         /* Do NOT Change current setting */
         return -1;
      } else {
         if (option_debug > 2)
            ast_log(LOG_DEBUG, "Have T.38 but no audio codecs, accepting offer anyway\n");
         return 0;
      }
   }

   /* We are now ready to change the sip session and p->rtp and p->vrtp with the offered codecs, since
      they are acceptable */
   p->jointcapability = newjointcapability;          /* Our joint codec profile for this call */
   p->peercapability = newpeercapability;            /* The other sides capability in latest offer */
   p->jointnoncodeccapability = newnoncodeccapability;   /* DTMF capabilities */

   ast_rtp_pt_copy(p->rtp, newaudiortp);
   if (p->vrtp)
      ast_rtp_pt_copy(p->vrtp, newvideortp);

   if (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO) {
      ast_clear_flag(&p->flags[0], SIP_DTMF);
      if (newnoncodeccapability & AST_RTP_DTMF) {
         /* XXX Would it be reasonable to drop the DSP at this point? XXX */
         ast_set_flag(&p->flags[0], SIP_DTMF_RFC2833);
         /* Since RFC2833 is now negotiated we need to change some properties of the RTP stream */
         ast_rtp_setdtmf(p->rtp, 1);
         ast_rtp_setdtmfcompensate(p->rtp, ast_test_flag(&p->flags[1], SIP_PAGE2_RFC2833_COMPENSATE));
      } else {
         ast_set_flag(&p->flags[0], SIP_DTMF_INBAND);
      }
   }

   /* Setup audio port number */
   if (p->rtp && sin.sin_port) {
      ast_rtp_set_peer(p->rtp, &sin);
      if (debug)
         ast_verbose("Peer audio RTP is at port %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
   }

   /* Setup video port number */
   if (p->vrtp && vsin.sin_port) {
      ast_rtp_set_peer(p->vrtp, &vsin);
      if (debug) 
         ast_verbose("Peer video RTP is at port %s:%d\n", ast_inet_ntoa(vsin.sin_addr), ntohs(vsin.sin_port));
   }

   /* Ok, we're going with this offer */
   if (option_debug > 1) {
      char buf[BUFSIZ];
      ast_log(LOG_DEBUG, "We're settling with these formats: %s\n", ast_getformatname_multiple(buf, BUFSIZ, p->jointcapability));
   }

   if (!p->owner)    /* There's no open channel owning us so we can return here. For a re-invite or so, we proceed */
      return 0;

   if (option_debug > 3)
      ast_log(LOG_DEBUG, "We have an owner, now see if we need to change this call\n");

   if (!(p->owner->nativeformats & p->jointcapability) && (p->jointcapability & AST_FORMAT_AUDIO_MASK)) {
      if (debug) {
         char s1[BUFSIZ], s2[BUFSIZ];
         ast_log(LOG_DEBUG, "Oooh, we need to change our audio formats since our peer supports only %s and not %s\n", 
            ast_getformatname_multiple(s1, BUFSIZ, p->jointcapability),
            ast_getformatname_multiple(s2, BUFSIZ, p->owner->nativeformats));
      }
      p->owner->nativeformats = ast_codec_choose(&p->prefs, p->jointcapability, 1) | (p->capability & vpeercapability);
      ast_set_read_format(p->owner, p->owner->readformat);
      ast_set_write_format(p->owner, p->owner->writeformat);
   }
   
   if (sin.sin_addr.s_addr && (!sendonly || sendonly == -1)) {
      ast_queue_control(p->owner, AST_CONTROL_UNHOLD);
      /* Activate a re-invite */
      ast_queue_frame(p->owner, &ast_null_frame);
   } else if (!sin.sin_addr.s_addr || sendonly) {
      ast_queue_control_data(p->owner, AST_CONTROL_HOLD, 
                   S_OR(p->mohsuggest, NULL),
                   !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0);
      if (sendonly)
         ast_rtp_stop(p->rtp);
      /* RTCP needs to go ahead, even if we're on hold!!! */
      /* Activate a re-invite */
      ast_queue_frame(p->owner, &ast_null_frame);
   }

   /* Manager Hold and Unhold events must be generated, if necessary */
   if (sin.sin_addr.s_addr && (!sendonly || sendonly == -1)) {
      if (ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD)) {
         append_history(p, "Unhold", "%s", req->data);
         if (global_callevents)
            manager_event(EVENT_FLAG_CALL, "Unhold",
               "Channel: %s\r\n"
               "Uniqueid: %s\r\n",
               p->owner->name, 
               p->owner->uniqueid);
         if (global_notifyhold)
            sip_peer_hold(p, 0);
      } 
      ast_clear_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD);  /* Clear both flags */
   } else if (!sin.sin_addr.s_addr || sendonly ) {
      /* No address for RTP, we're on hold */
      append_history(p, "Hold", "%s", req->data);

      if (global_callevents && !ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD)) {
         manager_event(EVENT_FLAG_CALL, "Hold",
            "Channel: %s\r\n"
            "Uniqueid: %s\r\n",
            p->owner->name, 
            p->owner->uniqueid);
      }
      if (sendonly == 1)   /* One directional hold (sendonly/recvonly) */
         ast_set_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD_ONEDIR);
      else if (sendonly == 2) /* Inactive stream */
         ast_set_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD_INACTIVE);
      if (global_notifyhold)
         sip_peer_hold(p, 1);
   }
   
   return 0;
}

static struct sip_peer * realtime_peer	(	const char *	newpeername,
		struct sockaddr_in *	sin
	)			[static]

realtime_peer: Get peer from realtime storage Checks the "sippeers" realtime family from extconfig.conf

Todo:

Consider adding check of port address when matching here to follow the same algorithm as for static peers. Will we break anything by adding that?

Definition at line 2407 of file chan_sip.c.

References ast_inet_ntoa(), ast_load_realtime(), ast_variables_destroy(), ipaddr, ast_variable::name, ast_variable::next, ast_variable::value, and var.

{
   struct sip_peer *peer;
   struct ast_variable *var = NULL;
   struct ast_variable *tmp;
   char ipaddr[INET_ADDRSTRLEN];

   /* First check on peer name */
   if (newpeername) 
      var = ast_load_realtime("sippeers", "name", newpeername, NULL);
   else if (sin) {   /* Then check on IP address for dynamic peers */
      ast_copy_string(ipaddr, ast_inet_ntoa(sin->sin_addr), sizeof(ipaddr));
      var = ast_load_realtime("sippeers", "host", ipaddr, NULL);  /* First check for fixed IP hosts */
      if (!var)
         var = ast_load_realtime("sippeers", "ipaddr", ipaddr, NULL);   /* Then check for registred hosts */
   }

   if (!var)
      return NULL;

   for (tmp = var; tmp; tmp = tmp->next) {
      /* If this is type=user, then skip this object. */
      if (!strcasecmp(tmp->name, "type") &&
          !strcasecmp(tmp->value, "user")) {
         ast_variables_destroy(var);
         return NULL;
      } else if (!newpeername && !strcasecmp(tmp->name, "name")) {
         newpeername = tmp->value;
      }
   }
   
   if (!newpeername) {  /* Did not find peer in realtime */
      ast_log(LOG_WARNING, "Cannot Determine peer name ip=%s\n", ipaddr);
      ast_variables_destroy(var);
      return NULL;
   }

   /* Peer found in realtime, now build it in memory */
   peer = build_peer(newpeername, var, NULL, !ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS));
   if (!peer) {
      ast_variables_destroy(var);
      return NULL;
   }

   if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
      /* Cache peer */
      ast_copy_flags(&peer->flags[1],&global_flags[1], SIP_PAGE2_RTAUTOCLEAR|SIP_PAGE2_RTCACHEFRIENDS);
      if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTAUTOCLEAR)) {
         if (peer->expire > -1) {
            ast_sched_del(sched, peer->expire);
         }
         peer->expire = ast_sched_add(sched, (global_rtautoclear) * 1000, expire_register, (void *)peer);
      }
      ASTOBJ_CONTAINER_LINK(&peerl,peer);
   } else {
      ast_set_flag(&peer->flags[0], SIP_REALTIME);
   }
   ast_variables_destroy(var);

   return peer;
}

static void realtime_update_peer	(	const char *	peername,
		struct sockaddr_in *	sin,
		const char *	username,
		const char *	fullcontact,
		int	expirey
	)			[static]

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.

Definition at line 2292 of file chan_sip.c.

References ast_config_AST_SYSTEM_NAME, ast_inet_ntoa(), ast_strlen_zero(), ast_test_flag, ast_update_realtime(), global_flags, ipaddr, and SIP_PAGE2_RTSAVE_SYSNAME.

{
   char port[10];
   char ipaddr[INET_ADDRSTRLEN];
   char regseconds[20];

   char *sysname = ast_config_AST_SYSTEM_NAME;
   char *syslabel = NULL;

   time_t nowtime = time(NULL) + expirey;
   const char *fc = fullcontact ? "fullcontact" : NULL;
   
   snprintf(regseconds, sizeof(regseconds), "%d", (int)nowtime);  /* Expiration time */
   ast_copy_string(ipaddr, ast_inet_ntoa(sin->sin_addr), sizeof(ipaddr));
   snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
   
   if (ast_strlen_zero(sysname)) /* No system name, disable this */
      sysname = NULL;
   else if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTSAVE_SYSNAME))
      syslabel = "regserver";

   if (fc)
      ast_update_realtime("sippeers", "name", peername, "ipaddr", ipaddr,
         "port", port, "regseconds", regseconds,
         "username", username, fc, fullcontact, syslabel, sysname, NULL); /* note fc and syslabel _can_ be NULL */
   else
      ast_update_realtime("sippeers", "name", peername, "ipaddr", ipaddr,
         "port", port, "regseconds", regseconds,
         "username", username, syslabel, sysname, NULL); /* note syslabel _can_ be NULL */
}

static struct sip_user * realtime_user

(

const char *

username

)

[static]

Load user from realtime storage Loads user from "sipusers" category in realtime (extconfig.conf) Users are matched on From: user name (the domain in skipped).

Definition at line 2517 of file chan_sip.c.

References ast_load_realtime(), ast_variables_destroy(), ast_variable::name, ast_variable::next, ast_variable::value, and var.

{
   struct ast_variable *var;
   struct ast_variable *tmp;
   struct sip_user *user = NULL;

   var = ast_load_realtime("sipusers", "name", username, NULL);

   if (!var)
      return NULL;

   for (tmp = var; tmp; tmp = tmp->next) {
      if (!strcasecmp(tmp->name, "type") &&
         !strcasecmp(tmp->value, "peer")) {
         ast_variables_destroy(var);
         return NULL;
      }
   }

   user = build_user(username, var, !ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS));
   
   if (!user) {   /* No user found */
      ast_variables_destroy(var);
      return NULL;
   }

   if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
      ast_set_flag(&user->flags[1], SIP_PAGE2_RTCACHEFRIENDS);
      suserobjs++;
      ASTOBJ_CONTAINER_LINK(&userl,user);
   } else {
      /* Move counter from s to r... */
      suserobjs--;
      ruserobjs++;
      ast_set_flag(&user->flags[0], SIP_REALTIME);
   }
   ast_variables_destroy(var);
   return user;
}

static void receive_message	(	struct sip_pvt *	p,
		struct sip_request *	req
	)			[static]

Receive SIP MESSAGE method messages.

Note:

We only handle messages within current calls currently Reference: RFC 3428

Definition at line 9327 of file chan_sip.c.

References AST_FRAME_TEXT, ast_log(), ast_queue_frame(), ast_verbose(), DEFAULT_TRANS_TIMEOUT, f, get_header(), get_msg_text(), LOG_WARNING, sip_pvt::owner, sip_debug_test_pvt(), sip_scheddestroy(), and transmit_response().

Referenced by handle_request_message().

{
   char buf[1024];
   struct ast_frame f;
   const char *content_type = get_header(req, "Content-Type");

   if (strcmp(content_type, "text/plain")) { /* No text/plain attachment */
      transmit_response(p, "415 Unsupported Media Type", req); /* Good enough, or? */
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
      return;
   }

   if (get_msg_text(buf, sizeof(buf), req)) {
      ast_log(LOG_WARNING, "Unable to retrieve text from %s\n", p->callid);
      transmit_response(p, "202 Accepted", req);
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
      return;
   }

   if (p->owner) {
      if (sip_debug_test_pvt(p))
         ast_verbose("Message received: '%s'\n", buf);
      memset(&f, 0, sizeof(f));
      f.frametype = AST_FRAME_TEXT;
      f.subclass = 0;
      f.offset = 0;
      f.data = buf;
      f.datalen = strlen(buf);
      ast_queue_frame(p->owner, &f);
      transmit_response(p, "202 Accepted", req); /* We respond 202 accepted, since we relay the message */
   } else { /* Message outside of a call, we do not support that */
      ast_log(LOG_WARNING,"Received message to %s from %s, dropped it...\n  Content-Type:%s\n  Message: %s\n", get_header(req,"To"), get_header(req,"From"), content_type, buf);
      transmit_response(p, "405 Method Not Allowed", req); /* Good enough, or? */
   }
   sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
   return;
}

static char * referstatus2str

(

enum referstatus

rstatus

)

[static]

Convert transfer status to string.

Definition at line 1604 of file chan_sip.c.

References referstatusstrings, and text.

Referenced by __sip_show_channels().

{
   int i = (sizeof(referstatusstrings) / sizeof(referstatusstrings[0]));
   int x;

   for (x = 0; x < i; x++) {
      if (referstatusstrings[x].status ==  rstatus)
         return (char *) referstatusstrings[x].text;
   }
   return "";
}

static void reg_source_db

(

struct sip_peer *

peer

)

[static]

Get registration details from Asterisk DB.

Definition at line 7617 of file chan_sip.c.

References sip_peer::addr, ast_db_get(), ast_inet_ntoa(), ast_log(), ast_random(), ast_sched_add(), ast_sched_del(), ast_test_flag, sip_peer::expire, expire_register(), sip_peer::flags, sip_peer::fullcontact, LOG_DEBUG, option_debug, sip_peer::pokeexpire, register_peer_exten(), sched, SIP_PAGE2_RT_FROMCONTACT, sip_poke_peer(), sip_poke_peer_s(), sipsock, strsep(), TRUE, sip_peer::username, and username.

{
   char data[256];
   struct in_addr in;
   int expiry;
   int port;
   char *scan, *addr, *port_str, *expiry_str, *username, *contact;

   if (ast_test_flag(&peer->flags[1], SIP_PAGE2_RT_FROMCONTACT)) 
      return;
   if (ast_db_get("SIP/Registry", peer->name, data, sizeof(data)))
      return;

   scan = data;
   addr = strsep(&scan, ":");
   port_str = strsep(&scan, ":");
   expiry_str = strsep(&scan, ":");
   username = strsep(&scan, ":");
   contact = scan;   /* Contact include sip: and has to be the last part of the database entry as long as we use : as a separator */

   if (!inet_aton(addr, &in))
      return;

   if (port_str)
      port = atoi(port_str);
   else
      return;

   if (expiry_str)
      expiry = atoi(expiry_str);
   else
      return;

   if (username)
      ast_copy_string(peer->username, username, sizeof(peer->username));
   if (contact)
      ast_copy_string(peer->fullcontact, contact, sizeof(peer->fullcontact));

   if (option_debug > 1)
      ast_log(LOG_DEBUG, "SIP Seeding peer from astdb: '%s' at %s@%s:%d for %d\n",
             peer->name, peer->username, ast_inet_ntoa(in), port, expiry);

   memset(&peer->addr, 0, sizeof(peer->addr));
   peer->addr.sin_family = AF_INET;
   peer->addr.sin_addr = in;
   peer->addr.sin_port = htons(port);
   if (sipsock < 0) {
      /* SIP isn't up yet, so schedule a poke only, pretty soon */
      if (peer->pokeexpire > -1)
         ast_sched_del(sched, peer->pokeexpire);
      peer->pokeexpire = ast_sched_add(sched, ast_random() % 5000 + 1, sip_poke_peer_s, peer);
   } else
      sip_poke_peer(peer);
   if (peer->expire > -1)
      ast_sched_del(sched, peer->expire);
   peer->expire = ast_sched_add(sched, (expiry + 10) * 1000, expire_register, peer);
   register_peer_exten(peer, TRUE);
}

static void register_peer_exten	(	struct sip_peer *	peer,
		int	onoff
	)			[static]

Automatically add peer extension to dial plan.

Definition at line 2324 of file chan_sip.c.

References ast_add_extension(), ast_context_find(), ast_context_remove_extension(), ast_free, ast_log(), ast_strdup, ast_strlen_zero(), domain::context, ext, LOG_WARNING, sip_peer::regexten, S_OR, and strsep().

{
   char multi[256];
   char *stringp, *ext, *context;

   /* XXX note that global_regcontext is both a global 'enable' flag and
    * the name of the global regexten context, if not specified
    * individually.
    */
   if (ast_strlen_zero(global_regcontext))
      return;

   ast_copy_string(multi, S_OR(peer->regexten, peer->name), sizeof(multi));
   stringp = multi;
   while ((ext = strsep(&stringp, "&"))) {
      if ((context = strchr(ext, '@'))) {
         *context++ = '\0';   /* split ext@context */
         if (!ast_context_find(context)) {
            ast_log(LOG_WARNING, "Context %s must exist in regcontext= in sip.conf!\n", context);
            continue;
         }
      } else {
         context = global_regcontext;
      }
      if (onoff)
         ast_add_extension(context, 1, ext, 1, NULL, NULL, "Noop",
             ast_strdup(peer->name), ast_free, "SIP");
      else
         ast_context_remove_extension(context, ext, 1, NULL);
   }
}

static enum check_auth_result register_verify	(	struct sip_pvt *	p,
		struct sockaddr_in *	sin,
		struct sip_request *	req,
		char *	uri
	)			[static]

Verify registration of user

• Registration is done in several steps, first a REGISTER without auth to get a challenge (nonce) then a second one with auth
• Registration requests are only matched with peers that are marked as "dynamic".

Definition at line 8266 of file chan_sip.c.

References ast_apply_ha(), ast_copy_flags, ast_device_state_changed(), ast_inet_ntoa(), AST_LIST_EMPTY, ast_log(), ast_rtp_codec_setpref(), ast_string_field_set, ast_test_flag, ast_uri_decode(), ASTOBJ_CONTAINER_LINK, ASTOBJ_UNREF, AUTH_NOT_FOUND, AUTH_SECRET_FAILED, AUTH_UNKNOWN_DOMAIN, AUTH_USERNAME_MISMATCH, sip_peer::autoframing, sip_pvt::autoframing, build_contact(), check_auth(), check_sip_domain(), EVENT_FLAG_SYSTEM, exten, find_peer(), sip_pvt::flags, sip_peer::flags, get_header(), get_in_brackets(), sip_peer::ha, sip_pvt::initreq, sip_peer::lastmsgssent, LOG_DEBUG, LOG_ERROR, LOG_NOTICE, LOG_WARNING, manager_event(), sip_peer::md5secret, name, option_debug, parse_register_contact(), PARSE_REGISTER_FAILED, PARSE_REGISTER_QUERY, PARSE_REGISTER_UPDATE, peerl, sip_peer::prefs, sip_pvt::rtp, sip_peer::secret, sip_cancel_destroy(), sip_destroy_peer(), SIP_NAT, SIP_PAGE2_DYNAMIC, SIP_PAGE2_SUBSCRIBEMWIONLY, SIP_PKT_IGNORE, SIP_REGISTER, strsep(), t, temp_peer(), transmit_fake_auth_response(), transmit_response(), transmit_response_with_date(), update_peer(), and XMIT_UNRELIABLE.

{
   enum check_auth_result res = AUTH_NOT_FOUND;
   struct sip_peer *peer;
   char tmp[256];
   char *name, *c;
   char *t;
   char *domain;

   /* Terminate URI */
   t = uri;
   while(*t && (*t > 32) && (*t != ';'))
      t++;
   *t = '\0';
   
   ast_copy_string(tmp, get_header(req, "To"), sizeof(tmp));
   if (pedanticsipchecking)
      ast_uri_decode(tmp);

   c = get_in_brackets(tmp);
   c = strsep(&c, ";"); /* Ditch ;user=phone */

   if (!strncmp(c, "sip:", 4)) {
      name = c + 4;
   } else {
      name = c;
      ast_log(LOG_NOTICE, "Invalid to address: '%s' from %s (missing sip:) trying to use anyway...\n", c, ast_inet_ntoa(sin->sin_addr));
   }

   /* Strip off the domain name */
   if ((c = strchr(name, '@'))) {
      *c++ = '\0';
      domain = c;
      if ((c = strchr(domain, ':')))   /* Remove :port */
         *c = '\0';
      if (!AST_LIST_EMPTY(&domain_list)) {
         if (!check_sip_domain(domain, NULL, 0)) {
            transmit_response(p, "404 Not found (unknown domain)", &p->initreq);
            return AUTH_UNKNOWN_DOMAIN;
         }
      }
   }

   ast_string_field_set(p, exten, name);
   build_contact(p);
   peer = find_peer(name, NULL, 1);
   if (!(peer && ast_apply_ha(peer->ha, sin))) {
      /* Peer fails ACL check */
      if (peer)
         ASTOBJ_UNREF(peer, sip_destroy_peer);
      peer = NULL;
   }
   if (peer) {
      /* Set Frame packetization */
      if (p->rtp) {
         ast_rtp_codec_setpref(p->rtp, &peer->prefs);
         p->autoframing = peer->autoframing;
      }
      if (!ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC)) {
         ast_log(LOG_ERROR, "Peer '%s' is trying to register, but not configured as host=dynamic\n", peer->name);
      } else {
         ast_copy_flags(&p->flags[0], &peer->flags[0], SIP_NAT);
         transmit_response(p, "100 Trying", req);
         if (!(res = check_auth(p, req, peer->name, peer->secret, peer->md5secret, SIP_REGISTER, uri, XMIT_UNRELIABLE, ast_test_flag(req, SIP_PKT_IGNORE)))) {
            sip_cancel_destroy(p);

            /* We have a succesful registration attemp with proper authentication,
               now, update the peer */
            switch (parse_register_contact(p, peer, req)) {
            case PARSE_REGISTER_FAILED:
               ast_log(LOG_WARNING, "Failed to parse contact info\n");
               transmit_response_with_date(p, "400 Bad Request", req);
               peer->lastmsgssent = -1;
               res = 0;
               break;
            case PARSE_REGISTER_QUERY:
               transmit_response_with_date(p, "200 OK", req);
               peer->lastmsgssent = -1;
               res = 0;
               break;
            case PARSE_REGISTER_UPDATE:
               update_peer(peer, p->expiry);
               /* Say OK and ask subsystem to retransmit msg counter */
               transmit_response_with_date(p, "200 OK", req);
               if (!ast_test_flag((&peer->flags[1]), SIP_PAGE2_SUBSCRIBEMWIONLY))
                  peer->lastmsgssent = -1;
               res = 0;
               break;
            }
         } 
      }
   }
   if (!peer && autocreatepeer) {
      /* Create peer if we have autocreate mode enabled */
      peer = temp_peer(name);
      if (peer) {
         ASTOBJ_CONTAINER_LINK(&peerl, peer);
         sip_cancel_destroy(p);
         switch (parse_register_contact(p, peer, req)) {
         case PARSE_REGISTER_FAILED:
            ast_log(LOG_WARNING, "Failed to parse contact info\n");
            transmit_response_with_date(p, "400 Bad Request", req);
            peer->lastmsgssent = -1;
            res = 0;
            break;
         case PARSE_REGISTER_QUERY:
            transmit_response_with_date(p, "200 OK", req);
            peer->lastmsgssent = -1;
            res = 0;
            break;
         case PARSE_REGISTER_UPDATE:
            /* Say OK and ask subsystem to retransmit msg counter */
            transmit_response_with_date(p, "200 OK", req);
            manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "Peer: SIP/%s\r\nPeerStatus: Registered\r\n", peer->name);
            peer->lastmsgssent = -1;
            res = 0;
            break;
         }
      }
   }
   if (!res) {
      ast_device_state_changed("SIP/%s", peer->name);
   }
   if (res < 0) {
      switch (res) {
      case AUTH_SECRET_FAILED:
         /* Wrong password in authentication. Go away, don't try again until you fixed it */
         transmit_response(p, "403 Forbidden (Bad auth)", &p->initreq);
         break;
      case AUTH_USERNAME_MISMATCH:
         /* Username and digest username does not match. 
            Asterisk uses the From: username for authentication. We need the
            users to use the same authentication user name until we support
            proper authentication by digest auth name */
         transmit_response(p, "403 Authentication user name does not match account name", &p->initreq);
         break;
      case AUTH_NOT_FOUND:
         if (global_alwaysauthreject) {
            transmit_fake_auth_response(p, &p->initreq, 1);
         } else {
            /* URI not found */
            transmit_response(p, "404 Not found", &p->initreq);
         }
         break;
      default:
         break;
      }
      if (option_debug > 1) {
         const char *reason = "";

         switch (res) {
         case AUTH_SECRET_FAILED:
            reason = "Bad password";
            break;
         case AUTH_USERNAME_MISMATCH:
            reason = "Bad digest user";
            break;
         case AUTH_NOT_FOUND:
            reason = "Peer not found";
            break;
         default:
            break;
         }
         ast_log(LOG_DEBUG, "SIP REGISTER attempt failed for %s : %s\n",
            peer->name, reason);
      }
   }
   if (peer)
      ASTOBJ_UNREF(peer, sip_destroy_peer);

   return res;
}

static char * regstate2str

(

enum sipregistrystate

regstate

)

const [static]

Convert registration state status to string.

Definition at line 7118 of file chan_sip.c.

References REG_STATE_AUTHSENT, REG_STATE_FAILED, REG_STATE_NOAUTH, REG_STATE_REGISTERED, REG_STATE_REGSENT, REG_STATE_REJECTED, REG_STATE_TIMEOUT, and REG_STATE_UNREGISTERED.

{
   switch(regstate) {
   case REG_STATE_FAILED:
      return "Failed";
   case REG_STATE_UNREGISTERED:
      return "Unregistered";
   case REG_STATE_REGSENT:
      return "Request Sent";
   case REG_STATE_AUTHSENT:
      return "Auth. Sent";
   case REG_STATE_REGISTERED:
      return "Registered";
   case REG_STATE_REJECTED:
      return "Rejected";
   case REG_STATE_TIMEOUT:
      return "Timeout";
   case REG_STATE_NOAUTH:
      return "No Authentication";
   default:
      return "Unknown";
   }
}

static int reload

(

void

)

[static]

Part of Asterisk module interface.

Definition at line 17286 of file chan_sip.c.

References sip_reload().

{
   return sip_reload(0, 0, NULL);
}

static int reload_config

(

enum channelreloadreason

reason

)

[static]

Re-read SIP.conf config file.

Note:

This function reloads all config data, except for active peers (with registrations). They will only change configuration data at restart, not at reload. SIP debug and recordhistory state will not change

< Default DTMF setting: RFC2833

< NAT support if requested by device with rport

< Allow re-invites

Definition at line 16197 of file chan_sip.c.

References ahp, ast_clear_flag, ast_config_AST_SYSTEM_NAME, ast_config_load(), ast_copy_flags, AST_FLAGS_ALL, ast_jb_read_conf(), ast_log(), AST_MAX_CONTEXT, ast_set_flag, ast_strlen_zero(), ast_true(), ast_variable_browse(), bindaddr, context, DEFAULT_ALLOW_EXT_DOM, DEFAULT_ALLOWGUEST, DEFAULT_AUTOCREATEPEER, DEFAULT_CALLERID, DEFAULT_COMPACTHEADERS, DEFAULT_CONTEXT, DEFAULT_EXPIRY, default_jbconf, DEFAULT_MAX_CALL_BITRATE, DEFAULT_MOHINTERPRET, DEFAULT_MOHSUGGEST, DEFAULT_MWITIME, DEFAULT_NOTIFYMIME, DEFAULT_NOTIFYRINGING, DEFAULT_PEDANTIC, default_prefs, DEFAULT_QUALIFY, DEFAULT_REALM, DEFAULT_REGISTRATION_TIMEOUT, DEFAULT_SRVLOOKUP, DEFAULT_T1MIN, DEFAULT_TOS_AUDIO, DEFAULT_TOS_SIP, DEFAULT_TOS_VIDEO, DEFAULT_USERAGENT, DEFAULT_VMEXTEN, externexpire, externhost, externip, externrefresh, FALSE, global_flags, global_jbconf, handle_common_options(), hp, localaddr, LOG_NOTICE, ast_variable::name, ast_variable::next, ourport, outboundproxyip, SIP_CAN_REINVITE, SIP_DTMF_RFC2833, SIP_NAT_RFC3581, SIP_PAGE2_ALLOWOVERLAP, SIP_PAGE2_ALLOWSUBSCRIBE, SIP_PAGE2_DEBUG_CONFIG, SIP_PAGE2_DEBUG_CONSOLE, SIP_PAGE2_RTUPDATE, SIP_PAGE2_VIDEOSUPPORT, STANDARD_SIP_PORT, TRANSFER_OPENFORALL, and ast_variable::value.

{
   struct ast_config *cfg, *ucfg;
   struct ast_variable *v;
   struct sip_peer *peer;
   struct sip_user *user;
   struct ast_hostent ahp;
   char *cat, *stringp, *context, *oldregcontext;
   char newcontexts[AST_MAX_CONTEXT], oldcontexts[AST_MAX_CONTEXT];
   struct hostent *hp;
   int format;
   struct ast_flags dummy[2];
   int auto_sip_domains = FALSE;
   struct sockaddr_in old_bindaddr = bindaddr;
   int registry_count = 0, peer_count = 0, user_count = 0;
   unsigned int temp_tos = 0;
   struct ast_flags debugflag = {0};

   cfg = ast_config_load(config);

   /* We *must* have a config file otherwise stop immediately */
   if (!cfg) {
      ast_log(LOG_NOTICE, "Unable to load config %s\n", config);
      return -1;
   }
   
   /* Initialize copy of current global_regcontext for later use in removing stale contexts */
   ast_copy_string(oldcontexts, global_regcontext, sizeof(oldcontexts));
   oldregcontext = oldcontexts;

   /* Clear all flags before setting default values */
   /* Preserve debugging settings for console */
   ast_copy_flags(&debugflag, &global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
   ast_clear_flag(&global_flags[0], AST_FLAGS_ALL);
   ast_clear_flag(&global_flags[1], AST_FLAGS_ALL);
   ast_copy_flags(&global_flags[1], &debugflag, SIP_PAGE2_DEBUG_CONSOLE);

   /* Reset IP addresses  */
   memset(&bindaddr, 0, sizeof(bindaddr));
   memset(&localaddr, 0, sizeof(localaddr));
   memset(&externip, 0, sizeof(externip));
   memset(&default_prefs, 0 , sizeof(default_prefs));
   outboundproxyip.sin_port = htons(STANDARD_SIP_PORT);
   outboundproxyip.sin_family = AF_INET;  /* Type of address: IPv4 */
   ourport = STANDARD_SIP_PORT;
   srvlookup = DEFAULT_SRVLOOKUP;
   global_tos_sip = DEFAULT_TOS_SIP;
   global_tos_audio = DEFAULT_TOS_AUDIO;
   global_tos_video = DEFAULT_TOS_VIDEO;
   externhost[0] = '\0';         /* External host name (for behind NAT DynDNS support) */
   externexpire = 0;       /* Expiration for DNS re-issuing */
   externrefresh = 10;
   memset(&outboundproxyip, 0, sizeof(outboundproxyip));

   /* Reset channel settings to default before re-configuring */
   allow_external_domains = DEFAULT_ALLOW_EXT_DOM;          /* Allow external invites */
   global_regcontext[0] = '\0';
   expiry = DEFAULT_EXPIRY;
   global_notifyringing = DEFAULT_NOTIFYRINGING;
   global_limitonpeers = FALSE;
   global_directrtpsetup = FALSE;      /* Experimental feature, disabled by default */
   global_notifyhold = FALSE;
   global_alwaysauthreject = 0;
   global_allowsubscribe = FALSE;
   ast_copy_string(global_useragent, DEFAULT_USERAGENT, sizeof(global_useragent));
   ast_copy_string(default_notifymime, DEFAULT_NOTIFYMIME, sizeof(default_notifymime));
   if (ast_strlen_zero(ast_config_AST_SYSTEM_NAME))
      ast_copy_string(global_realm, DEFAULT_REALM, sizeof(global_realm));
   else
      ast_copy_string(global_realm, ast_config_AST_SYSTEM_NAME, sizeof(global_realm));
   ast_copy_string(default_callerid, DEFAULT_CALLERID, sizeof(default_callerid));
   compactheaders = DEFAULT_COMPACTHEADERS;
   global_reg_timeout = DEFAULT_REGISTRATION_TIMEOUT;
   global_regattempts_max = 0;
   pedanticsipchecking = DEFAULT_PEDANTIC;
   global_mwitime = DEFAULT_MWITIME;
   autocreatepeer = DEFAULT_AUTOCREATEPEER;
   global_autoframing = 0;
   global_allowguest = DEFAULT_ALLOWGUEST;
   global_rtptimeout = 0;
   global_rtpholdtimeout = 0;
   global_rtpkeepalive = 0;
   global_allowtransfer = TRANSFER_OPENFORALL;  /* Merrily accept all transfers by default */
   global_rtautoclear = 120;
   ast_set_flag(&global_flags[1], SIP_PAGE2_ALLOWSUBSCRIBE);   /* Default for peers, users: TRUE */
   ast_set_flag(&global_flags[1], SIP_PAGE2_ALLOWOVERLAP);     /* Default for peers, users: TRUE */
   ast_set_flag(&global_flags[1], SIP_PAGE2_RTUPDATE);

   /* Initialize some reasonable defaults at SIP reload (used both for channel and as default for peers and users */
   ast_copy_string(default_context, DEFAULT_CONTEXT, sizeof(default_context));
   default_subscribecontext[0] = '\0';
   default_language[0] = '\0';
   default_fromdomain[0] = '\0';
   default_qualify = DEFAULT_QUALIFY;
   default_maxcallbitrate = DEFAULT_MAX_CALL_BITRATE;
   ast_copy_string(default_mohinterpret, DEFAULT_MOHINTERPRET, sizeof(default_mohinterpret));
   ast_copy_string(default_mohsuggest, DEFAULT_MOHSUGGEST, sizeof(default_mohsuggest));
   ast_copy_string(default_vmexten, DEFAULT_VMEXTEN, sizeof(default_vmexten));
   ast_set_flag(&global_flags[0], SIP_DTMF_RFC2833);        /*!< Default DTMF setting: RFC2833 */
   ast_set_flag(&global_flags[0], SIP_NAT_RFC3581);         /*!< NAT support if requested by device with rport */
   ast_set_flag(&global_flags[0], SIP_CAN_REINVITE);        /*!< Allow re-invites */

   /* Debugging settings, always default to off */
   dumphistory = FALSE;
   recordhistory = FALSE;
   ast_clear_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONFIG);

   /* Misc settings for the channel */
   global_relaxdtmf = FALSE;
   global_callevents = FALSE;
   global_t1min = DEFAULT_T1MIN;    

   global_matchexterniplocally = FALSE;

   /* Copy the default jb config over global_jbconf */
   memcpy(&global_jbconf, &default_jbconf, sizeof(struct ast_jb_conf));

   ast_clear_flag(&global_flags[1], SIP_PAGE2_VIDEOSUPPORT);

   /* Read the [general] config section of sip.conf (or from realtime config) */
   for (v = ast_variable_browse(cfg, "general"); v; v = v->next) {
      if (handle_common_options(&global_flags[0], &dummy[0], v))
         continue;
      /* handle jb conf */
      if (!ast_jb_read_conf(&global_jbconf, v->name, v->value))
         continue;

      /* Create the interface list */
      if (!strcasecmp(v->name, "context")) {
         ast_copy_string(default_context, v->value, sizeof(default_context));
      } else if (!strcasecmp(v->name, "allowguest")) {
         global_allowguest = ast_true(v->value) ? 1 : 0;
      } else if (!strcasecmp(v->name, "realm")) {
         ast_copy_string(global_realm, v->value, sizeof(global_realm));
      } else if (!strcasecmp(v->name, "useragent")) {
         ast_copy_string(global_useragent, v->value, sizeof(global_useragent));
         if (option_debug)
            ast_log(LOG_DEBUG, "Setting SIP channel User-Agent Name to %s\n", global_useragent);
      } else if (!strcasecmp(v->name, "allowtransfer")) {
         global_allowtransfer = ast_true(v->value) ? TRANSFER_OPENFORALL : TRANSFER_CLOSED;
      } else if (!strcasecmp(v->name, "rtcachefriends")) {
         ast_set2_flag(&global_flags[1], ast_true(v->value), SIP_PAGE2_RTCACHEFRIENDS);   
      } else if (!strcasecmp(v->name, "rtsavesysname")) {
         ast_set2_flag(&global_flags[1], ast_true(v->value), SIP_PAGE2_RTSAVE_SYSNAME);   
      } else if (!strcasecmp(v->name, "rtupdate")) {
         ast_set2_flag(&global_flags[1], ast_true(v->value), SIP_PAGE2_RTUPDATE);   
      } else if (!strcasecmp(v->name, "ignoreregexpire")) {
         ast_set2_flag(&global_flags[1], ast_true(v->value), SIP_PAGE2_IGNOREREGEXPIRE);  
      } else if (!strcasecmp(v->name, "t1min")) {
         global_t1min = atoi(v->value);
      } else if (!strcasecmp(v->name, "rtautoclear")) {
         int i = atoi(v->value);
         if (i > 0)
            global_rtautoclear = i;
         else
            i = 0;
         ast_set2_flag(&global_flags[1], i || ast_true(v->value), SIP_PAGE2_RTAUTOCLEAR);
      } else if (!strcasecmp(v->name, "usereqphone")) {
         ast_set2_flag(&global_flags[0], ast_true(v->value), SIP_USEREQPHONE);   
      } else if (!strcasecmp(v->name, "relaxdtmf")) {
         global_relaxdtmf = ast_true(v->value);
      } else if (!strcasecmp(v->name, "checkmwi")) {
         if ((sscanf(v->value, "%d", &global_mwitime) != 1) || (global_mwitime < 0)) {
            ast_log(LOG_WARNING, "'%s' is not a valid MWI time setting at line %d.  Using default (10).\n", v->value, v->lineno);
            global_mwitime = DEFAULT_MWITIME;
         }
      } else if (!strcasecmp(v->name, "vmexten")) {
         ast_copy_string(default_vmexten, v->value, sizeof(default_vmexten));
      } else if (!strcasecmp(v->name, "rtptimeout")) {
         if ((sscanf(v->value, "%d", &global_rtptimeout) != 1) || (global_rtptimeout < 0)) {
            ast_log(LOG_WARNING, "'%s' is not a valid RTP hold time at line %d.  Using default.\n", v->value, v->lineno);
            global_rtptimeout = 0;
         }
      } else if (!strcasecmp(v->name, "rtpholdtimeout")) {
         if ((sscanf(v->value, "%d", &global_rtpholdtimeout) != 1) || (global_rtpholdtimeout < 0)) {
            ast_log(LOG_WARNING, "'%s' is not a valid RTP hold time at line %d.  Using default.\n", v->value, v->lineno);
            global_rtpholdtimeout = 0;
         }
      } else if (!strcasecmp(v->name, "rtpkeepalive")) {
         if ((sscanf(v->value, "%d", &global_rtpkeepalive) != 1) || (global_rtpkeepalive < 0)) {
            ast_log(LOG_WARNING, "'%s' is not a valid RTP keepalive time at line %d.  Using default.\n", v->value, v->lineno);
            global_rtpkeepalive = 0;
         }
      } else if (!strcasecmp(v->name, "compactheaders")) {
         compactheaders = ast_true(v->value);
      } else if (!strcasecmp(v->name, "notifymimetype")) {
         ast_copy_string(default_notifymime, v->value, sizeof(default_notifymime));
      } else if (!strncasecmp(v->name, "limitonpeer", 11)) {
         global_limitonpeers = ast_true(v->value);
      } else if (!strcasecmp(v->name, "directrtpsetup")) {
         global_directrtpsetup = ast_true(v->value);
      } else if (!strcasecmp(v->name, "notifyringing")) {
         global_notifyringing = ast_true(v->value);
      } else if (!strcasecmp(v->name, "notifyhold")) {
         global_notifyhold = ast_true(v->value);
      } else if (!strcasecmp(v->name, "alwaysauthreject")) {
         global_alwaysauthreject = ast_true(v->value);
      } else if (!strcasecmp(v->name, "mohinterpret") 
         || !strcasecmp(v->name, "musicclass") || !strcasecmp(v->name, "musiconhold")) {
         ast_copy_string(default_mohinterpret, v->value, sizeof(default_mohinterpret));
      } else if (!strcasecmp(v->name, "mohsuggest")) {
         ast_copy_string(default_mohsuggest, v->value, sizeof(default_mohsuggest));
      } else if (!strcasecmp(v->name, "language")) {
         ast_copy_string(default_language, v->value, sizeof(default_language));
      } else if (!strcasecmp(v->name, "regcontext")) {
         ast_copy_string(newcontexts, v->value, sizeof(newcontexts));
         stringp = newcontexts;
         /* Let's remove any contexts that are no longer defined in regcontext */
         cleanup_stale_contexts(stringp, oldregcontext);
         /* Create contexts if they don't exist already */
         while ((context = strsep(&stringp, "&"))) {
            if (!ast_context_find(context))
               ast_context_create(NULL, context,"SIP");
         }
         ast_copy_string(global_regcontext, v->value, sizeof(global_regcontext));
      } else if (!strcasecmp(v->name, "callerid")) {
         ast_copy_string(default_callerid, v->value, sizeof(default_callerid));
      } else if (!strcasecmp(v->name, "fromdomain")) {
         ast_copy_string(default_fromdomain, v->value, sizeof(default_fromdomain));
      } else if (!strcasecmp(v->name, "outboundproxy")) {
         if (ast_get_ip_or_srv(&outboundproxyip, v->value, srvlookup ? "_sip._udp" : NULL) < 0)
            ast_log(LOG_WARNING, "Unable to locate host '%s'\n", v->value);
      } else if (!strcasecmp(v->name, "outboundproxyport")) {
         /* Port needs to be after IP */
         sscanf(v->value, "%d", &format);
         outboundproxyip.sin_port = htons(format);
      } else if (!strcasecmp(v->name, "autocreatepeer")) {
         autocreatepeer = ast_true(v->value);
      } else if (!strcasecmp(v->name, "srvlookup")) {
         srvlookup = ast_true(v->value);
      } else if (!strcasecmp(v->name, "pedantic")) {
         pedanticsipchecking = ast_true(v->value);
      } else if (!strcasecmp(v->name, "maxexpirey") || !strcasecmp(v->name, "maxexpiry")) {
         max_expiry = atoi(v->value);
         if (max_expiry < 1)
            max_expiry = DEFAULT_MAX_EXPIRY;
      } else if (!strcasecmp(v->name, "minexpirey") || !strcasecmp(v->name, "minexpiry")) {
         min_expiry = atoi(v->value);
         if (min_expiry < 1)
            min_expiry = DEFAULT_MIN_EXPIRY;
      } else if (!strcasecmp(v->name, "defaultexpiry") || !strcasecmp(v->name, "defaultexpirey")) {
         default_expiry = atoi(v->value);
         if (default_expiry < 1)
            default_expiry = DEFAULT_DEFAULT_EXPIRY;
      } else if (!strcasecmp(v->name, "sipdebug")) {  /* XXX maybe ast_set2_flags ? */
         if (ast_true(v->value))
            ast_set_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONFIG);
      } else if (!strcasecmp(v->name, "dumphistory")) {
         dumphistory = ast_true(v->value);
      } else if (!strcasecmp(v->name, "recordhistory")) {
         recordhistory = ast_true(v->value);
      } else if (!strcasecmp(v->name, "registertimeout")) {
         global_reg_timeout = atoi(v->value);
         if (global_reg_timeout < 1)
            global_reg_timeout = DEFAULT_REGISTRATION_TIMEOUT;
      } else if (!strcasecmp(v->name, "registerattempts")) {
         global_regattempts_max = atoi(v->value);
      } else if (!strcasecmp(v->name, "bindaddr")) {
         if (!(hp = ast_gethostbyname(v->value, &ahp))) {
            ast_log(LOG_WARNING, "Invalid address: %s\n", v->value);
         } else {
            memcpy(&bindaddr.sin_addr, hp->h_addr, sizeof(bindaddr.sin_addr));
         }
      } else if (!strcasecmp(v->name, "localnet")) {
         struct ast_ha *na;
         if (!(na = ast_append_ha("d", v->value, localaddr)))
            ast_log(LOG_WARNING, "Invalid localnet value: %s\n", v->value);
         else
            localaddr = na;
      } else if (!strcasecmp(v->name, "localmask")) {
         ast_log(LOG_WARNING, "Use of localmask is no long supported -- use localnet with mask syntax\n");
      } else if (!strcasecmp(v->name, "externip")) {
         if (!(hp = ast_gethostbyname(v->value, &ahp))) 
            ast_log(LOG_WARNING, "Invalid address for externip keyword: %s\n", v->value);
         else
            memcpy(&externip.sin_addr, hp->h_addr, sizeof(externip.sin_addr));
         externexpire = 0;
      } else if (!strcasecmp(v->name, "externhost")) {
         ast_copy_string(externhost, v->value, sizeof(externhost));
         if (!(hp = ast_gethostbyname(externhost, &ahp))) 
            ast_log(LOG_WARNING, "Invalid address for externhost keyword: %s\n", externhost);
         else
            memcpy(&externip.sin_addr, hp->h_addr, sizeof(externip.sin_addr));
         externexpire = time(NULL);
      } else if (!strcasecmp(v->name, "externrefresh")) {
         if (sscanf(v->value, "%d", &externrefresh) != 1) {
            ast_log(LOG_WARNING, "Invalid externrefresh value '%s', must be an integer >0 at line %d\n", v->value, v->lineno);
            externrefresh = 10;
         }
      } else if (!strcasecmp(v->name, "allow")) {
         ast_parse_allow_disallow(&default_prefs, &global_capability, v->value, 1);
      } else if (!strcasecmp(v->name, "disallow")) {
         ast_parse_allow_disallow(&default_prefs, &global_capability, v->value, 0);
      } else if (!strcasecmp(v->name, "autoframing")) {
         global_autoframing = ast_true(v->value);
      } else if (!strcasecmp(v->name, "allowexternaldomains")) {
         allow_external_domains = ast_true(v->value);
      } else if (!strcasecmp(v->name, "autodomain")) {
         auto_sip_domains = ast_true(v->value);
      } else if (!strcasecmp(v->name, "domain")) {
         char *domain = ast_strdupa(v->value);
         char *context = strchr(domain, ',');

         if (context)
            *context++ = '\0';

         if (option_debug && ast_strlen_zero(context))
            ast_log(LOG_DEBUG, "No context specified at line %d for domain '%s'\n", v->lineno, domain);
         if (ast_strlen_zero(domain))
            ast_log(LOG_WARNING, "Empty domain specified at line %d\n", v->lineno);
         else
            add_sip_domain(ast_strip(domain), SIP_DOMAIN_CONFIG, context ? ast_strip(context) : "");
      } else if (!strcasecmp(v->name, "register")) {
         if (sip_register(v->value, v->lineno) == 0)
            registry_count++;
      } else if (!strcasecmp(v->name, "tos")) {
         if (!ast_str2tos(v->value, &temp_tos)) {
            global_tos_sip = temp_tos;
            global_tos_audio = temp_tos;
            global_tos_video = temp_tos;
            ast_log(LOG_WARNING, "tos value at line %d is deprecated.  See doc/ip-tos.txt for more information.\n", v->lineno);
         } else
            ast_log(LOG_WARNING, "Invalid tos value at line %d, See doc/ip-tos.txt for more information.\n", v->lineno);
      } else if (!strcasecmp(v->name, "tos_sip")) {
         if (ast_str2tos(v->value, &global_tos_sip))
            ast_log(LOG_WARNING, "Invalid tos_sip value at line %d, recommended value is 'cs3'. See doc/ip-tos.txt.\n", v->lineno);
      } else if (!strcasecmp(v->name, "tos_audio")) {
         if (ast_str2tos(v->value, &global_tos_audio))
            ast_log(LOG_WARNING, "Invalid tos_audio value at line %d, recommended value is 'ef'. See doc/ip-tos.txt.\n", v->lineno);
      } else if (!strcasecmp(v->name, "tos_video")) {
         if (ast_str2tos(v->value, &global_tos_video))
            ast_log(LOG_WARNING, "Invalid tos_video value at line %d, recommended value is 'af41'. See doc/ip-tos.txt.\n", v->lineno);
      } else if (!strcasecmp(v->name, "bindport")) {
         if (sscanf(v->value, "%d", &ourport) == 1) {
            bindaddr.sin_port = htons(ourport);
         } else {
            ast_log(LOG_WARNING, "Invalid port number '%s' at line %d of %s\n", v->value, v->lineno, config);
         }
      } else if (!strcasecmp(v->name, "qualify")) {
         if (!strcasecmp(v->value, "no")) {
            default_qualify = 0;
         } else if (!strcasecmp(v->value, "yes")) {
            default_qualify = DEFAULT_MAXMS;
         } else if (sscanf(v->value, "%d", &default_qualify) != 1) {
            ast_log(LOG_WARNING, "Qualification default should be 'yes', 'no', or a number of milliseconds at line %d of sip.conf\n", v->lineno);
            default_qualify = 0;
         }
      } else if (!strcasecmp(v->name, "callevents")) {
         global_callevents = ast_true(v->value);
      } else if (!strcasecmp(v->name, "maxcallbitrate")) {
         default_maxcallbitrate = atoi(v->value);
         if (default_maxcallbitrate < 0)
            default_maxcallbitrate = DEFAULT_MAX_CALL_BITRATE;
      } else if (!strcasecmp(v->name, "matchexterniplocally")) {
         global_matchexterniplocally = ast_true(v->value);
      }
   }

   if (!allow_external_domains && AST_LIST_EMPTY(&domain_list)) {
      ast_log(LOG_WARNING, "To disallow external domains, you need to configure local SIP domains.\n");
      allow_external_domains = 1;
   }
   
   /* Build list of authentication to various SIP realms, i.e. service providers */
   for (v = ast_variable_browse(cfg, "authentication"); v ; v = v->next) {
      /* Format for authentication is auth = username:password@realm */
      if (!strcasecmp(v->name, "auth"))
         authl = add_realm_authentication(authl, v->value, v->lineno);
   }
   
   ucfg = ast_config_load("users.conf");
   if (ucfg) {
      struct ast_variable *gen;
      int genhassip, genregistersip;
      const char *hassip, *registersip;
      
      genhassip = ast_true(ast_variable_retrieve(ucfg, "general", "hassip"));
      genregistersip = ast_true(ast_variable_retrieve(ucfg, "general", "registersip"));
      gen = ast_variable_browse(ucfg, "general");
      cat = ast_category_browse(ucfg, NULL);
      while (cat) {
         if (strcasecmp(cat, "general")) {
            hassip = ast_variable_retrieve(ucfg, cat, "hassip");
            registersip = ast_variable_retrieve(ucfg, cat, "registersip");
            if (ast_true(hassip) || (!hassip && genhassip)) {
               peer = build_peer(cat, gen, ast_variable_browse(ucfg, cat), 0);
               if (peer) {
                  ASTOBJ_CONTAINER_LINK(&peerl,peer);
                  ASTOBJ_UNREF(peer, sip_destroy_peer);
                  peer_count++;
               }
            }
            if (ast_true(registersip) || (!registersip && genregistersip)) {
               char tmp[256];
               const char *host = ast_variable_retrieve(ucfg, cat, "host");
               const char *username = ast_variable_retrieve(ucfg, cat, "username");
               const char *secret = ast_variable_retrieve(ucfg, cat, "secret");
               const char *contact = ast_variable_retrieve(ucfg, cat, "contact");
               if (!host)
                  host = ast_variable_retrieve(ucfg, "general", "host");
               if (!username)
                  username = ast_variable_retrieve(ucfg, "general", "username");
               if (!secret)
                  secret = ast_variable_retrieve(ucfg, "general", "secret");
               if (!contact)
                  contact = "s";
               if (!ast_strlen_zero(username) && !ast_strlen_zero(host)) {
                  if (!ast_strlen_zero(secret))
                     snprintf(tmp, sizeof(tmp), "%s:%s@%s/%s", username, secret, host, contact);
                  else
                     snprintf(tmp, sizeof(tmp), "%s@%s/%s", username, host, contact);
                  if (sip_register(tmp, 0) == 0)
                     registry_count++;
               }
            }
         }
         cat = ast_category_browse(ucfg, cat);
      }
      ast_config_destroy(ucfg);
   }
   

   /* Load peers, users and friends */
   cat = NULL;
   while ( (cat = ast_category_browse(cfg, cat)) ) {
      const char *utype;
      if (!strcasecmp(cat, "general") || !strcasecmp(cat, "authentication"))
         continue;
      utype = ast_variable_retrieve(cfg, cat, "type");
      if (!utype) {
         ast_log(LOG_WARNING, "Section '%s' lacks type\n", cat);
         continue;
      } else {
         int is_user = 0, is_peer = 0;
         if (!strcasecmp(utype, "user"))
            is_user = 1;
         else if (!strcasecmp(utype, "friend"))
            is_user = is_peer = 1;
         else if (!strcasecmp(utype, "peer"))
            is_peer = 1;
         else {
            ast_log(LOG_WARNING, "Unknown type '%s' for '%s' in %s\n", utype, cat, "sip.conf");
            continue;
         }
         if (is_user) {
            user = build_user(cat, ast_variable_browse(cfg, cat), 0);
            if (user) {
               ASTOBJ_CONTAINER_LINK(&userl,user);
               ASTOBJ_UNREF(user, sip_destroy_user);
               user_count++;
            }
         }
         if (is_peer) {
            peer = build_peer(cat, ast_variable_browse(cfg, cat), NULL, 0);
            if (peer) {
               ASTOBJ_CONTAINER_LINK(&peerl,peer);
               ASTOBJ_UNREF(peer, sip_destroy_peer);
               peer_count++;
            }
         }
      }
   }
   if (ast_find_ourip(&__ourip, bindaddr)) {
      ast_log(LOG_WARNING, "Unable to get own IP address, SIP disabled\n");
      return 0;
   }
   if (!ntohs(bindaddr.sin_port))
      bindaddr.sin_port = ntohs(STANDARD_SIP_PORT);
   bindaddr.sin_family = AF_INET;
   ast_mutex_lock(&netlock);
   if ((sipsock > -1) && (memcmp(&old_bindaddr, &bindaddr, sizeof(struct sockaddr_in)))) {
      close(sipsock);
      sipsock = -1;
   }
   if (sipsock < 0) {
      sipsock = socket(AF_INET, SOCK_DGRAM, 0);
      if (sipsock < 0) {
         ast_log(LOG_WARNING, "Unable to create SIP socket: %s\n", strerror(errno));
         return -1;
      } else {
         /* Allow SIP clients on the same host to access us: */
         const int reuseFlag = 1;

         setsockopt(sipsock, SOL_SOCKET, SO_REUSEADDR,
               (const char*)&reuseFlag,
               sizeof reuseFlag);

         ast_enable_packet_fragmentation(sipsock);

         if (bind(sipsock, (struct sockaddr *)&bindaddr, sizeof(bindaddr)) < 0) {
            ast_log(LOG_WARNING, "Failed to bind to %s:%d: %s\n",
            ast_inet_ntoa(bindaddr.sin_addr), ntohs(bindaddr.sin_port),
            strerror(errno));
            close(sipsock);
            sipsock = -1;
         } else {
            if (option_verbose > 1) { 
               ast_verbose(VERBOSE_PREFIX_2 "SIP Listening on %s:%d\n", 
               ast_inet_ntoa(bindaddr.sin_addr), ntohs(bindaddr.sin_port));
               ast_verbose(VERBOSE_PREFIX_2 "Using SIP TOS: %s\n", ast_tos2str(global_tos_sip));
            }
            if (setsockopt(sipsock, IPPROTO_IP, IP_TOS, &global_tos_sip, sizeof(global_tos_sip))) 
               ast_log(LOG_WARNING, "Unable to set SIP TOS to %s\n", ast_tos2str(global_tos_sip));
         }
      }
   }
   ast_mutex_unlock(&netlock);

   /* Add default domains - host name, IP address and IP:port */
   /* Only do this if user added any sip domain with "localdomains" */
   /* In order to *not* break backwards compatibility */
   /*    Some phones address us at IP only, some with additional port number */
   if (auto_sip_domains) {
      char temp[MAXHOSTNAMELEN];

      /* First our default IP address */
      if (bindaddr.sin_addr.s_addr)
         add_sip_domain(ast_inet_ntoa(bindaddr.sin_addr), SIP_DOMAIN_AUTO, NULL);
      else
         ast_log(LOG_NOTICE, "Can't add wildcard IP address to domain list, please add IP address to domain manually.\n");

      /* Our extern IP address, if configured */
      if (externip.sin_addr.s_addr)
         add_sip_domain(ast_inet_ntoa(externip.sin_addr), SIP_DOMAIN_AUTO, NULL);

      /* Extern host name (NAT traversal support) */
      if (!ast_strlen_zero(externhost))
         add_sip_domain(externhost, SIP_DOMAIN_AUTO, NULL);
      
      /* Our host name */
      if (!gethostname(temp, sizeof(temp)))
         add_sip_domain(temp, SIP_DOMAIN_AUTO, NULL);
   }

   /* Release configuration from memory */
   ast_config_destroy(cfg);

   /* Load the list of manual NOTIFY types to support */
   if (notify_types)
      ast_config_destroy(notify_types);
   notify_types = ast_config_load(notify_config);

   /* Done, tell the manager */
   manager_event(EVENT_FLAG_SYSTEM, "ChannelReload", "Channel: SIP\r\nReloadReason: %s\r\nRegistry_Count: %d\r\nPeer_Count: %d\r\nUser_Count: %d\r\n\r\n", channelreloadreason2txt(reason), registry_count, peer_count, user_count);

   return 0;
}

static int reply_digest	(	struct sip_pvt *	p,
		struct sip_request *	req,
		char *	header,
		int	sipmethod,
		char *	digest,
		int	digest_len
	)			[static]

reply to authentication for outbound registrations

Returns:

Returns -1 if we have no auth

Note:

This is used for register= servers in sip.conf, SIP proxies we register with for receiving calls from.

Definition at line 11113 of file chan_sip.c.

References ast_log(), ast_string_field_index, ast_string_field_index_set, ast_string_field_set, ast_strlen_zero(), build_reply_digest(), get_header(), key(), keys, LOG_WARNING, sip_registry::noncecount, sip_pvt::noncecount, sip_pvt::registry, and strsep().

Referenced by do_proxy_auth(), and do_register_auth().

{
   char tmp[512];
   char *c;
   char oldnonce[256];

   /* table of recognised keywords, and places where they should be copied */
   const struct x {
      const char *key;
      int field_index;
   } *i, keys[] = {
      { "realm=", ast_string_field_index(p, realm) },
      { "nonce=", ast_string_field_index(p, nonce) },
      { "opaque=", ast_string_field_index(p, opaque) },
      { "qop=", ast_string_field_index(p, qop) },
      { "domain=", ast_string_field_index(p, domain) },
      { NULL, 0 },
   };

   ast_copy_string(tmp, get_header(req, header), sizeof(tmp));
   if (ast_strlen_zero(tmp)) 
      return -1;
   if (strncasecmp(tmp, "Digest ", strlen("Digest "))) {
      ast_log(LOG_WARNING, "missing Digest.\n");
      return -1;
   }
   c = tmp + strlen("Digest ");
   ast_copy_string(oldnonce, p->nonce, sizeof(oldnonce));
   while (c && *(c = ast_skip_blanks(c))) {  /* lookup for keys */
      for (i = keys; i->key != NULL; i++) {
         char *src, *separator;
         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 == '"') {
            src = ++c;
            separator = "\"";
         } else {
            src = c;
            separator = ",";
         }
         strsep(&c, separator); /* clear separator and move ptr */
         ast_string_field_index_set(p, i->field_index, src);
         break;
      }
      if (i->key == NULL) /* not found, try ',' */
         strsep(&c, ",");
   }
   /* Reset nonce count */
   if (strcmp(p->nonce, oldnonce)) 
      p->noncecount = 0;

   /* Save auth data for following registrations */
   if (p->registry) {
      struct sip_registry *r = p->registry;

      if (strcmp(r->nonce, p->nonce)) {
         ast_string_field_set(r, realm, p->realm);
         ast_string_field_set(r, nonce, p->nonce);
         ast_string_field_set(r, domain, p->domain);
         ast_string_field_set(r, opaque, p->opaque);
         ast_string_field_set(r, qop, p->qop);
         r->noncecount = 0;
      }
   }
   return build_reply_digest(p, sipmethod, digest, digest_len); 
}

static int reqprep	(	struct sip_request *	req,
		struct sip_pvt *	p,
		int	sipmethod,
		int	seqno,
		int	newbranch
	)			[static]

Initialize a SIP request message (not the initial one in a dialog).

< Strict routing flag

Definition at line 5633 of file chan_sip.c.

References add_header(), add_route(), ast_log(), ast_random(), ast_strlen_zero(), ast_test_flag, sip_pvt::branch, build_via(), copy_header(), DEFAULT_MAX_FORWARDS, FALSE, sip_pvt::flags, get_header(), get_in_brackets(), sip_route::hop, init_req(), sip_pvt::initreq, sip_pvt::lastmsg, LOG_DEBUG, sip_route::next, sip_pvt::ocseq, sip_request::rlPart2, sip_pvt::route, set_destination(), SIP_ACK, SIP_BYE, SIP_CANCEL, SIP_MESSAGE, sip_methods, SIP_OUTGOING, sipdebug, strcasestr(), strsep(), sip_pvt::tag, text, cfsip_methods::text, and TRUE.

{
   struct sip_request *orig = &p->initreq;
   char stripped[80];
   char tmp[80];
   char newto[256];
   const char *c;
   const char *ot, *of;
   int is_strict = FALSE;     /*!< Strict routing flag */

   memset(req, 0, sizeof(struct sip_request));
   
   snprintf(p->lastmsg, sizeof(p->lastmsg), "Tx: %s", sip_methods[sipmethod].text);
   
   if (!seqno) {
      p->ocseq++;
      seqno = p->ocseq;
   }
   
   if (newbranch) {
      p->branch ^= ast_random();
      build_via(p);
   }

   /* Check for strict or loose router */
   if (p->route && !ast_strlen_zero(p->route->hop) && strstr(p->route->hop,";lr") == NULL) {
      is_strict = TRUE;
      if (sipdebug)
         ast_log(LOG_DEBUG, "Strict routing enforced for session %s\n", p->callid);
   }

   if (sipmethod == SIP_CANCEL)
      c = p->initreq.rlPart2; /* Use original URI */
   else if (sipmethod == SIP_ACK) {
      /* Use URI from Contact: in 200 OK (if INVITE) 
      (we only have the contacturi on INVITEs) */
      if (!ast_strlen_zero(p->okcontacturi))
         c = is_strict ? p->route->hop : p->okcontacturi;
      else
         c = p->initreq.rlPart2;
   } else if (!ast_strlen_zero(p->okcontacturi)) 
      c = is_strict ? p->route->hop : p->okcontacturi; /* Use for BYE or REINVITE */
   else if (!ast_strlen_zero(p->uri)) 
      c = p->uri;
   else {
      char *n;
      /* We have no URI, use To: or From:  header as URI (depending on direction) */
      ast_copy_string(stripped, get_header(orig, (ast_test_flag(&p->flags[0], SIP_OUTGOING)) ? "To" : "From"),
            sizeof(stripped));
      n = get_in_brackets(stripped);
      c = strsep(&n, ";"); /* trim ; and beyond */
   }  
   init_req(req, sipmethod, c);

   snprintf(tmp, sizeof(tmp), "%d %s", seqno, sip_methods[sipmethod].text);

   add_header(req, "Via", p->via);
   if (p->route) {
      set_destination(p, p->route->hop);
      add_route(req, is_strict ? p->route->next : p->route);
   }

   ot = get_header(orig, "To");
   of = get_header(orig, "From");

   /* Add tag *unless* this is a CANCEL, in which case we need to send it exactly
      as our original request, including tag (or presumably lack thereof) */
   if (!strcasestr(ot, "tag=") && sipmethod != SIP_CANCEL) {
      /* Add the proper tag if we don't have it already.  If they have specified
         their tag, use it.  Otherwise, use our own tag */
      if (ast_test_flag(&p->flags[0], SIP_OUTGOING) && !ast_strlen_zero(p->theirtag))
         snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
      else if (!ast_test_flag(&p->flags[0], SIP_OUTGOING))
         snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->tag);
      else
         snprintf(newto, sizeof(newto), "%s", ot);
      ot = newto;
   }

   if (ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
      add_header(req, "From", of);
      add_header(req, "To", ot);
   } else {
      add_header(req, "From", ot);
      add_header(req, "To", of);
   }
   /* Do not add Contact for MESSAGE, BYE and Cancel requests */
   if (sipmethod != SIP_BYE && sipmethod != SIP_CANCEL && sipmethod != SIP_MESSAGE)
      add_header(req, "Contact", p->our_contact);

   copy_header(req, orig, "Call-ID");
   add_header(req, "CSeq", tmp);

   if (!ast_strlen_zero(global_useragent))
      add_header(req, "User-Agent", global_useragent);
   add_header(req, "Max-Forwards", DEFAULT_MAX_FORWARDS);

   if (!ast_strlen_zero(p->rpid))
      add_header(req, "Remote-Party-ID", p->rpid);

   return 0;
}

static int respprep	(	struct sip_request *	resp,
		struct sip_pvt *	p,
		const char *	msg,
		const struct sip_request *	req
	)			[static]

Prepare SIP response packet.

Definition at line 5585 of file chan_sip.c.

References add_header(), ALLOWED_METHODS, ast_strlen_zero(), ast_test_flag, copy_all_header(), copy_header(), copy_via_headers(), sip_pvt::expiry, sip_pvt::flags, get_header(), init_resp(), sip_pvt::method, SIP_OUTGOING, SIP_REGISTER, SIP_SUBSCRIBE, strcasestr(), SUPPORTED_EXTENSIONS, and sip_pvt::tag.

{
   char newto[256];
   const char *ot;

   init_resp(resp, msg);
   copy_via_headers(p, resp, req, "Via");
   if (msg[0] == '2')
      copy_all_header(resp, req, "Record-Route");
   copy_header(resp, req, "From");
   ot = get_header(req, "To");
   if (!strcasestr(ot, "tag=") && strncmp(msg, "100", 3)) {
      /* Add the proper tag if we don't have it already.  If they have specified
         their tag, use it.  Otherwise, use our own tag */
      if (!ast_strlen_zero(p->theirtag) && ast_test_flag(&p->flags[0], SIP_OUTGOING))
         snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
      else if (p->tag && !ast_test_flag(&p->flags[0], SIP_OUTGOING))
         snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->tag);
      else
         ast_copy_string(newto, ot, sizeof(newto));
      ot = newto;
   }
   add_header(resp, "To", ot);
   copy_header(resp, req, "Call-ID");
   copy_header(resp, req, "CSeq");
   if (!ast_strlen_zero(global_useragent))
      add_header(resp, "User-Agent", global_useragent);
   add_header(resp, "Allow", ALLOWED_METHODS);
   add_header(resp, "Supported", SUPPORTED_EXTENSIONS);
   if (msg[0] == '2' && (p->method == SIP_SUBSCRIBE || p->method == SIP_REGISTER)) {
      /* For registration responses, we also need expiry and
         contact info */
      char tmp[256];

      snprintf(tmp, sizeof(tmp), "%d", p->expiry);
      add_header(resp, "Expires", tmp);
      if (p->expiry) {  /* Only add contact if we have an expiry time */
         char contact[BUFSIZ];
         snprintf(contact, sizeof(contact), "%s;expires=%d", p->our_contact, p->expiry);
         add_header(resp, "Contact", contact);  /* Not when we unregister */
      }
   } else if (msg[0] != '4' && p->our_contact[0]) {
      add_header(resp, "Contact", p->our_contact);
   }
   return 0;
}

static int restart_monitor

(

void

)

[static]

Start the channel monitor thread.

Definition at line 15180 of file chan_sip.c.

References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_pthread_create_background, AST_PTHREADT_NULL, AST_PTHREADT_STOP, do_monitor(), LOG_ERROR, and LOG_WARNING.

{
   /* If we're supposed to be stopped -- stay stopped */
   if (monitor_thread == AST_PTHREADT_STOP)
      return 0;
   ast_mutex_lock(&monlock);
   if (monitor_thread == pthread_self()) {
      ast_mutex_unlock(&monlock);
      ast_log(LOG_WARNING, "Cannot kill myself\n");
      return -1;
   }
   if (monitor_thread != AST_PTHREADT_NULL) {
      /* Wake up the thread */
      pthread_kill(monitor_thread, SIGURG);
   } else {
      /* Start a new monitor */
      if (ast_pthread_create_background(&monitor_thread, NULL, do_monitor, NULL) < 0) {
         ast_mutex_unlock(&monlock);
         ast_log(LOG_ERROR, "Unable to start monitor thread.\n");
         return -1;
      }
   }
   ast_mutex_unlock(&monlock);
   return 0;
}

static int retrans_pkt

(

void *

data

)

[static]

Retransmit SIP message if no answer (Called from scheduler).

Definition at line 1850 of file chan_sip.c.

References __sip_xmit(), append_history, ast_channel_trylock, ast_channel_unlock, ast_inet_ntoa(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_queue_hangup(), ast_set_flag, ast_test_flag, ast_verbose(), sip_pkt::data, DEFAULT_RETRANS, FLAG_FATAL, FLAG_RESPONSE, sip_pvt::flags, free, sip_pvt::lock, LOG_DEBUG, LOG_WARNING, MAX_RETRANS, sip_pkt::method, sip_pkt::next, option_debug, sip_pvt::owner, sip_pkt::owner, sip_pkt::packetlen, sip_pvt::packets, sip_pkt::retrans, sip_pkt::retransid, sip_alreadygone(), sip_debug_test_pvt(), SIP_INVITE, sip_methods, sip_nat_mode(), SIP_NEEDDESTROY, SIP_OPTIONS, sip_real_dst(), sipdebug, cfsip_methods::text, sip_pkt::timer_a, and sip_pkt::timer_t1.

{
   struct sip_pkt *pkt = data, *prev, *cur = NULL;
   int reschedule = DEFAULT_RETRANS;

   /* Lock channel PVT */
   ast_mutex_lock(&pkt->owner->lock);

   if (pkt->retrans < MAX_RETRANS) {
      pkt->retrans++;
      if (!pkt->timer_t1) {   /* Re-schedule using timer_a and timer_t1 */
         if (sipdebug && option_debug > 3)
            ast_log(LOG_DEBUG, "SIP TIMER: Not rescheduling id #%d:%s (Method %d) (No timer T1)\n", pkt->retransid, sip_methods[pkt->method].text, pkt->method);
      } else {
         int siptimer_a;

         if (sipdebug && option_debug > 3)
            ast_log(LOG_DEBUG, "SIP TIMER: Rescheduling retransmission #%d (%d) %s - %d\n", pkt->retransid, pkt->retrans, sip_methods[pkt->method].text, pkt->method);
         if (!pkt->timer_a)
            pkt->timer_a = 2 ;
         else
            pkt->timer_a = 2 * pkt->timer_a;
 
         /* For non-invites, a maximum of 4 secs */
         siptimer_a = pkt->timer_t1 * pkt->timer_a;   /* Double each time */
         if (pkt->method != SIP_INVITE && siptimer_a > 4000)
            siptimer_a = 4000;
      
         /* Reschedule re-transmit */
         reschedule = siptimer_a;
         if (option_debug > 3)
            ast_log(LOG_DEBUG, "** SIP timers: Rescheduling retransmission %d to %d ms (t1 %d ms (Retrans id #%d)) \n", pkt->retrans +1, siptimer_a, pkt->timer_t1, pkt->retransid);
      } 

      if (sip_debug_test_pvt(pkt->owner)) {
         const struct sockaddr_in *dst = sip_real_dst(pkt->owner);
         ast_verbose("Retransmitting #%d (%s) to %s:%d:\n%s\n---\n",
            pkt->retrans, sip_nat_mode(pkt->owner),
            ast_inet_ntoa(dst->sin_addr),
            ntohs(dst->sin_port), pkt->data);
      }

      append_history(pkt->owner, "ReTx", "%d %s", reschedule, pkt->data);
      __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
      ast_mutex_unlock(&pkt->owner->lock);
      return  reschedule;
   } 
   /* Too many retries */
   if (pkt->owner && pkt->method != SIP_OPTIONS) {
      if (ast_test_flag(pkt, FLAG_FATAL) || sipdebug) /* Tell us if it's critical or if we're debugging */
         ast_log(LOG_WARNING, "Maximum retries exceeded on transmission %s for seqno %d (%s %s)\n", pkt->owner->callid, pkt->seqno, (ast_test_flag(pkt, FLAG_FATAL)) ? "Critical" : "Non-critical", (ast_test_flag(pkt, FLAG_RESPONSE)) ? "Response" : "Request");
   } else {
      if ((pkt->method == SIP_OPTIONS) && sipdebug)
         ast_log(LOG_WARNING, "Cancelling retransmit of OPTIONs (call id %s) \n", pkt->owner->callid);
   }
   append_history(pkt->owner, "MaxRetries", "%s", (ast_test_flag(pkt, FLAG_FATAL)) ? "(Critical)" : "(Non-critical)");
      
   pkt->retransid = -1;

   if (ast_test_flag(pkt, FLAG_FATAL)) {
      while(pkt->owner->owner && ast_channel_trylock(pkt->owner->owner)) {
         ast_mutex_unlock(&pkt->owner->lock);   /* SIP_PVT, not channel */
         usleep(1);
         ast_mutex_lock(&pkt->owner->lock);
      }
      if (pkt->owner->owner) {
         sip_alreadygone(pkt->owner);
         ast_log(LOG_WARNING, "Hanging up call %s - no reply to our critical packet.\n", pkt->owner->callid);
         ast_queue_hangup(pkt->owner->owner);
         ast_channel_unlock(pkt->owner->owner);
      } else {
         /* If no channel owner, destroy now */

         /* Let the peerpoke system expire packets when the timer expires for poke_noanswer */
         if (pkt->method != SIP_OPTIONS)
            ast_set_flag(&pkt->owner->flags[0], SIP_NEEDDESTROY); 
      }
   }
   /* In any case, go ahead and remove the packet */
   for (prev = NULL, cur = pkt->owner->packets; cur; prev = cur, cur = cur->next) {
      if (cur == pkt)
         break;
   }
   if (cur) {
      if (prev)
         prev->next = cur->next;
      else
         pkt->owner->packets = cur->next;
      ast_mutex_unlock(&pkt->owner->lock);
      free(cur);
      pkt = NULL;
   } else
      ast_log(LOG_WARNING, "Weird, couldn't find packet owner!\n");
   if (pkt)
      ast_mutex_unlock(&pkt->owner->lock);
   return 0;
}

static int send_request	(	struct sip_pvt *	p,
		struct sip_request *	req,
		enum xmittype	reliable,
		int	seqno
	)			[static]

Send SIP Request to the other part of the dialogue.

Definition at line 2185 of file chan_sip.c.

References __sip_reliable_xmit(), __sip_xmit(), add_blank(), append_history, ast_inet_ntoa(), ast_test_flag, ast_verbose(), sip_request::data, sip_pvt::flags, get_header(), sip_request::len, sip_request::method, parse_copy(), sip_pvt::recv, sip_pvt::sa, sip_debug_test_pvt(), sip_methods, SIP_NAT_ROUTE, SIP_NO_HISTORY, and cfsip_methods::text.

{
   int res;

   add_blank(req);
   if (sip_debug_test_pvt(p)) {
      if (ast_test_flag(&p->flags[0], SIP_NAT_ROUTE))
         ast_verbose("%sTransmitting (NAT) to %s:%d:\n%s\n---\n", reliable ? "Reliably " : "", ast_inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port), req->data);
      else
         ast_verbose("%sTransmitting (no NAT) to %s:%d:\n%s\n---\n", reliable ? "Reliably " : "", ast_inet_ntoa(p->sa.sin_addr), ntohs(p->sa.sin_port), req->data);
   }
   if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY)) {
      struct sip_request tmp;
      parse_copy(&tmp, req);
      append_history(p, reliable ? "TxReqRel" : "TxReq", "%s / %s - %s", tmp.data, get_header(&tmp, "CSeq"), sip_methods[tmp.method].text);
   }
   res = (reliable) ?
      __sip_reliable_xmit(p, seqno, 0, req->data, req->len, (reliable > 1), req->method) :
      __sip_xmit(p, req->data, req->len);
   return res;
}

static int send_response	(	struct sip_pvt *	p,
		struct sip_request *	req,
		enum xmittype	reliable,
		int	seqno
	)			[static]

Transmit response on SIP request.

Definition at line 2157 of file chan_sip.c.

References __sip_reliable_xmit(), __sip_xmit(), add_blank(), append_history, ast_inet_ntoa(), ast_test_flag, ast_verbose(), sip_request::data, sip_pvt::flags, get_header(), sip_request::len, sip_request::method, parse_copy(), sip_debug_test_pvt(), sip_methods, sip_nat_mode(), SIP_NO_HISTORY, sip_real_dst(), SIP_RESPONSE, SIP_UNKNOWN, cfsip_methods::text, and XMIT_CRITICAL.

{
   int res;

   add_blank(req);
   if (sip_debug_test_pvt(p)) {
      const struct sockaddr_in *dst = sip_real_dst(p);

      ast_verbose("\n<--- %sTransmitting (%s) to %s:%d --->\n%s\n<------------>\n",
         reliable ? "Reliably " : "", sip_nat_mode(p),
         ast_inet_ntoa(dst->sin_addr),
         ntohs(dst->sin_port), req->data);
   }
   if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY)) {
      struct sip_request tmp;
      parse_copy(&tmp, req);
      append_history(p, reliable ? "TxRespRel" : "TxResp", "%s / %s - %s", tmp.data, get_header(&tmp, "CSeq"), 
         (tmp.method == SIP_RESPONSE || tmp.method == SIP_UNKNOWN) ? tmp.rlPart2 : sip_methods[tmp.method].text);
   }
   res = (reliable) ?
      __sip_reliable_xmit(p, seqno, 1, req->data, req->len, (reliable == XMIT_CRITICAL), req->method) :
      __sip_xmit(p, req->data, req->len);
   if (res > 0)
      return 0;
   return res;
}

static int set_address_from_contact

(

struct sip_pvt *

pvt

)

[static]

Change the other partys IP address based on given contact.

Definition at line 7698 of file chan_sip.c.

References ahp, ast_gethostbyname(), ast_log(), ast_strdupa, ast_test_flag, sip_pvt::flags, hp, LOG_NOTICE, LOG_WARNING, sip_pvt::recv, sip_pvt::sa, SIP_NAT_ROUTE, STANDARD_SIP_PORT, and strsep().

Referenced by handle_response_invite().

{
   struct hostent *hp;
   struct ast_hostent ahp;
   int port;
   char *c, *host, *pt;
   char *contact;


   if (ast_test_flag(&pvt->flags[0], SIP_NAT_ROUTE)) {
      /* NAT: Don't trust the contact field.  Just use what they came to us
         with. */
      pvt->sa = pvt->recv;
      return 0;
   }


   /* Work on a copy */
   contact = ast_strdupa(pvt->fullcontact);

   /* XXX this code is repeated all over */
   /* Make sure it's a SIP URL */
   if (strncasecmp(contact, "sip:", 4)) {
      ast_log(LOG_NOTICE, "'%s' is not a valid SIP contact (missing sip:) trying to use anyway\n", contact);
   } else
      contact += 4;

   /* Ditch arguments */
   /* XXX this code is replicated also shortly below */
   contact = strsep(&contact, ";"); /* trim ; and beyond */

   /* Grab host */
   host = strchr(contact, '@');
   if (!host) {   /* No username part */
      host = contact;
      c = NULL;
   } else {
      *host++ = '\0';
   }
   pt = strchr(host, ':');
   if (pt) {
      *pt++ = '\0';
      port = atoi(pt);
   } else
      port = STANDARD_SIP_PORT;

   /* XXX This could block for a long time XXX */
   /* We should only do this if it's a name, not an IP */
   hp = ast_gethostbyname(host, &ahp);
   if (!hp)  {
      ast_log(LOG_WARNING, "Invalid host name in Contact: (can't resolve in DNS) : '%s'\n", host);
      return -1;
   }
   pvt->sa.sin_family = AF_INET;
   memcpy(&pvt->sa.sin_addr, hp->h_addr, sizeof(pvt->sa.sin_addr));
   pvt->sa.sin_port = htons(port);

   return 0;
}

static void set_destination	(	struct sip_pvt *	p,
		char *	uri
	)			[static]

Set destination from SIP URI.

Definition at line 5494 of file chan_sip.c.

References ahp, ast_gethostbyname(), ast_inet_ntoa(), ast_log(), ast_verbose(), debug, hostname, hp, LOG_WARNING, sip_pvt::sa, sip_debug_test_pvt(), and STANDARD_SIP_PORT.

Referenced by reqprep().

{
   char *h, *maddr, hostname[256];
   int port, hn;
   struct hostent *hp;
   struct ast_hostent ahp;
   int debug=sip_debug_test_pvt(p);

   /* Parse uri to h (host) and port - uri is already just the part inside the <> */
   /* general form we are expecting is sip[s]:username[:password]@host[:port][;...] */

   if (debug)
      ast_verbose("set_destination: Parsing <%s> for address/port to send to\n", uri);

   /* Find and parse hostname */
   h = strchr(uri, '@');
   if (h)
      ++h;
   else {
      h = uri;
      if (strncmp(h, "sip:", 4) == 0)
         h += 4;
      else if (strncmp(h, "sips:", 5) == 0)
         h += 5;
   }
   hn = strcspn(h, ":;>") + 1;
   if (hn > sizeof(hostname)) 
      hn = sizeof(hostname);
   ast_copy_string(hostname, h, hn);
   /* XXX bug here if string has been trimmed to sizeof(hostname) */
   h += hn - 1;

   /* Is "port" present? if not default to STANDARD_SIP_PORT */
   if (*h == ':') {
      /* Parse port */
      ++h;
      port = strtol(h, &h, 10);
   }
   else
      port = STANDARD_SIP_PORT;

   /* Got the hostname:port - but maybe there's a "maddr=" to override address? */
   maddr = strstr(h, "maddr=");
   if (maddr) {
      maddr += 6;
      hn = strspn(maddr, "0123456789.") + 1;
      if (hn > sizeof(hostname))
         hn = sizeof(hostname);
      ast_copy_string(hostname, maddr, hn);
   }
   
   hp = ast_gethostbyname(hostname, &ahp);
   if (hp == NULL)  {
      ast_log(LOG_WARNING, "Can't find address for host '%s'\n", hostname);
      return;
   }
   p->sa.sin_family = AF_INET;
   memcpy(&p->sa.sin_addr, hp->h_addr, sizeof(p->sa.sin_addr));
   p->sa.sin_port = htons(port);
   if (debug)
      ast_verbose("set_destination: set destination to %s, port %d\n", ast_inet_ntoa(p->sa.sin_addr), port);
}

static void set_peer_defaults

(

struct sip_peer *

peer

)

[static]

Set peer defaults before configuring specific configurations.

Definition at line 15882 of file chan_sip.c.

References sip_peer::addr, sip_peer::allowtransfer, ast_copy_flags, sip_peer::autoframing, sip_peer::callgroup, sip_peer::capability, sip_peer::cid_name, sip_peer::cid_num, sip_peer::context, sip_peer::defaddr, default_prefs, sip_peer::expire, sip_peer::flags, sip_peer::fromdomain, sip_peer::fromuser, global_flags, sip_peer::language, sip_peer::mailbox, sip_peer::maxcallbitrate, sip_peer::maxms, sip_peer::md5secret, sip_peer::mohinterpret, sip_peer::mohsuggest, sip_peer::pickupgroup, sip_peer::pokeexpire, sip_peer::prefs, sip_peer::regexten, sip_peer::rtpholdtimeout, sip_peer::rtpkeepalive, sip_peer::rtptimeout, sip_peer::secret, SIP_FLAGS_TO_COPY, SIP_PAGE2_FLAGS_TO_COPY, STANDARD_SIP_PORT, sip_peer::subscribecontext, and sip_peer::vmexten.

Referenced by build_peer(), and temp_peer().

{
   if (peer->expire == 0) {
      /* Don't reset expire or port time during reload 
         if we have an active registration 
      */
      peer->expire = -1;
      peer->pokeexpire = -1;
      peer->addr.sin_port = htons(STANDARD_SIP_PORT);
   }
   ast_copy_flags(&peer->flags[0], &global_flags[0], SIP_FLAGS_TO_COPY);
   ast_copy_flags(&peer->flags[1], &global_flags[1], SIP_PAGE2_FLAGS_TO_COPY);
   strcpy(peer->context, default_context);
   strcpy(peer->subscribecontext, default_subscribecontext);
   strcpy(peer->language, default_language);
   strcpy(peer->mohinterpret, default_mohinterpret);
   strcpy(peer->mohsuggest, default_mohsuggest);
   peer->addr.sin_family = AF_INET;
   peer->defaddr.sin_family = AF_INET;
   peer->capability = global_capability;
   peer->maxcallbitrate = default_maxcallbitrate;
   peer->rtptimeout = global_rtptimeout;
   peer->rtpholdtimeout = global_rtpholdtimeout;
   peer->rtpkeepalive = global_rtpkeepalive;
   peer->allowtransfer = global_allowtransfer;
   peer->autoframing = global_autoframing;
   strcpy(peer->vmexten, default_vmexten);
   peer->secret[0] = '\0';
   peer->md5secret[0] = '\0';
   peer->cid_num[0] = '\0';
   peer->cid_name[0] = '\0';
   peer->fromdomain[0] = '\0';
   peer->fromuser[0] = '\0';
   peer->regexten[0] = '\0';
   peer->mailbox[0] = '\0';
   peer->callgroup = 0;
   peer->pickupgroup = 0;
   peer->maxms = default_qualify;
   peer->prefs = default_prefs;
}

static int sip_addheader	(	struct ast_channel *	chan,
		void *	data
	)			[static]

Add a SIP header to an outbound INVITE.

Definition at line 17075 of file chan_sip.c.

References ast_channel_lock, ast_channel_unlock, ast_log(), ast_strlen_zero(), FALSE, inbuf(), LOG_DEBUG, LOG_WARNING, pbx_builtin_getvar_helper(), pbx_builtin_setvar_helper(), sipdebug, and TRUE.

Referenced by load_module().

{
   int no = 0;
   int ok = FALSE;
   char varbuf[30];
   char *inbuf = (char *) data;
   
   if (ast_strlen_zero(inbuf)) {
      ast_log(LOG_WARNING, "This application requires the argument: Header\n");
      return 0;
   }
   ast_channel_lock(chan);

   /* Check for headers */
   while (!ok && no <= 50) {
      no++;
      snprintf(varbuf, sizeof(varbuf), "_SIPADDHEADER%.2d", no);

      /* Compare without the leading underscore */
      if( (pbx_builtin_getvar_helper(chan, (const char *) varbuf + 1) == (const char *) NULL) )
         ok = TRUE;
   }
   if (ok) {
      pbx_builtin_setvar_helper (chan, varbuf, inbuf);
      if (sipdebug)
         ast_log(LOG_DEBUG,"SIP Header added \"%s\" as %s\n", inbuf, varbuf);
   } else {
      ast_log(LOG_WARNING, "Too many SIP headers added, max 50\n");
   }
   ast_channel_unlock(chan);
   return 0;
}

static int sip_addrcmp	(	char *	name,
		struct sockaddr_in *	sin
	)			[static]

Support routine for find_peer.

Definition at line 2470 of file chan_sip.c.

References sip_peer::addr, ast_test_flag, sip_peer::flags, inaddrcmp(), and SIP_INSECURE_PORT.

Referenced by find_peer().

{
   /* We know name is the first field, so we can cast */
   struct sip_peer *p = (struct sip_peer *) name;
   return   !(!inaddrcmp(&p->addr, sin) || 
               (ast_test_flag(&p->flags[0], SIP_INSECURE_PORT) &&
               (p->addr.sin_addr.s_addr == sin->sin_addr.s_addr)));
}

static struct sip_pvt * sip_alloc	(	ast_string_field	callid,
		struct sockaddr_in *	sin,
		int	useglobal_nat,
		const int	intended_method
	)			[static]

Allocate SIP_PVT structure and set defaults.

Definition at line 4202 of file chan_sip.c.

References __ourip, ast_calloc, ast_copy_flags, ast_log(), ast_mutex_destroy(), ast_mutex_init(), ast_mutex_lock(), ast_mutex_unlock(), ast_random(), AST_RTP_DTMF, ast_rtp_new_with_bindaddr(), ast_rtp_set_rtpholdtimeout(), ast_rtp_set_rtpkeepalive(), ast_rtp_set_rtptimeout(), ast_rtp_setdtmf(), ast_rtp_setdtmfcompensate(), ast_rtp_settos(), ast_set2_flag, ast_sip_ouraddrfor(), ast_string_field_init, ast_string_field_set, ast_test_flag, ast_udptl_get_error_correction_scheme(), ast_udptl_new_with_bindaddr(), ast_udptl_settos(), ast_variables_destroy(), bindaddr, build_callid_pvt(), build_via(), context, default_prefs, do_setnat(), free, global_flags, global_t38_capability, iflist, INITIAL_CSEQ, io, LOG_DEBUG, LOG_WARNING, make_our_tag(), mohinterpret, mohsuggest, NONE, option_debug, sched, SIP_DTMF, SIP_DTMF_AUTO, SIP_DTMF_RFC2833, SIP_FLAGS_TO_COPY, sip_methods, SIP_NAT, SIP_NAT_ROUTE, SIP_NO_HISTORY, SIP_OPTIONS, SIP_PAGE2_FLAGS_TO_COPY, SIP_PAGE2_RFC2833_COMPENSATE, SIP_PAGE2_T38SUPPORT, SIP_PAGE2_VIDEOSUPPORT, SIP_REGISTER, T38FAX_RATE_MANAGEMENT_TRANSFERED_TCF, T38FAX_UDP_EC_FEC, T38FAX_UDP_EC_NONE, T38FAX_UDP_EC_REDUNDANCY, text, UDPTL_ERROR_CORRECTION_FEC, UDPTL_ERROR_CORRECTION_NONE, and UDPTL_ERROR_CORRECTION_REDUNDANCY.

Referenced by sip_notify(), sip_poke_peer(), sip_request_call(), sip_send_mwi_to_peer(), and transmit_register().

{
   struct sip_pvt *p;

   if (!(p = ast_calloc(1, sizeof(*p))))
      return NULL;

   if (ast_string_field_init(p, 512)) {
      free(p);
      return NULL;
   }

   ast_mutex_init(&p->lock);

   p->method = intended_method;
   p->initid = -1;
   p->autokillid = -1;
   p->subscribed = NONE;
   p->stateid = -1;
   p->prefs = default_prefs;     /* Set default codecs for this call */

   if (intended_method != SIP_OPTIONS) /* Peerpoke has it's own system */
      p->timer_t1 = 500;   /* Default SIP retransmission timer T1 (RFC 3261) */

   if (sin) {
      p->sa = *sin;
      if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
         p->ourip = __ourip;
   } else
      p->ourip = __ourip;

   /* Copy global flags to this PVT at setup. */
   ast_copy_flags(&p->flags[0], &global_flags[0], SIP_FLAGS_TO_COPY);
   ast_copy_flags(&p->flags[1], &global_flags[1], SIP_PAGE2_FLAGS_TO_COPY);

   ast_set2_flag(&p->flags[0], !recordhistory, SIP_NO_HISTORY);

   p->branch = ast_random();  
   make_our_tag(p->tag, sizeof(p->tag));
   p->ocseq = INITIAL_CSEQ;

   if (sip_methods[intended_method].need_rtp) {
      p->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
      /* If the global videosupport flag is on, we always create a RTP interface for video */
      if (ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT))
         p->vrtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
      if (ast_test_flag(&p->flags[1], SIP_PAGE2_T38SUPPORT))
         p->udptl = ast_udptl_new_with_bindaddr(sched, io, 0, bindaddr.sin_addr);
      if (!p->rtp || (ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT) && !p->vrtp)) {
         ast_log(LOG_WARNING, "Unable to create RTP audio %s session: %s\n",
            ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT) ? "and video" : "", strerror(errno));
         ast_mutex_destroy(&p->lock);
         if (p->chanvars) {
            ast_variables_destroy(p->chanvars);
            p->chanvars = NULL;
         }
         free(p);
         return NULL;
      }
      ast_rtp_setdtmf(p->rtp, ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833);
      ast_rtp_setdtmfcompensate(p->rtp, ast_test_flag(&p->flags[1], SIP_PAGE2_RFC2833_COMPENSATE));
      ast_rtp_settos(p->rtp, global_tos_audio);
      ast_rtp_set_rtptimeout(p->rtp, global_rtptimeout);
      ast_rtp_set_rtpholdtimeout(p->rtp, global_rtpholdtimeout);
      ast_rtp_set_rtpkeepalive(p->rtp, global_rtpkeepalive);
      if (p->vrtp) {
         ast_rtp_settos(p->vrtp, global_tos_video);
         ast_rtp_setdtmf(p->vrtp, 0);
         ast_rtp_setdtmfcompensate(p->vrtp, 0);
         ast_rtp_set_rtptimeout(p->vrtp, global_rtptimeout);
         ast_rtp_set_rtpholdtimeout(p->vrtp, global_rtpholdtimeout);
         ast_rtp_set_rtpkeepalive(p->vrtp, global_rtpkeepalive);
      }
      if (p->udptl)
         ast_udptl_settos(p->udptl, global_tos_audio);
      p->maxcallbitrate = default_maxcallbitrate;
   }

   if (useglobal_nat && sin) {
      /* Setup NAT structure according to global settings if we have an address */
      ast_copy_flags(&p->flags[0], &global_flags[0], SIP_NAT);
      p->recv = *sin;
      do_setnat(p, ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE);
   }

   if (p->method != SIP_REGISTER)
      ast_string_field_set(p, fromdomain, default_fromdomain);
   build_via(p);
   if (!callid)
      build_callid_pvt(p);
   else
      ast_string_field_set(p, callid, callid);
   /* Assign default music on hold class */
   ast_string_field_set(p, mohinterpret, default_mohinterpret);
   ast_string_field_set(p, mohsuggest, default_mohsuggest);
   p->capability = global_capability;
   p->allowtransfer = global_allowtransfer;
   if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
       (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO))
      p->noncodeccapability |= AST_RTP_DTMF;
   if (p->udptl) {
      p->t38.capability = global_t38_capability;
      if (ast_udptl_get_error_correction_scheme(p->udptl) == UDPTL_ERROR_CORRECTION_REDUNDANCY)
         p->t38.capability |= T38FAX_UDP_EC_REDUNDANCY;
      else if (ast_udptl_get_error_correction_scheme(p->udptl) == UDPTL_ERROR_CORRECTION_FEC)
         p->t38.capability |= T38FAX_UDP_EC_FEC;
      else if (ast_udptl_get_error_correction_scheme(p->udptl) == UDPTL_ERROR_CORRECTION_NONE)
         p->t38.capability |= T38FAX_UDP_EC_NONE;
      p->t38.capability |= T38FAX_RATE_MANAGEMENT_TRANSFERED_TCF;
      p->t38.jointcapability = p->t38.capability;
   }
   ast_string_field_set(p, context, default_context);

   /* Add to active dialog list */
   ast_mutex_lock(&iflock);
   p->next = iflist;
   iflist = p;
   ast_mutex_unlock(&iflock);
   if (option_debug)
      ast_log(LOG_DEBUG, "Allocating new SIP dialog for %s - %s (%s)\n", callid ? callid : "(No Call-ID)", sip_methods[intended_method].text, p->rtp ? "With RTP" : "No RTP");
   return p;
}

static void sip_alreadygone

(

struct sip_pvt *

dialog

)

[static]

Definition at line 1631 of file chan_sip.c.

References ast_log(), ast_set_flag, sip_pvt::flags, LOG_DEBUG, option_debug, and SIP_ALREADYGONE.

Referenced by handle_request_bye(), handle_request_cancel(), handle_request_invite(), handle_request_refer(), handle_response(), handle_response_invite(), retrans_pkt(), and sip_indicate().

{
   if (option_debug > 2)
      ast_log(LOG_DEBUG, "Setting SIP_ALREADYGONE on dialog %s\n", dialog->callid);
   ast_set_flag(&dialog->flags[0], SIP_ALREADYGONE);
}

static int sip_answer

(

struct ast_channel *

ast

)

[static]

sip_answer: Answer SIP call , send 200 OK on Invite Part of PBX interface

Definition at line 3453 of file chan_sip.c.

References ast_channel::_state, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_setstate(), AST_STATE_UP, sip_pvt::lock, LOG_DEBUG, option_debug, T38_ENABLED, T38_PEER_DIRECT, ast_channel::tech_pvt, transmit_response_with_sdp(), transmit_response_with_t38_sdp(), try_suggested_sip_codec(), and XMIT_CRITICAL.

{
   int res = 0;
   struct sip_pvt *p = ast->tech_pvt;

   ast_mutex_lock(&p->lock);
   if (ast->_state != AST_STATE_UP) {
      try_suggested_sip_codec(p);   

      ast_setstate(ast, AST_STATE_UP);
      if (option_debug)
         ast_log(LOG_DEBUG, "SIP answering channel: %s\n", ast->name);
      if (p->t38.state == T38_PEER_DIRECT) {
         p->t38.state = T38_ENABLED;
         if (option_debug > 1)
            ast_log(LOG_DEBUG,"T38State change to %d on channel %s\n", p->t38.state, ast->name);
         res = transmit_response_with_t38_sdp(p, "200 OK", &p->initreq, XMIT_CRITICAL);
      } else 
         res = transmit_response_with_sdp(p, "200 OK", &p->initreq, XMIT_CRITICAL);
   }
   ast_mutex_unlock(&p->lock);
   return res;
}

static int sip_call	(	struct ast_channel *	ast,
		char *	dest,
		int	timeout
	)			[static]

Initiate SIP call from PBX used from the dial() application.

Definition at line 2771 of file chan_sip.c.

References ast_channel::_state, sip_invite_param::addsipheaders, AST_FORMAT_AUDIO_MASK, AST_LIST_TRAVERSE, ast_log(), ast_sched_add(), ast_set_flag, AST_STATE_DOWN, AST_STATE_RESERVED, ast_string_field_set, ast_translate_available_formats(), ast_var_name(), ast_var_value(), auto_congest(), sip_pvt::callingpres, t38properties::capability, sip_pvt::capability, ast_channel::cid, cid_name, ast_callerid::cid_pres, sip_invite_param::distinctive_ring, sip_pvt::flags, INC_CALL_RINGING, sip_pvt::initid, INV_CALLING, sip_pvt::invitestate, t38properties::jointcapability, sip_pvt::jointcapability, sip_pvt::jointnoncodeccapability, LOG_DEBUG, LOG_WARNING, sip_pvt::maxtime, sip_pvt::noncodeccapability, option_debug, sip_pvt::options, sip_pvt::prefcodec, sip_invite_param::replaces, sched, SIP_INVITE, SIP_OUTGOING, SIP_TRANS_TIMEOUT, sipdebug, t38properties::state, sip_pvt::t38, T38_LOCAL_DIRECT, ast_channel::tech_pvt, sip_invite_param::transfer, transmit_invite(), update_call_counter(), sip_invite_param::uri_options, ast_channel::varshead, and sip_invite_param::vxml_url.

{
   int res;
   struct sip_pvt *p;
   struct varshead *headp;
   struct ast_var_t *current;
   const char *referer = NULL;   /* SIP refererer */  

   p = ast->tech_pvt;
   if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
      ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
      return -1;
   }

   /* Check whether there is vxml_url, distinctive ring variables */
   headp=&ast->varshead;
   AST_LIST_TRAVERSE(headp,current,entries) {
      /* Check whether there is a VXML_URL variable */
      if (!p->options->vxml_url && !strcasecmp(ast_var_name(current), "VXML_URL")) {
         p->options->vxml_url = ast_var_value(current);
      } else if (!p->options->uri_options && !strcasecmp(ast_var_name(current), "SIP_URI_OPTIONS")) {
         p->options->uri_options = ast_var_value(current);
      } else if (!p->options->distinctive_ring && !strcasecmp(ast_var_name(current), "ALERT_INFO")) {
         /* Check whether there is a ALERT_INFO variable */
         p->options->distinctive_ring = ast_var_value(current);
      } else if (!p->options->addsipheaders && !strncasecmp(ast_var_name(current), "SIPADDHEADER", strlen("SIPADDHEADER"))) {
         /* Check whether there is a variable with a name starting with SIPADDHEADER */
         p->options->addsipheaders = 1;
      } else if (!strcasecmp(ast_var_name(current), "SIPTRANSFER")) {
         /* This is a transfered call */
         p->options->transfer = 1;
      } else if (!strcasecmp(ast_var_name(current), "SIPTRANSFER_REFERER")) {
         /* This is the referer */
         referer = ast_var_value(current);
      } else if (!strcasecmp(ast_var_name(current), "SIPTRANSFER_REPLACES")) {
         /* We're replacing a call. */
         p->options->replaces = ast_var_value(current);
      } else if (!strcasecmp(ast_var_name(current), "T38CALL")) {
         p->t38.state = T38_LOCAL_DIRECT;
         if (option_debug)
            ast_log(LOG_DEBUG,"T38State change to %d on channel %s\n", p->t38.state, ast->name);
      }

   }
   
   res = 0;
   ast_set_flag(&p->flags[0], SIP_OUTGOING);

   if (p->options->transfer) {
      char buf[BUFSIZ/2];

      if (referer) {
         if (sipdebug && option_debug > 2)
            ast_log(LOG_DEBUG, "Call for %s transfered by %s\n", p->username, referer);
         snprintf(buf, sizeof(buf)-1, "-> %s (via %s)", p->cid_name, referer);
      } else 
         snprintf(buf, sizeof(buf)-1, "-> %s", p->cid_name);
      ast_string_field_set(p, cid_name, buf);
   } 
   if (option_debug)
      ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);

   res = update_call_counter(p, INC_CALL_RINGING);
   if ( res != -1 ) {
      p->callingpres = ast->cid.cid_pres;
      p->jointcapability = ast_translate_available_formats(p->capability, p->prefcodec);
      p->jointnoncodeccapability = p->noncodeccapability;

      /* If there are no audio formats left to offer, punt */
      if (!(p->jointcapability & AST_FORMAT_AUDIO_MASK)) {
         ast_log(LOG_WARNING, "No audio format found to offer. Cancelling call to %s\n", p->username);
         res = -1;
      } else {
         p->t38.jointcapability = p->t38.capability;
         if (option_debug > 1)
            ast_log(LOG_DEBUG,"Our T38 capability (%d), joint T38 capability (%d)\n", p->t38.capability, p->t38.jointcapability);
         transmit_invite(p, SIP_INVITE, 1, 2);
         p->invitestate = INV_CALLING;

         /* Initialize auto-congest time */
         p->initid = ast_sched_add(sched, p->maxtime ? (p->maxtime * 4) : SIP_TRANS_TIMEOUT, auto_congest, p);
      }
   }
   return res;
}

static void sip_cancel_destroy

(

struct sip_pvt *

p

)

[static]

Cancel destruction of SIP dialog.

Definition at line 2045 of file chan_sip.c.

References append_history, ast_sched_del(), sip_pvt::autokillid, and sched.

Referenced by cb_extensionstate(), check_user_full(), handle_request_invite(), handle_request_subscribe(), handle_response(), handle_response_invite(), register_verify(), and sip_hangup().

{
   if (p->autokillid > -1) {
      ast_sched_del(sched, p->autokillid);
      append_history(p, "CancelDestroy", "");
      p->autokillid = -1;
   }
}

static int sip_debug_test_addr

(

const struct sockaddr_in *

addr

)

[inline, static]

See if we pass debug IP filter.

Definition at line 1713 of file chan_sip.c.

References sipdebug.

Referenced by check_user_full(), sip_debug_test_pvt(), and sipsock_read().

{
   if (!sipdebug)
      return 0;
   if (debugaddr.sin_addr.s_addr) {
      if (((ntohs(debugaddr.sin_port) != 0)
         && (debugaddr.sin_port != addr->sin_port))
         || (debugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
         return 0;
   }
   return 1;
}

static int sip_debug_test_pvt

(

struct sip_pvt *

p

)

[inline, static]

Test PVT for debugging output.

Definition at line 1739 of file chan_sip.c.

References sip_debug_test_addr(), sip_real_dst(), and sipdebug.

Referenced by __sip_destroy(), add_sdp(), add_t38_sdp(), build_route(), check_via(), do_register_auth(), get_also_info(), get_destination(), get_rdnis(), get_refer_info(), handle_request(), process_sdp(), receive_message(), retrans_pkt(), send_request(), send_response(), set_destination(), sip_scheddestroy(), sip_sendtext(), and transmit_register().

{
   if (!sipdebug)
      return 0;
   return sip_debug_test_addr(sip_real_dst(p));
}

static void sip_destroy

(

struct sip_pvt *

p

)

[static]

Destroy SIP call structure.

Definition at line 3106 of file chan_sip.c.

References __sip_destroy(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), LOG_DEBUG, and option_debug.

Referenced by __sip_autodestruct(), handle_request_subscribe(), sip_destroy_peer(), sip_do_reload(), sip_notify(), sip_poke_noanswer(), sip_poke_peer(), sip_registry_destroy(), sip_request_call(), sip_send_mwi_to_peer(), and transmit_register().

{
   ast_mutex_lock(&iflock);
   if (option_debug > 2)
      ast_log(LOG_DEBUG, "Destroying SIP dialog %s\n", p->callid);
   __sip_destroy(p, 1);
   ast_mutex_unlock(&iflock);
}

static void sip_destroy_peer

(

struct sip_peer *

peer

)

[static]

Destroy peer object from memory.

Definition at line 2357 of file chan_sip.c.

References ast_free_ha(), ast_log(), ast_sched_del(), ast_test_flag, ast_variables_destroy(), sip_peer::auth, sip_peer::call, sip_peer::chanvars, clear_realm_authentication(), sip_peer::expire, FALSE, sip_peer::flags, free, sip_peer::ha, LOG_DEBUG, sip_peer::mwipvt, option_debug, sip_peer::pokeexpire, register_peer_exten(), sched, sip_destroy(), SIP_PAGE2_SELFDESTRUCT, and SIP_REALTIME.

Referenced by __sip_autodestruct(), _sip_show_peer(), build_peer(), check_user_full(), create_addr(), expire_register(), function_sippeer(), handle_request_subscribe(), register_verify(), sip_devicestate(), sip_do_debug_peer(), sip_prune_realtime(), unload_module(), and update_call_counter().

{
   if (option_debug > 2)
      ast_log(LOG_DEBUG, "Destroying SIP peer %s\n", peer->name);

   /* Delete it, it needs to disappear */
   if (peer->call)
      sip_destroy(peer->call);

   if (peer->mwipvt)    /* We have an active subscription, delete it */
      sip_destroy(peer->mwipvt);

   if (peer->chanvars) {
      ast_variables_destroy(peer->chanvars);
      peer->chanvars = NULL;
   }
   if (peer->expire > -1)
      ast_sched_del(sched, peer->expire);

   if (peer->pokeexpire > -1)
      ast_sched_del(sched, peer->pokeexpire);
   register_peer_exten(peer, FALSE);
   ast_free_ha(peer->ha);
   if (ast_test_flag(&peer->flags[1], SIP_PAGE2_SELFDESTRUCT))
      apeerobjs--;
   else if (ast_test_flag(&peer->flags[0], SIP_REALTIME))
      rpeerobjs--;
   else
      speerobjs--;
   clear_realm_authentication(peer->auth);
   peer->auth = NULL;
   free(peer);
}

static void sip_destroy_user

(

struct sip_user *

user

)

[static]

Remove user object from in-memory storage.

Definition at line 2498 of file chan_sip.c.

References ast_free_ha(), ast_log(), ast_test_flag, ast_variables_destroy(), sip_user::chanvars, sip_user::flags, free, sip_user::ha, LOG_DEBUG, option_debug, and SIP_REALTIME.

Referenced by check_user_full(), sip_show_user(), unload_module(), and update_call_counter().

{
   if (option_debug > 2)
      ast_log(LOG_DEBUG, "Destroying user object from memory: %s\n", user->name);
   ast_free_ha(user->ha);
   if (user->chanvars) {
      ast_variables_destroy(user->chanvars);
      user->chanvars = NULL;
   }
   if (ast_test_flag(&user->flags[0], SIP_REALTIME))
      ruserobjs--;
   else
      suserobjs--;
   free(user);
}

static int sip_devicestate

(

void *

data

)

[static]

Part of PBX channel interface.

Note:

Return values:---

If we have qualify on and the device is not reachable, regardless of registration state we return AST_DEVICE_UNAVAILABLE

For peers with call limit:

• not registered AST_DEVICE_UNAVAILABLE
• registered, no call AST_DEVICE_NOT_INUSE
• registered, active calls AST_DEVICE_INUSE
• registered, call limit reached AST_DEVICE_BUSY
• registered, onhold AST_DEVICE_ONHOLD
• registered, ringing AST_DEVICE_RINGING

For peers without call limit:

• not registered AST_DEVICE_UNAVAILABLE
• registered AST_DEVICE_NOT_INUSE
• fixed IP (!dynamic) AST_DEVICE_NOT_INUSE

Peers that does not have a known call and can't be reached by OPTIONS

• unreachable AST_DEVICE_UNAVAILABLE

If we return AST_DEVICE_UNKNOWN, the device state engine will try to find out a state by walking the channel list.

The queue system (app_queue.c) treats a member as "active" if devicestate is != AST_DEVICE_UNAVAILBALE && != AST_DEVICE_INVALID

When placing a call to the queue member, queue system sets a member to busy if != AST_DEVICE_NOT_INUSE and != AST_DEVICE_UNKNOWN

Definition at line 15320 of file chan_sip.c.

References sip_peer::addr, ahp, AST_DEVICE_BUSY, AST_DEVICE_INUSE, AST_DEVICE_INVALID, AST_DEVICE_NOT_INUSE, AST_DEVICE_ONHOLD, AST_DEVICE_RINGING, AST_DEVICE_RINGINUSE, AST_DEVICE_UNAVAILABLE, AST_DEVICE_UNKNOWN, ast_gethostbyname(), ast_log(), ast_strdupa, ASTOBJ_UNREF, sip_peer::call_limit, sip_peer::defaddr, find_peer(), hp, sip_peer::inRinging, sip_peer::inUse, sip_peer::lastms, LOG_DEBUG, sip_peer::maxms, sip_peer::onHold, option_debug, and sip_destroy_peer().

{
   char *host;
   char *tmp;

   struct hostent *hp;
   struct ast_hostent ahp;
   struct sip_peer *p;

   int res = AST_DEVICE_INVALID;

   /* make sure data is not null. Maybe unnecessary, but better be safe */
   host = ast_strdupa(data ? data : "");
   if ((tmp = strchr(host, '@')))
      host = tmp + 1;

   if (option_debug > 2) 
      ast_log(LOG_DEBUG, "Checking device state for peer %s\n", host);

   if ((p = find_peer(host, NULL, 1))) {
      if (p->addr.sin_addr.s_addr || p->defaddr.sin_addr.s_addr) {
         /* we have an address for the peer */
      
         /* Check status in this order
            - Hold
            - Ringing
            - Busy (enforced only by call limit)
            - Inuse (we have a call)
            - Unreachable (qualify)
            If we don't find any of these state, report AST_DEVICE_NOT_INUSE
            for registered devices */

         if (p->onHold)
            /* First check for hold or ring states */
            res = AST_DEVICE_ONHOLD;
         else if (p->inRinging) {
            if (p->inRinging == p->inUse)
               res = AST_DEVICE_RINGING;
            else
               res = AST_DEVICE_RINGINUSE;
         } else if (p->call_limit && (p->inUse == p->call_limit))
            /* check call limit */
            res = AST_DEVICE_BUSY;
         else if (p->call_limit && p->inUse)
            /* Not busy, but we do have a call */
            res = AST_DEVICE_INUSE;
         else if (p->maxms && (p->lastms > p->maxms)) 
            /* We don't have a call. Are we reachable at all? Requires qualify= */
            res = AST_DEVICE_UNAVAILABLE;
         else  /* Default reply if we're registered and have no other data */
            res = AST_DEVICE_NOT_INUSE;
      } else {
         /* there is no address, it's unavailable */
         res = AST_DEVICE_UNAVAILABLE;
      }
      ASTOBJ_UNREF(p,sip_destroy_peer);
   } else {
      hp = ast_gethostbyname(host, &ahp);
      if (hp)
         res = AST_DEVICE_UNKNOWN;
   }

   return res;
}

static int sip_do_debug	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Turn on SIP debugging (CLI command).

Definition at line 10926 of file chan_sip.c.

References ast_cli(), ast_set_flag, debugaddr, global_flags, RESULT_SHOWUSAGE, RESULT_SUCCESS, sip_do_debug_ip(), sip_do_debug_peer(), SIP_PAGE2_DEBUG_CONSOLE, and sipdebug_console.

{
   int oldsipdebug = sipdebug_console;
   if (argc != 3) {
      if (argc != 5) 
         return RESULT_SHOWUSAGE;
      else if (strcmp(argv[3], "ip") == 0)
         return sip_do_debug_ip(fd, argc, argv);
      else if (strcmp(argv[3], "peer") == 0)
         return sip_do_debug_peer(fd, argc, argv);
      else
         return RESULT_SHOWUSAGE;
   }
   ast_set_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
   memset(&debugaddr, 0, sizeof(debugaddr));
   ast_cli(fd, "SIP Debugging %senabled\n", oldsipdebug ? "re-" : "");
   return RESULT_SUCCESS;
}

static int sip_do_debug_deprecated	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Definition at line 10945 of file chan_sip.c.

References ast_cli(), ast_set_flag, debugaddr, global_flags, RESULT_SHOWUSAGE, RESULT_SUCCESS, sip_do_debug_ip(), sip_do_debug_peer(), SIP_PAGE2_DEBUG_CONSOLE, and sipdebug_console.

{
   int oldsipdebug = sipdebug_console;
   char *newargv[6] = { "sip", "set", "debug", NULL };
   if (argc != 2) {
      if (argc != 4) 
         return RESULT_SHOWUSAGE;
      else if (strcmp(argv[2], "ip") == 0) {
         newargv[3] = argv[2];
         newargv[4] = argv[3];
         return sip_do_debug_ip(fd, argc + 1, newargv);
      } else if (strcmp(argv[2], "peer") == 0) {
         newargv[3] = argv[2];
         newargv[4] = argv[3];
         return sip_do_debug_peer(fd, argc + 1, newargv);
      } else
         return RESULT_SHOWUSAGE;
   }
   ast_set_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
   memset(&debugaddr, 0, sizeof(debugaddr));
   ast_cli(fd, "SIP Debugging %senabled\n", oldsipdebug ? "re-" : "");
   return RESULT_SUCCESS;
}

static int sip_do_debug_ip	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Enable SIP Debugging in CLI.

Definition at line 10872 of file chan_sip.c.

References ahp, ast_cli(), ast_gethostbyname(), ast_inet_ntoa(), ast_set_flag, debugaddr, global_flags, hp, RESULT_SHOWUSAGE, RESULT_SUCCESS, SIP_PAGE2_DEBUG_CONSOLE, and strsep().

Referenced by sip_do_debug(), and sip_do_debug_deprecated().

{
   struct hostent *hp;
   struct ast_hostent ahp;
   int port = 0;
   char *p, *arg;

   /* sip set debug ip <ip> */
   if (argc != 5)
      return RESULT_SHOWUSAGE;
   p = arg = argv[4];
   strsep(&p, ":");
   if (p)
      port = atoi(p);
   hp = ast_gethostbyname(arg, &ahp);
   if (hp == NULL)
      return RESULT_SHOWUSAGE;

   debugaddr.sin_family = AF_INET;
   memcpy(&debugaddr.sin_addr, hp->h_addr, sizeof(debugaddr.sin_addr));
   debugaddr.sin_port = htons(port);
   if (port == 0)
      ast_cli(fd, "SIP Debugging Enabled for IP: %s\n", ast_inet_ntoa(debugaddr.sin_addr));
   else
      ast_cli(fd, "SIP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(debugaddr.sin_addr), port);

   ast_set_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);

   return RESULT_SUCCESS;
}

static int sip_do_debug_peer	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

sip_do_debug_peer: Turn on SIP debugging with peer mask

Definition at line 10904 of file chan_sip.c.

References sip_peer::addr, ast_cli(), ast_inet_ntoa(), ast_set_flag, ASTOBJ_UNREF, debugaddr, find_peer(), global_flags, RESULT_SHOWUSAGE, RESULT_SUCCESS, sip_destroy_peer(), and SIP_PAGE2_DEBUG_CONSOLE.

Referenced by sip_do_debug(), and sip_do_debug_deprecated().

{
   struct sip_peer *peer;
   if (argc != 5)
      return RESULT_SHOWUSAGE;
   peer = find_peer(argv[4], NULL, 1);
   if (peer) {
      if (peer->addr.sin_addr.s_addr) {
         debugaddr.sin_family = AF_INET;
         debugaddr.sin_addr = peer->addr.sin_addr;
         debugaddr.sin_port = peer->addr.sin_port;
         ast_cli(fd, "SIP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(debugaddr.sin_addr), ntohs(debugaddr.sin_port));
         ast_set_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
      } else
         ast_cli(fd, "Unable to get IP address of peer '%s'\n", argv[4]);
      ASTOBJ_UNREF(peer,sip_destroy_peer);
   } else
      ast_cli(fd, "No such peer '%s'\n", argv[4]);
   return RESULT_SUCCESS;
}

static int sip_do_history	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Enable SIP History logging (CLI).

Definition at line 11045 of file chan_sip.c.

References ast_cli(), RESULT_SHOWUSAGE, RESULT_SUCCESS, and TRUE.

{
   if (argc != 2) {
      return RESULT_SHOWUSAGE;
   }
   recordhistory = TRUE;
   ast_cli(fd, "SIP History Recording Enabled (use 'sip show history')\n");
   return RESULT_SUCCESS;
}

static int sip_do_reload

(

enum channelreloadreason

reason

)

[static]

Reload module.

Definition at line 17216 of file chan_sip.c.

References ast_log(), ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_RDLOCK, ASTOBJ_UNLOCK, authl, clear_realm_authentication(), clear_sip_domains(), LOG_DEBUG, regl, and sip_destroy().

Referenced by do_monitor().

{
   if (option_debug > 3)
      ast_log(LOG_DEBUG, "--------------- SIP reload started\n");

   clear_realm_authentication(authl);
   clear_sip_domains();
   authl = NULL;

   /* First, destroy all outstanding registry calls */
   /* This is needed, since otherwise active registry entries will not be destroyed */
   ASTOBJ_CONTAINER_TRAVERSE(&regl, 1, do {
      ASTOBJ_RDLOCK(iterator);
      if (iterator->call) {
         if (option_debug > 2)
            ast_log(LOG_DEBUG, "Destroying active SIP dialog for registry %s@%s\n", iterator->username, iterator->hostname);
         /* This will also remove references to the registry */
         sip_destroy(iterator->call);
      }
      ASTOBJ_UNLOCK(iterator);
   
   } while(0));

   /* Then, actually destroy users and registry */
   ASTOBJ_CONTAINER_DESTROYALL(&userl, sip_destroy_user);
   if (option_debug > 3)
      ast_log(LOG_DEBUG, "--------------- Done destroying user list\n");
   ASTOBJ_CONTAINER_DESTROYALL(&regl, sip_registry_destroy);
   if (option_debug > 3)
      ast_log(LOG_DEBUG, "--------------- Done destroying registry list\n");
   ASTOBJ_CONTAINER_MARKALL(&peerl);
   reload_config(reason);

   /* Prune peers who still are supposed to be deleted */
   ASTOBJ_CONTAINER_PRUNE_MARKED(&peerl, sip_destroy_peer);
   if (option_debug > 3)
      ast_log(LOG_DEBUG, "--------------- Done destroying pruned peers\n");

   /* Send qualify (OPTIONS) to all peers */
   sip_poke_all_peers();

   /* Register with all services */
   sip_send_all_registers();

   if (option_debug > 3)
      ast_log(LOG_DEBUG, "--------------- SIP reload done\n");

   return 0;
}

static int sip_dtmfmode	(	struct ast_channel *	chan,
		void *	data
	)			[static]

Set the DTMFmode for an outbound SIP call (application).

Definition at line 17020 of file chan_sip.c.

References ast_channel_lock, ast_channel_unlock, ast_clear_flag, ast_dsp_free(), ast_dsp_new(), ast_dsp_set_features(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), AST_RTP_DTMF, ast_rtp_setdtmf(), ast_set_flag, ast_test_flag, DSP_FEATURE_DTMF_DETECT, sip_pvt::flags, sip_pvt::jointnoncodeccapability, sip_pvt::lock, LOG_WARNING, sip_pvt::rtp, SIP_DTMF, SIP_DTMF_INBAND, SIP_DTMF_INFO, SIP_DTMF_RFC2833, sip_tech, sip_tech_info, ast_channel::tech, ast_channel::tech_pvt, and sip_pvt::vad.

Referenced by load_module().

{
   struct sip_pvt *p;
   char *mode;
   if (data)
      mode = (char *)data;
   else {
      ast_log(LOG_WARNING, "This application requires the argument: info, inband, rfc2833\n");
      return 0;
   }
   ast_channel_lock(chan);
   if (chan->tech != &sip_tech && chan->tech != &sip_tech_info) {
      ast_log(LOG_WARNING, "Call this application only on SIP incoming calls\n");
      ast_channel_unlock(chan);
      return 0;
   }
   p = chan->tech_pvt;
   if (!p) {
      ast_channel_unlock(chan);
      return 0;
   }
   ast_mutex_lock(&p->lock);
   if (!strcasecmp(mode,"info")) {
      ast_clear_flag(&p->flags[0], SIP_DTMF);
      ast_set_flag(&p->flags[0], SIP_DTMF_INFO);
      p->jointnoncodeccapability &= ~AST_RTP_DTMF;
   } else if (!strcasecmp(mode,"rfc2833")) {
      ast_clear_flag(&p->flags[0], SIP_DTMF);
      ast_set_flag(&p->flags[0], SIP_DTMF_RFC2833);
      p->jointnoncodeccapability |= AST_RTP_DTMF;
   } else if (!strcasecmp(mode,"inband")) { 
      ast_clear_flag(&p->flags[0], SIP_DTMF);
      ast_set_flag(&p->flags[0], SIP_DTMF_INBAND);
      p->jointnoncodeccapability &= ~AST_RTP_DTMF;
   } else
      ast_log(LOG_WARNING, "I don't know about this dtmf mode: %s\n",mode);
   if (p->rtp)
      ast_rtp_setdtmf(p->rtp, ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833);
   if (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_INBAND) {
      if (!p->vad) {
         p->vad = ast_dsp_new();
         ast_dsp_set_features(p->vad, DSP_FEATURE_DTMF_DETECT);
      }
   } else {
      if (p->vad) {
         ast_dsp_free(p->vad);
         p->vad = NULL;
      }
   }
   ast_mutex_unlock(&p->lock);
   ast_channel_unlock(chan);
   return 0;
}

static void sip_dump_history

(

struct sip_pvt *

dialog

)

[static]

Dump SIP history to debug log file at end of lifespan for SIP dialog.

Definition at line 10742 of file chan_sip.c.

References AST_LIST_TRAVERSE, ast_log(), sip_pvt::history, LOG_DEBUG, LOG_NOTICE, option_debug, sipdebug, and sip_pvt::subscribed.

Referenced by __sip_destroy().

{
   int x = 0;
   struct sip_history *hist;
   static int errmsg = 0;

   if (!dialog)
      return;

   if (!option_debug && !sipdebug) {
      if (!errmsg) {
         ast_log(LOG_NOTICE, "You must have debugging enabled (SIP or Asterisk) in order to dump SIP history.\n");
         errmsg = 1;
      }
      return;
   }

   ast_log(LOG_DEBUG, "\n---------- SIP HISTORY for '%s' \n", dialog->callid);
   if (dialog->subscribed)
      ast_log(LOG_DEBUG, "  * Subscription\n");
   else
      ast_log(LOG_DEBUG, "  * SIP Call\n");
   if (dialog->history)
      AST_LIST_TRAVERSE(dialog->history, hist, list)
         ast_log(LOG_DEBUG, "  %-3.3d. %s\n", ++x, hist->event);
   if (!x)
      ast_log(LOG_DEBUG, "Call '%s' has no history\n", dialog->callid);
   ast_log(LOG_DEBUG, "\n---------- END SIP HISTORY for '%s' \n", dialog->callid);
}

static int sip_fixup	(	struct ast_channel *	oldchan,
		struct ast_channel *	newchan
	)			[static]

sip_fixup: Fix up a channel: If a channel is consumed, this is called. Basically update any ->owner links

Definition at line 3557 of file chan_sip.c.

References append_history, AST_FLAG_ZOMBIE, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_test_flag, sip_pvt::lock, LOG_DEBUG, LOG_WARNING, option_debug, sip_pvt::owner, and ast_channel::tech_pvt.

{
   int ret = -1;
   struct sip_pvt *p;

   if (newchan && ast_test_flag(newchan, AST_FLAG_ZOMBIE) && option_debug)
      ast_log(LOG_DEBUG, "New channel is zombie\n");
   if (oldchan && ast_test_flag(oldchan, AST_FLAG_ZOMBIE) && option_debug)
      ast_log(LOG_DEBUG, "Old channel is zombie\n");

   if (!newchan || !newchan->tech_pvt) {
      if (!newchan)
         ast_log(LOG_WARNING, "No new channel! Fixup of %s failed.\n", oldchan->name);
      else
         ast_log(LOG_WARNING, "No SIP tech_pvt! Fixup of %s failed.\n", oldchan->name);
      return -1;
   }
   p = newchan->tech_pvt;

   if (!p) {
      ast_log(LOG_WARNING, "No pvt after masquerade. Strange things may happen\n");
      return -1;
   }

   ast_mutex_lock(&p->lock);
   append_history(p, "Masq", "Old channel: %s\n", oldchan->name);
   append_history(p, "Masq (cont)", "...new owner: %s\n", newchan->name);
   if (p->owner != oldchan)
      ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
   else {
      p->owner = newchan;
      ret = 0;
   }
   if (option_debug > 2)
      ast_log(LOG_DEBUG, "SIP Fixup: New owner for dialogue %s: %s (Old parent: %s)\n", p->callid, p->owner->name, oldchan->name);

   ast_mutex_unlock(&p->lock);
   return ret;
}

static int sip_get_codec

(

struct ast_channel *

chan

)

[static]

Return SIP UA's codec (part of the RTP interface).

Definition at line 17165 of file chan_sip.c.

References sip_pvt::capability, sip_pvt::peercapability, and ast_channel::tech_pvt.

{
   struct sip_pvt *p = chan->tech_pvt;
   return p->peercapability ? p->peercapability : p->capability;  
}

static enum ast_rtp_get_result sip_get_rtp_peer	(	struct ast_channel *	chan,
		struct ast_rtp **	rtp
	)			[static]

Returns null if we can't reinvite audio (part of RTP interface).

Definition at line 16880 of file chan_sip.c.

References AST_JB_FORCED, ast_mutex_lock(), ast_mutex_unlock(), AST_RTP_GET_FAILED, ast_rtp_getnat(), AST_RTP_TRY_NATIVE, AST_RTP_TRY_PARTIAL, ast_test_flag, sip_pvt::flags, global_jbconf, sip_pvt::lock, sip_pvt::rtp, SIP_CAN_REINVITE, SIP_CAN_REINVITE_NAT, and ast_channel::tech_pvt.

{
   struct sip_pvt *p = NULL;
   enum ast_rtp_get_result res = AST_RTP_TRY_PARTIAL;

   if (!(p = chan->tech_pvt))
      return AST_RTP_GET_FAILED;

   ast_mutex_lock(&p->lock);
   if (!(p->rtp)) {
      ast_mutex_unlock(&p->lock);
      return AST_RTP_GET_FAILED;
   }

   *rtp = p->rtp;

   if (ast_rtp_getnat(*rtp) && !ast_test_flag(&p->flags[0], SIP_CAN_REINVITE_NAT))
      res = AST_RTP_TRY_PARTIAL;
   else if (ast_test_flag(&p->flags[0], SIP_CAN_REINVITE))
      res = AST_RTP_TRY_NATIVE;
   else if (ast_test_flag(&global_jbconf, AST_JB_FORCED))
      res = AST_RTP_GET_FAILED;

   ast_mutex_unlock(&p->lock);

   return res;
}

static struct ast_udptl * sip_get_udptl_peer

(

struct ast_channel *

chan

)

[static]

Definition at line 16745 of file chan_sip.c.

References ast_mutex_lock(), ast_mutex_unlock(), ast_test_flag, sip_pvt::flags, sip_pvt::lock, SIP_CAN_REINVITE, ast_channel::tech_pvt, and sip_pvt::udptl.

{
   struct sip_pvt *p;
   struct ast_udptl *udptl = NULL;
   
   p = chan->tech_pvt;
   if (!p)
      return NULL;
   
   ast_mutex_lock(&p->lock);
   if (p->udptl && ast_test_flag(&p->flags[0], SIP_CAN_REINVITE))
      udptl = p->udptl;
   ast_mutex_unlock(&p->lock);
   return udptl;
}

static enum ast_rtp_get_result sip_get_vrtp_peer	(	struct ast_channel *	chan,
		struct ast_rtp **	rtp
	)			[static]

Returns null if we can't reinvite video (part of RTP interface).

Definition at line 16909 of file chan_sip.c.

References ast_mutex_lock(), ast_mutex_unlock(), AST_RTP_GET_FAILED, AST_RTP_TRY_NATIVE, AST_RTP_TRY_PARTIAL, ast_test_flag, sip_pvt::flags, sip_pvt::lock, sip_pvt::rtp, SIP_CAN_REINVITE, ast_channel::tech_pvt, and sip_pvt::vrtp.

{
   struct sip_pvt *p = NULL;
   enum ast_rtp_get_result res = AST_RTP_TRY_PARTIAL;
   
   if (!(p = chan->tech_pvt))
      return AST_RTP_GET_FAILED;

   ast_mutex_lock(&p->lock);
   if (!(p->vrtp)) {
      ast_mutex_unlock(&p->lock);
      return AST_RTP_GET_FAILED;
   }

   *rtp = p->vrtp;

   if (ast_test_flag(&p->flags[0], SIP_CAN_REINVITE))
      res = AST_RTP_TRY_NATIVE;

   ast_mutex_unlock(&p->lock);

   return res;
}

static int sip_handle_t38_reinvite	(	struct ast_channel *	chan,
		struct sip_pvt *	pvt,
		int	reinvite
	)			[static]

Handle T38 reinvite.

Todo:

Make sure we don't destroy the call if we can't handle the re-invite. Nothing should be changed until we have processed the SDP and know that we can handle it.

Todo:

check if this is not set earlier when setting up the PVT. If not maybe it should move there.

Note:

The SIP_CAN_REINVITE flag is for RTP media redirects, not really T38 re-invites which are different. In this case it's used properly, to see if we can reinvite over NAT

Definition at line 16797 of file chan_sip.c.

References ast_inet_ntoa(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_set_flag, ast_test_flag, ast_udptl_get_error_correction_scheme(), ast_udptl_get_local_max_datagram(), ast_udptl_get_peer(), ast_udptl_set_error_correction_scheme(), ast_udptl_set_far_max_datagram(), ast_udptl_set_local_max_datagram(), sip_pvt::flags, sip_pvt::initreq, t38properties::jointcapability, sip_pvt::lastrtprx, sip_pvt::lastrtptx, sip_pvt::lock, LOG_DEBUG, sip_pvt::ourip, sip_pvt::owner, t38properties::peercapability, sip_pvt::pendinginvite, SIP_CAN_REINVITE, SIP_GOTREFER, SIP_NEEDREINVITE, SIP_PENDINGBYE, t38properties::state, sip_pvt::t38, T38_ENABLED, ast_channel::tech_pvt, transmit_reinvite_with_t38_sdp(), transmit_response_with_t38_sdp(), sip_pvt::udptl, sip_pvt::udptlredirip, and XMIT_CRITICAL.

Referenced by handle_request_invite(), and handle_response_invite().

{
   struct sip_pvt *p;
   int flag = 0;
   
   p = chan->tech_pvt;
   if (!p || !pvt->udptl)
      return -1;
   
   /* Setup everything on the other side like offered/responded from first side */
   ast_mutex_lock(&p->lock);

   /*! \todo check if this is not set earlier when setting up the PVT. If not
      maybe it should move there. */
   p->t38.jointcapability = p->t38.peercapability = pvt->t38.jointcapability;

   ast_udptl_set_far_max_datagram(p->udptl, ast_udptl_get_local_max_datagram(pvt->udptl));
   ast_udptl_set_local_max_datagram(p->udptl, ast_udptl_get_local_max_datagram(pvt->udptl));
   ast_udptl_set_error_correction_scheme(p->udptl, ast_udptl_get_error_correction_scheme(pvt->udptl));
   
   if (reinvite) {      /* If we are handling sending re-invite to the other side of the bridge */
      /*! \note The SIP_CAN_REINVITE flag is for RTP media redirects,
         not really T38 re-invites which are different. In this
         case it's used properly, to see if we can reinvite over
         NAT 
      */
      if (ast_test_flag(&p->flags[0], SIP_CAN_REINVITE) && ast_test_flag(&pvt->flags[0], SIP_CAN_REINVITE)) {
         ast_udptl_get_peer(pvt->udptl, &p->udptlredirip);
         flag =1;
      } else {
         memset(&p->udptlredirip, 0, sizeof(p->udptlredirip));
      }
      if (!ast_test_flag(&p->flags[0], SIP_GOTREFER)) {
         if (!p->pendinginvite) {
            if (option_debug > 2) {
               if (flag)
                  ast_log(LOG_DEBUG, "Sending reinvite on SIP '%s' - It's UDPTL soon redirected to IP %s:%d\n", p->callid, ast_inet_ntoa(p->udptlredirip.sin_addr), ntohs(p->udptlredirip.sin_port));
               else
                  ast_log(LOG_DEBUG, "Sending reinvite on SIP '%s' - It's UDPTL soon redirected to us (IP %s)\n", p->callid, ast_inet_ntoa(p->ourip));
            }
            transmit_reinvite_with_t38_sdp(p);
         } else if (!ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
            if (option_debug > 2) {
               if (flag)
                  ast_log(LOG_DEBUG, "Deferring reinvite on SIP '%s' - It's UDPTL will be redirected to IP %s:%d\n", p->callid, ast_inet_ntoa(p->udptlredirip.sin_addr), ntohs(p->udptlredirip.sin_port));
               else
                  ast_log(LOG_DEBUG, "Deferring reinvite on SIP '%s' - It's UDPTL will be redirected to us (IP %s)\n", p->callid, ast_inet_ntoa(p->ourip));
            }
            ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
         }
      }
      /* Reset lastrtprx timer */
      p->lastrtprx = p->lastrtptx = time(NULL);
      ast_mutex_unlock(&p->lock);
      return 0;
   } else { /* If we are handling sending 200 OK to the other side of the bridge */
      if (ast_test_flag(&p->flags[0], SIP_CAN_REINVITE) && ast_test_flag(&pvt->flags[0], SIP_CAN_REINVITE)) {
         ast_udptl_get_peer(pvt->udptl, &p->udptlredirip);
         flag = 1;
      } else {
         memset(&p->udptlredirip, 0, sizeof(p->udptlredirip));
      }
      if (option_debug > 2) {
         if (flag)
            ast_log(LOG_DEBUG, "Responding 200 OK on SIP '%s' - It's UDPTL soon redirected to IP %s:%d\n", p->callid, ast_inet_ntoa(p->udptlredirip.sin_addr), ntohs(p->udptlredirip.sin_port));
         else
            ast_log(LOG_DEBUG, "Responding 200 OK on SIP '%s' - It's UDPTL soon redirected to us (IP %s)\n", p->callid, ast_inet_ntoa(p->ourip));
      }
      pvt->t38.state = T38_ENABLED;
      p->t38.state = T38_ENABLED;
      if (option_debug > 1) {
         ast_log(LOG_DEBUG, "T38 changed state to %d on channel %s\n", pvt->t38.state, pvt->owner ? pvt->owner->name : "<none>");
         ast_log(LOG_DEBUG, "T38 changed state to %d on channel %s\n", p->t38.state, chan ? chan->name : "<none>");
      }
      transmit_response_with_t38_sdp(p, "200 OK", &p->initreq, XMIT_CRITICAL);
      p->lastrtprx = p->lastrtptx = time(NULL);
      ast_mutex_unlock(&p->lock);
      return 0;
   }
}

static int sip_hangup

(

struct ast_channel *

ast

)

[static]

sip_hangup: Hangup SIP call Part of PBX interface, called from ast_hangup

Definition at line 3278 of file chan_sip.c.

References __sip_pretend_ack(), ast_channel::_state, append_history, ast_clear_flag, ast_dsp_free(), AST_FLAG_ZOMBIE, ast_log(), ast_module_unref(), ast_mutex_lock(), ast_mutex_unlock(), ast_rtp_get_quality(), ast_set_flag, ast_state2str(), AST_STATE_RING, AST_STATE_RINGING, AST_STATE_UP, ast_strlen_zero(), ast_test_flag, sip_pvt::autokillid, DEC_CALL_LIMIT, DEFAULT_TRANS_TIMEOUT, FALSE, sip_pvt::flags, hangup_cause2sip(), ast_channel::hangupcause, INC_CALL_LIMIT, INV_CALLING, INV_COMPLETED, sip_pvt::invitestate, sip_pvt::lock, LOG_DEBUG, LOG_WARNING, option_debug, sip_pvt::owner, pbx_builtin_setvar_helper(), sip_pvt::refer, SIP_ALREADYGONE, SIP_BYE, SIP_CANCEL, sip_cancel_destroy(), SIP_DEFER_BYE_ON_TRANSFER, SIP_INC_COUNT, SIP_NEEDDESTROY, SIP_NEEDREINVITE, SIP_NO_HISTORY, SIP_OUTGOING, SIP_PENDINGBYE, sip_scheddestroy(), sipdebug, ast_channel::tech_pvt, transmit_request(), transmit_request_with_auth(), transmit_response_reliable(), TRUE, update_call_counter(), sip_pvt::vad, and XMIT_RELIABLE.

{
   struct sip_pvt *p = ast->tech_pvt;
   int needcancel = FALSE;
   int needdestroy = 0;
   struct ast_channel *oldowner = ast;

   if (!p) {
      if (option_debug)
         ast_log(LOG_DEBUG, "Asked to hangup channel that was not connected\n");
      return 0;
   }

   if (ast_test_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER)) {
      if (ast_test_flag(&p->flags[0], SIP_INC_COUNT)) {
         if (option_debug && sipdebug)
            ast_log(LOG_DEBUG, "update_call_counter(%s) - decrement call limit counter on hangup\n", p->username);
         update_call_counter(p, DEC_CALL_LIMIT);
      }
      if (option_debug >3)
         ast_log(LOG_DEBUG, "SIP Transfer: Not hanging up right now... Rescheduling hangup for %s.\n", p->callid);
      if (p->autokillid > -1)
         sip_cancel_destroy(p);
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
      ast_clear_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER); /* Really hang up next time */
      ast_clear_flag(&p->flags[0], SIP_NEEDDESTROY);
      p->owner->tech_pvt = NULL;
      p->owner = NULL;  /* Owner will be gone after we return, so take it away */
      return 0;
   }
   if (option_debug) {
      if (ast_test_flag(ast, AST_FLAG_ZOMBIE) && p->refer && option_debug)
               ast_log(LOG_DEBUG, "SIP Transfer: Hanging up Zombie channel %s after transfer ... Call-ID: %s\n", ast->name, p->callid);
      else  {
         if (option_debug)
            ast_log(LOG_DEBUG, "Hangup call %s, SIP callid %s)\n", ast->name, p->callid);
      }
   }
   if (option_debug && ast_test_flag(ast, AST_FLAG_ZOMBIE)) 
      ast_log(LOG_DEBUG, "Hanging up zombie call. Be scared.\n");

   ast_mutex_lock(&p->lock);
   if (ast_test_flag(&p->flags[0], SIP_INC_COUNT)) {
      if (option_debug && sipdebug)
         ast_log(LOG_DEBUG, "update_call_counter(%s) - decrement call limit counter on hangup\n", p->username);
      update_call_counter(p, DEC_CALL_LIMIT);
   }

   /* Determine how to disconnect */
   if (p->owner != ast) {
      ast_log(LOG_WARNING, "Huh?  We aren't the owner? Can't hangup call.\n");
      ast_mutex_unlock(&p->lock);
      return 0;
   }
   /* If the call is not UP, we need to send CANCEL instead of BYE */
   if (ast->_state == AST_STATE_RING || ast->_state == AST_STATE_RINGING || (p->invitestate < INV_COMPLETED && ast->_state != AST_STATE_UP)) {
      needcancel = TRUE;
      if (option_debug > 3)
         ast_log(LOG_DEBUG, "Hanging up channel in state %s (not UP)\n", ast_state2str(ast->_state));
   }

   /* Disconnect */
   if (p->vad)
      ast_dsp_free(p->vad);

   p->owner = NULL;
   ast->tech_pvt = NULL;

   ast_module_unref(ast_module_info->self);

   /* Do not destroy this pvt until we have timeout or
      get an answer to the BYE or INVITE/CANCEL 
      If we get no answer during retransmit period, drop the call anyway.
      (Sorry, mother-in-law, you can't deny a hangup by sending
      603 declined to BYE...)
   */
   if (ast_test_flag(&p->flags[0], SIP_ALREADYGONE))
      needdestroy = 1;  /* Set destroy flag at end of this function */
   else if (p->invitestate != INV_CALLING)
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);

   /* Start the process if it's not already started */
   if (!ast_test_flag(&p->flags[0], SIP_ALREADYGONE) && !ast_strlen_zero(p->initreq.data)) {
      if (needcancel) { /* Outgoing call, not up */
         if (ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
            /* stop retransmitting an INVITE that has not received a response */
            __sip_pretend_ack(p);

            /* if we can't send right now, mark it pending */
            if (p->invitestate == INV_CALLING) {
               /* We can't send anything in CALLING state */
               ast_set_flag(&p->flags[0], SIP_PENDINGBYE);
               /* Do we need a timer here if we don't hear from them at all? */
            } else {
               /* Send a new request: CANCEL */
               transmit_request(p, SIP_CANCEL, p->ocseq, XMIT_RELIABLE, FALSE);
               /* Actually don't destroy us yet, wait for the 487 on our original 
                  INVITE, but do set an autodestruct just in case we never get it. */
               needdestroy = 0;
               sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
            }
            if ( p->initid != -1 ) {
               /* channel still up - reverse dec of inUse counter
                  only if the channel is not auto-congested */
               update_call_counter(p, INC_CALL_LIMIT);
            }
         } else { /* Incoming call, not up */
            const char *res;
            if (ast->hangupcause && (res = hangup_cause2sip(ast->hangupcause)))
               transmit_response_reliable(p, res, &p->initreq);
            else 
               transmit_response_reliable(p, "603 Declined", &p->initreq);
         }
      } else { /* Call is in UP state, send BYE */
         if (!p->pendinginvite) {
            char *audioqos = "";
            char *videoqos = "";
            if (p->rtp)
               audioqos = ast_rtp_get_quality(p->rtp, NULL);
            if (p->vrtp)
               videoqos = ast_rtp_get_quality(p->vrtp, NULL);
            /* Send a hangup */
            transmit_request_with_auth(p, SIP_BYE, 0, XMIT_RELIABLE, 1);

            /* Get RTCP quality before end of call */
            if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY)) {
               if (p->rtp)
                  append_history(p, "RTCPaudio", "Quality:%s", audioqos);
               if (p->vrtp)
                  append_history(p, "RTCPvideo", "Quality:%s", videoqos);
            }
            if (p->rtp && oldowner)
               pbx_builtin_setvar_helper(oldowner, "RTPAUDIOQOS", audioqos);
            if (p->vrtp && oldowner)
               pbx_builtin_setvar_helper(oldowner, "RTPVIDEOQOS", videoqos);
         } else {
            /* Note we will need a BYE when this all settles out
               but we can't send one while we have "INVITE" outstanding. */
            ast_set_flag(&p->flags[0], SIP_PENDINGBYE);  
            ast_clear_flag(&p->flags[0], SIP_NEEDREINVITE); 
            sip_cancel_destroy(p);
         }
      }
   }
   if (needdestroy)
      ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
   ast_mutex_unlock(&p->lock);
   return 0;
}

static int sip_indicate	(	struct ast_channel *	ast,
		int	condition,
		const void *	data,
		size_t	datalen
	)			[static]

Play indication to user With SIP a lot of indications is sent as messages, letting the device play the indication - busy signal, congestion etc.

Returns:

-1 to force ast_indicate to send indication in audio, 0 if SIP can handle the indication by sending a message

Definition at line 3666 of file chan_sip.c.

References ast_channel::_state, AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_HOLD, AST_CONTROL_PROCEEDING, AST_CONTROL_PROGRESS, AST_CONTROL_RINGING, AST_CONTROL_UNHOLD, AST_CONTROL_VIDUPDATE, ast_log(), ast_moh_start(), ast_moh_stop(), ast_mutex_lock(), ast_mutex_unlock(), ast_set_flag, AST_SOFTHANGUP_DEV, ast_softhangup_nolock(), AST_STATE_RING, AST_STATE_UP, ast_test_flag, sip_pvt::flags, sip_pvt::initreq, INV_COMPLETED, INV_EARLY_MEDIA, INV_PROCEEDING, sip_pvt::invitestate, sip_pvt::lock, LOG_WARNING, sip_alreadygone(), SIP_NOVIDEO, SIP_OUTGOING, SIP_PROG_INBAND, SIP_PROG_INBAND_NEVER, SIP_PROG_INBAND_YES, SIP_PROGRESS_SENT, SIP_RINGING, ast_channel::tech_pvt, transmit_info_with_vidupdate(), transmit_response(), transmit_response_with_sdp(), sip_pvt::vrtp, and XMIT_UNRELIABLE.

{
   struct sip_pvt *p = ast->tech_pvt;
   int res = 0;

   ast_mutex_lock(&p->lock);
   switch(condition) {
   case AST_CONTROL_RINGING:
      if (ast->_state == AST_STATE_RING) {
         p->invitestate = INV_EARLY_MEDIA;
         if (!ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) ||
             (ast_test_flag(&p->flags[0], SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER)) {            
            /* Send 180 ringing if out-of-band seems reasonable */
            transmit_response(p, "180 Ringing", &p->initreq);
            ast_set_flag(&p->flags[0], SIP_RINGING);
            if (ast_test_flag(&p->flags[0], SIP_PROG_INBAND) != SIP_PROG_INBAND_YES)
               break;
         } else {
            /* Well, if it's not reasonable, just send in-band */
         }
      }
      res = -1;
      break;
   case AST_CONTROL_BUSY:
      if (ast->_state != AST_STATE_UP) {
         transmit_response(p, "486 Busy Here", &p->initreq);
         p->invitestate = INV_COMPLETED;
         sip_alreadygone(p);
         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
         break;
      }
      res = -1;
      break;
   case AST_CONTROL_CONGESTION:
      if (ast->_state != AST_STATE_UP) {
         transmit_response(p, "503 Service Unavailable", &p->initreq);
         p->invitestate = INV_COMPLETED;
         sip_alreadygone(p);
         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
         break;
      }
      res = -1;
      break;
   case AST_CONTROL_PROCEEDING:
      if ((ast->_state != AST_STATE_UP) &&
          !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
          !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
         transmit_response(p, "100 Trying", &p->initreq);
         p->invitestate = INV_PROCEEDING;  
         break;
      }
      res = -1;
      break;
   case AST_CONTROL_PROGRESS:
      if ((ast->_state != AST_STATE_UP) &&
          !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
          !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
         p->invitestate = INV_EARLY_MEDIA;
         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, XMIT_UNRELIABLE);
         ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);  
         break;
      }
      res = -1;
      break;
   case AST_CONTROL_HOLD:
      ast_moh_start(ast, data, p->mohinterpret);
      break;
   case AST_CONTROL_UNHOLD:
      ast_moh_stop(ast);
      break;
   case AST_CONTROL_VIDUPDATE:   /* Request a video frame update */
      if (p->vrtp && !ast_test_flag(&p->flags[0], SIP_NOVIDEO)) {
         transmit_info_with_vidupdate(p);
         /* ast_rtcp_send_h261fur(p->vrtp); */
      } else
         res = -1;
      break;
   case -1:
      res = -1;
      break;
   default:
      ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
      res = -1;
      break;
   }
   ast_mutex_unlock(&p->lock);
   return res;
}

static const char * sip_nat_mode

(

const struct sip_pvt *

p

)

[static]

Display SIP nat mode.

Definition at line 1733 of file chan_sip.c.

References ast_test_flag, sip_pvt::flags, SIP_NAT, and SIP_NAT_ROUTE.

Referenced by check_via(), retrans_pkt(), and send_response().

{
   return ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE ? "NAT" : "no NAT";
}

static struct ast_channel* sip_new	(	struct sip_pvt *	i,
		int	state,
		const char *	title
	)			[static]

Initiate a call in the SIP channel called from sip_request_call (calls from the pbx ) for outbound channels and from handle_request_invite for inbound channels.

Definition at line 3762 of file chan_sip.c.

References accountcode, ast_channel::adsicpe, ast_channel::amaflags, sip_pvt::amaflags, append_history, AST_ADSI_UNAVAILABLE, ast_best_codec(), AST_CAUSE_SWITCH_CONGESTION, ast_channel_alloc(), ast_codec_choose(), ast_dsp_digitmode(), ast_dsp_new(), ast_dsp_set_features(), AST_FORMAT_VIDEO_MASK, ast_getformatname_multiple(), ast_hangup(), ast_jb_configure(), ast_log(), ast_module_ref(), ast_mutex_lock(), ast_mutex_unlock(), ast_pbx_start(), ast_rtcp_fd(), ast_rtp_fd(), AST_STATE_DOWN, AST_STATE_RING, ast_strdup, ast_string_field_set, ast_strlen_zero(), ast_test_flag, ast_udptl_fd(), sip_pvt::callgroup, ast_channel::callgroup, sip_pvt::callingpres, sip_pvt::capability, sip_pvt::chanvars, ast_channel::cid, ast_callerid::cid_ani, ast_callerid::cid_dnid, ast_callerid::cid_name, ast_callerid::cid_num, ast_callerid::cid_pres, ast_callerid::cid_rdnis, ast_channel::context, DSP_DIGITMODE_DTMF, DSP_DIGITMODE_RELAXDTMF, DSP_FEATURE_DTMF_DETECT, ast_channel::exten, ast_channel::fds, sip_pvt::flags, fmt, global_jbconf, ast_channel::hangupcause, sip_pvt::jointcapability, language, sip_pvt::lock, LOG_DEBUG, LOG_WARNING, ast_variable::name, ast_channel::nativeformats, ast_variable::next, option_debug, sip_pvt::owner, pbx_builtin_setvar_helper(), sip_pvt::pickupgroup, ast_channel::pickupgroup, sip_pvt::prefcodec, sip_pvt::prefs, ast_channel::priority, ast_channel::rawreadformat, ast_channel::rawwriteformat, ast_channel::readformat, ast_channel::rings, sip_pvt::rtp, SIP_DTMF, SIP_DTMF_INBAND, SIP_DTMF_INFO, SIP_NO_HISTORY, sip_tech, sip_tech_info, ast_channel::tech, ast_channel::tech_pvt, sip_pvt::udptl, sip_pvt::vad, ast_variable::value, sip_pvt::vrtp, and ast_channel::writeformat.

Referenced by handle_request_invite(), and sip_request_call().

{
   struct ast_channel *tmp;
   struct ast_variable *v = NULL;
   int fmt;
   int what;
   int needvideo = 0;
   {
      const char *my_name;    /* pick a good name */

      if (title)
         my_name = title;
      else if ( (my_name = strchr(i->fromdomain,':')) )
         my_name++;      /* skip ':' */
      else
         my_name = i->fromdomain;

      ast_mutex_unlock(&i->lock);
      /* Don't hold a sip pvt lock while we allocate a channel */
      tmp = ast_channel_alloc(1, state, i->cid_num, i->cid_name, i->accountcode, i->exten, i->context, i->amaflags, "SIP/%s-%08x", my_name, (int)(long) i);

   }
   if (!tmp) {
      ast_log(LOG_WARNING, "Unable to allocate AST channel structure for SIP channel\n");
      return NULL;
   }
   ast_mutex_lock(&i->lock);

   if (ast_test_flag(&i->flags[0], SIP_DTMF) == SIP_DTMF_INFO)
      tmp->tech = &sip_tech_info;
   else
      tmp->tech = &sip_tech;

   /* Select our native format based on codec preference until we receive
      something from another device to the contrary. */
   if (i->jointcapability)    /* The joint capabilities of us and peer */
      what = i->jointcapability;
   else if (i->capability)    /* Our configured capability for this peer */
      what = i->capability;
   else
      what = global_capability;  /* Global codec support */

   /* Set the native formats for audio  and merge in video */
   tmp->nativeformats = ast_codec_choose(&i->prefs, what, 1) | (i->jointcapability & AST_FORMAT_VIDEO_MASK);
   if (option_debug > 2) {
      char buf[BUFSIZ];
      ast_log(LOG_DEBUG, "*** Our native formats are %s \n", ast_getformatname_multiple(buf, BUFSIZ, tmp->nativeformats));
      ast_log(LOG_DEBUG, "*** Joint capabilities are %s \n", ast_getformatname_multiple(buf, BUFSIZ, i->jointcapability));
      ast_log(LOG_DEBUG, "*** Our capabilities are %s \n", ast_getformatname_multiple(buf, BUFSIZ, i->capability));
      ast_log(LOG_DEBUG, "*** AST_CODEC_CHOOSE formats are %s \n", ast_getformatname_multiple(buf, BUFSIZ, ast_codec_choose(&i->prefs, what, 1)));
      if (i->prefcodec)
         ast_log(LOG_DEBUG, "*** Our preferred formats from the incoming channel are %s \n", ast_getformatname_multiple(buf, BUFSIZ, i->prefcodec));
   }

   /* XXX Why are we choosing a codec from the native formats?? */
   fmt = ast_best_codec(tmp->nativeformats);

   /* If we have a prefcodec setting, we have an inbound channel that set a 
      preferred format for this call. Otherwise, we check the jointcapability
      We also check for vrtp. If it's not there, we are not allowed do any video anyway.
    */
   if (i->vrtp) {
      if (i->prefcodec)
         needvideo = i->prefcodec & AST_FORMAT_VIDEO_MASK;  /* Outbound call */
      else
         needvideo = i->jointcapability & AST_FORMAT_VIDEO_MASK;  /* Inbound call */
   }

   if (option_debug > 2) {
      if (needvideo) 
         ast_log(LOG_DEBUG, "This channel can handle video! HOLLYWOOD next!\n");
      else
         ast_log(LOG_DEBUG, "This channel will not be able to handle video.\n");
   }



   if (ast_test_flag(&i->flags[0], SIP_DTMF) ==  SIP_DTMF_INBAND) {
      i->vad = ast_dsp_new();
      ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
      if (global_relaxdtmf)
         ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
   }
   if (i->rtp) {
      tmp->fds[0] = ast_rtp_fd(i->rtp);
      tmp->fds[1] = ast_rtcp_fd(i->rtp);
   }
   if (needvideo && i->vrtp) {
      tmp->fds[2] = ast_rtp_fd(i->vrtp);
      tmp->fds[3] = ast_rtcp_fd(i->vrtp);
   }
   if (i->udptl) {
      tmp->fds[5] = ast_udptl_fd(i->udptl);
   }
   if (state == AST_STATE_RING)
      tmp->rings = 1;
   tmp->adsicpe = AST_ADSI_UNAVAILABLE;
   tmp->writeformat = fmt;
   tmp->rawwriteformat = fmt;
   tmp->readformat = fmt;
   tmp->rawreadformat = fmt;
   tmp->tech_pvt = i;

   tmp->callgroup = i->callgroup;
   tmp->pickupgroup = i->pickupgroup;
   tmp->cid.cid_pres = i->callingpres;
   if (!ast_strlen_zero(i->accountcode))
      ast_string_field_set(tmp, accountcode, i->accountcode);
   if (i->amaflags)
      tmp->amaflags = i->amaflags;
   if (!ast_strlen_zero(i->language))
      ast_string_field_set(tmp, language, i->language);
   i->owner = tmp;
   ast_module_ref(ast_module_info->self);
   ast_copy_string(tmp->context, i->context, sizeof(tmp->context));
   ast_copy_string(tmp->exten, i->exten, sizeof(tmp->exten));


   /* Don't use ast_set_callerid() here because it will
    * generate an unnecessary NewCallerID event  */
   tmp->cid.cid_num = ast_strdup(i->cid_num);
   tmp->cid.cid_ani = ast_strdup(i->cid_num);
   tmp->cid.cid_name = ast_strdup(i->cid_name);
   if (!ast_strlen_zero(i->rdnis))
      tmp->cid.cid_rdnis = ast_strdup(i->rdnis);
   
   if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
      tmp->cid.cid_dnid = ast_strdup(i->exten);

   tmp->priority = 1;
   if (!ast_strlen_zero(i->uri))
      pbx_builtin_setvar_helper(tmp, "SIPURI", i->uri);
   if (!ast_strlen_zero(i->domain))
      pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
   if (!ast_strlen_zero(i->useragent))
      pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
   if (!ast_strlen_zero(i->callid))
      pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
   if (i->rtp)
      ast_jb_configure(tmp, &global_jbconf);
   if (state != AST_STATE_DOWN && ast_pbx_start(tmp)) {
      ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
      tmp->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
      ast_hangup(tmp);
      tmp = NULL;
   }
   /* Set channel variables for this call from configuration */
   for (v = i->chanvars ; v ; v = v->next)
      pbx_builtin_setvar_helper(tmp,v->name,v->value);

   if (!ast_test_flag(&i->flags[0], SIP_NO_HISTORY))
      append_history(i, "NewChan", "Channel %s - from %s", tmp->name, i->callid);

   return tmp;
}

static int sip_no_debug	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Disable SIP Debugging in CLI.

Definition at line 11026 of file chan_sip.c.

References ast_clear_flag, ast_cli(), global_flags, RESULT_SHOWUSAGE, RESULT_SUCCESS, and SIP_PAGE2_DEBUG_CONSOLE.

{
   if (argc != 4)
      return RESULT_SHOWUSAGE;
   ast_clear_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
   ast_cli(fd, "SIP Debugging Disabled\n");
   return RESULT_SUCCESS;
}

static int sip_no_debug_deprecated	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Definition at line 11035 of file chan_sip.c.

References ast_clear_flag, ast_cli(), global_flags, RESULT_SHOWUSAGE, RESULT_SUCCESS, and SIP_PAGE2_DEBUG_CONSOLE.

{
   if (argc != 3)
      return RESULT_SHOWUSAGE;
   ast_clear_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
   ast_cli(fd, "SIP Debugging Disabled\n");
   return RESULT_SUCCESS;
}

static int sip_no_history	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Disable SIP History logging (CLI).

Definition at line 11056 of file chan_sip.c.

References ast_cli(), FALSE, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

{
   if (argc != 3) {
      return RESULT_SHOWUSAGE;
   }
   recordhistory = FALSE;
   ast_cli(fd, "SIP History Recording Disabled\n");
   return RESULT_SUCCESS;
}

static int sip_notify	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Cli command to send SIP notify to peer.

Definition at line 10970 of file chan_sip.c.

References __ourip, add_header(), ast_cli(), ast_log(), ast_sip_ouraddrfor(), ast_variable_browse(), build_callid_pvt(), build_via(), create_addr(), DEFAULT_TRANS_TIMEOUT, initreqprep(), LOG_WARNING, notify_types, RESULT_FAILURE, RESULT_SHOWUSAGE, RESULT_SUCCESS, sip_alloc(), sip_destroy(), SIP_NOTIFY, sip_scheddestroy(), transmit_sip_request(), and var.

{
   struct ast_variable *varlist;
   int i;

   if (argc < 4)
      return RESULT_SHOWUSAGE;

   if (!notify_types) {
      ast_cli(fd, "No %s file found, or no types listed there\n", notify_config);
      return RESULT_FAILURE;
   }

   varlist = ast_variable_browse(notify_types, argv[2]);

   if (!varlist) {
      ast_cli(fd, "Unable to find notify type '%s'\n", argv[2]);
      return RESULT_FAILURE;
   }

   for (i = 3; i < argc; i++) {
      struct sip_pvt *p;
      struct sip_request req;
      struct ast_variable *var;

      if (!(p = sip_alloc(NULL, NULL, 0, SIP_NOTIFY))) {
         ast_log(LOG_WARNING, "Unable to build sip pvt data for notify (memory/socket error)\n");
         return RESULT_FAILURE;
      }

      if (create_addr(p, argv[i])) {
         /* Maybe they're not registered, etc. */
         sip_destroy(p);
         ast_cli(fd, "Could not create address for '%s'\n", argv[i]);
         continue;
      }

      initreqprep(&req, p, SIP_NOTIFY);

      for (var = varlist; var; var = var->next)
         add_header(&req, var->name, var->value);

      /* Recalculate our side, and recalculate Call ID */
      if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
         p->ourip = __ourip;
      build_via(p);
      build_callid_pvt(p);
      ast_cli(fd, "Sending NOTIFY of type '%s' to '%s'\n", argv[2], argv[i]);
      transmit_sip_request(p, &req);
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
   }

   return RESULT_SUCCESS;
}

static int sip_park	(	struct ast_channel *	chan1,
		struct ast_channel *	chan2,
		struct sip_request *	req,
		int	seqno
	)			[static]

Park a call using the subsystem in res_features.c This is executed in a separate thread.

Definition at line 12652 of file chan_sip.c.

References ast_channel::amaflags, ast_calloc, AST_CAUSE_SWITCH_CONGESTION, ast_channel_alloc(), ast_channel_lock, ast_channel_masquerade(), ast_channel_unlock, ast_do_masquerade(), ast_hangup(), ast_log(), ast_pthread_create_background, AST_STATE_DOWN, ast_channel::context, copy_request(), ast_channel::exten, free, ast_channel::hangupcause, LOG_DEBUG, LOG_WARNING, option_debug, ast_channel::priority, ast_channel::readformat, sip_park_thread(), and ast_channel::writeformat.

Referenced by handle_request_refer().

{
   struct sip_dual *d;
   struct ast_channel *transferee, *transferer;
      /* Chan2m: The transferer, chan1m: The transferee */
   pthread_t th;

   transferee = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, chan1->accountcode, chan1->exten, chan1->context, chan1->amaflags, "Parking/%s", chan1->name);
   transferer = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, chan2->accountcode, chan2->exten, chan2->context, chan2->amaflags, "SIPPeer/%s", chan2->name);
   if ((!transferer) || (!transferee)) {
      if (transferee) {
         transferee->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
         ast_hangup(transferee);
      }
      if (transferer) {
         transferer->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
         ast_hangup(transferer);
      }
      return -1;
   }

   /* Make formats okay */
   transferee->readformat = chan1->readformat;
   transferee->writeformat = chan1->writeformat;

   /* Prepare for taking over the channel */
   ast_channel_masquerade(transferee, chan1);

   /* Setup the extensions and such */
   ast_copy_string(transferee->context, chan1->context, sizeof(transferee->context));
   ast_copy_string(transferee->exten, chan1->exten, sizeof(transferee->exten));
   transferee->priority = chan1->priority;
      
   /* We make a clone of the peer channel too, so we can play
      back the announcement */

   /* Make formats okay */
   transferer->readformat = chan2->readformat;
   transferer->writeformat = chan2->writeformat;

   /* Prepare for taking over the channel */
   ast_channel_masquerade(transferer, chan2);

   /* Setup the extensions and such */
   ast_copy_string(transferer->context, chan2->context, sizeof(transferer->context));
   ast_copy_string(transferer->exten, chan2->exten, sizeof(transferer->exten));
   transferer->priority = chan2->priority;

   ast_channel_lock(transferer);
   if (ast_do_masquerade(transferer)) {
      ast_log(LOG_WARNING, "Masquerade failed :(\n");
      ast_channel_unlock(transferer);
      transferer->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
      ast_hangup(transferer);
      return -1;
   }
   ast_channel_unlock(transferer);
   if (!transferer || !transferee) {
      if (!transferer) { 
         if (option_debug)
            ast_log(LOG_DEBUG, "No transferer channel, giving up parking\n");
      }
      if (!transferee) {
         if (option_debug)
            ast_log(LOG_DEBUG, "No transferee channel, giving up parking\n");
      }
      return -1;
   }
   if ((d = ast_calloc(1, sizeof(*d)))) {
      pthread_attr_t attr;

      pthread_attr_init(&attr);
      pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);   

      /* Save original request for followup */
      copy_request(&d->req, req);
      d->chan1 = transferee;  /* Transferee */
      d->chan2 = transferer;  /* Transferer */
      d->seqno = seqno;
      if (ast_pthread_create_background(&th, &attr, sip_park_thread, d) < 0) {
         /* Could not start thread */
         free(d); /* We don't need it anymore. If thread is created, d will be free'd
                  by sip_park_thread() */
         pthread_attr_destroy(&attr);
         return 0;
      }
      pthread_attr_destroy(&attr);
   } 
   return -1;
}

static void * sip_park_thread

(

void *

stuff

)

[static]

Park SIP call support function Starts in a new thread, then parks the call XXX Should we add a wait period after streaming audio and before hangup?? Sometimes the audio can't be heard before hangup.

Definition at line 12585 of file chan_sip.c.

References append_history, AST_CAUSE_NORMAL_CLEARING, ast_channel_lock, ast_channel_unlock, ast_do_masquerade(), ast_hangup(), ast_log(), ast_park_call(), sip_dual::chan1, sip_dual::chan2, copy_request(), ext, free, ast_channel::hangupcause, LOG_DEBUG, LOG_ERROR, LOG_WARNING, option_debug, sip_dual::req, sip_dual::seqno, ast_channel::tech_pvt, transmit_message_with_text(), transmit_notify_with_sipfrag(), transmit_response(), and TRUE.

Referenced by sip_park().

{
   struct ast_channel *transferee, *transferer; /* Chan1: The transferee, Chan2: The transferer */
   struct sip_dual *d;
   struct sip_request req;
   int ext;
   int res;

   d = stuff;
   transferee = d->chan1;
   transferer = d->chan2;
   copy_request(&req, &d->req);
   free(d);

   if (!transferee || !transferer) {
      ast_log(LOG_ERROR, "Missing channels for parking! Transferer %s Transferee %s\n", transferer ? "<available>" : "<missing>", transferee ? "<available>" : "<missing>" );
      return NULL;
   }
   if (option_debug > 3) 
      ast_log(LOG_DEBUG, "SIP Park: Transferer channel %s, Transferee %s\n", transferer->name, transferee->name);

   ast_channel_lock(transferee);
   if (ast_do_masquerade(transferee)) {
      ast_log(LOG_WARNING, "Masquerade failed.\n");
      transmit_response(transferer->tech_pvt, "503 Internal error", &req);
      ast_channel_unlock(transferee);
      return NULL;
   } 
   ast_channel_unlock(transferee);

   res = ast_park_call(transferee, transferer, 0, &ext);
   

#ifdef WHEN_WE_KNOW_THAT_THE_CLIENT_SUPPORTS_MESSAGE
   if (!res) {
      transmit_message_with_text(transferer->tech_pvt, "Unable to park call.\n");
   } else {
      /* Then tell the transferer what happened */
      sprintf(buf, "Call parked on extension '%d'", ext);
      transmit_message_with_text(transferer->tech_pvt, buf);
   }
#endif

   /* Any way back to the current call??? */
   /* Transmit response to the REFER request */
   transmit_response(transferer->tech_pvt, "202 Accepted", &req);
   if (!res)   {
      /* Transfer succeeded */
      append_history(transferer->tech_pvt, "SIPpark","Parked call on %d", ext);
      transmit_notify_with_sipfrag(transferer->tech_pvt, d->seqno, "200 OK", TRUE);
      transferer->hangupcause = AST_CAUSE_NORMAL_CLEARING;
      ast_hangup(transferer); /* This will cause a BYE */
      if (option_debug)
         ast_log(LOG_DEBUG, "SIP Call parked on extension '%d'\n", ext);
   } else {
      transmit_notify_with_sipfrag(transferer->tech_pvt, d->seqno, "503 Service Unavailable", TRUE);
      append_history(transferer->tech_pvt, "SIPpark","Parking failed\n");
      if (option_debug)
         ast_log(LOG_DEBUG, "SIP Call parked failed \n");
      /* Do not hangup call */
   }
   return NULL;
}

static void sip_peer_hold	(	struct sip_pvt *	p,
		int	hold
	)			[static]

Change onhold state of a peer using a pvt structure.

Definition at line 8203 of file chan_sip.c.

References ast_device_state_changed(), find_peer(), and sip_peer::onHold.

Referenced by process_sdp(), and update_call_counter().

{
   struct sip_peer *peer = find_peer(p->peername, NULL, 1);

   if (!peer)
      return;

   /* If they put someone on hold, increment the value... otherwise decrement it */
   if (hold)
      peer->onHold++;
   else
      peer->onHold--;

   /* Request device state update */
   ast_device_state_changed("SIP/%s", peer->name);

   return;
}

static void sip_poke_all_peers

(

void

)

[static]

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?

Definition at line 17175 of file chan_sip.c.

References ast_sched_add(), ast_sched_del(), ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_UNLOCK, ASTOBJ_WRLOCK, peerl, sched, and sip_poke_peer_s().

Referenced by load_module().

{
   int ms = 0;
   
   if (!speerobjs)   /* No peers, just give up */
      return;

   ASTOBJ_CONTAINER_TRAVERSE(&peerl, 1, do {
      ASTOBJ_WRLOCK(iterator);
      if (iterator->pokeexpire > -1)
         ast_sched_del(sched, iterator->pokeexpire);
      ms += 100;
      iterator->pokeexpire = ast_sched_add(sched, ms, sip_poke_peer_s, iterator);
      ASTOBJ_UNLOCK(iterator);
   } while (0)
   );
}

static int sip_poke_noanswer

(

void *

data

)

[static]

React to lack of answer to Qualify poke.

Definition at line 15207 of file chan_sip.c.

References ast_device_state_changed(), ast_log(), ast_sched_add(), sip_peer::call, DEFAULT_FREQ_NOTOK, EVENT_FLAG_SYSTEM, sip_peer::lastms, LOG_NOTICE, manager_event(), sip_peer::pokeexpire, sched, sip_destroy(), and sip_poke_peer_s().

Referenced by sip_poke_peer().

{
   struct sip_peer *peer = data;
   
   peer->pokeexpire = -1;
   if (peer->lastms > -1) {
      ast_log(LOG_NOTICE, "Peer '%s' is now UNREACHABLE!  Last qualify: %d\n", peer->name, peer->lastms);
      manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "Peer: SIP/%s\r\nPeerStatus: Unreachable\r\nTime: %d\r\n", peer->name, -1);
   }
   if (peer->call)
      sip_destroy(peer->call);
   peer->call = NULL;
   peer->lastms = -1;
   ast_device_state_changed("SIP/%s", peer->name);
   /* Try again quickly */
   peer->pokeexpire = ast_sched_add(sched, DEFAULT_FREQ_NOTOK, sip_poke_peer_s, peer);
   return 0;
}

static int sip_poke_peer

(

struct sip_peer *

peer

)

[static]

Check availability of peer, also keep NAT open.

Note:

This is done with the interval in qualify= configuration option Default is 2 seconds

Definition at line 15229 of file chan_sip.c.

References __ourip, sip_peer::addr, ast_copy_flags, ast_inet_ntoa(), ast_log(), ast_sched_add(), ast_sched_del(), ast_set_flag, ast_sip_ouraddrfor(), ast_string_field_set, ast_strlen_zero(), build_callid_pvt(), build_via(), sip_peer::call, DEFAULT_MAXMS, sip_peer::flags, sip_pvt::flags, sip_peer::fullcontact, sip_peer::lastms, LOG_NOTICE, sip_peer::maxms, sip_pvt::ourip, sip_peer::pokeexpire, sip_peer::ps, sip_pvt::recv, sip_pvt::relatedpeer, sip_pvt::sa, sched, sip_alloc(), sip_destroy(), SIP_FLAGS_TO_COPY, SIP_INVITE, SIP_OPTIONS, SIP_OUTGOING, SIP_PAGE2_FLAGS_TO_COPY, sip_poke_noanswer(), sipdebug, sip_peer::tohost, and transmit_invite().

Referenced by parse_register_contact(), reg_source_db(), and sip_poke_peer_s().

{
   struct sip_pvt *p;

   if (!peer->maxms || !peer->addr.sin_addr.s_addr) {
      /* IF we have no IP, or this isn't to be monitored, return
        imeediately after clearing things out */
      if (peer->pokeexpire > -1)
         ast_sched_del(sched, peer->pokeexpire);
      peer->lastms = 0;
      peer->pokeexpire = -1;
      peer->call = NULL;
      return 0;
   }
   if (peer->call) {
      if (sipdebug)
         ast_log(LOG_NOTICE, "Still have a QUALIFY dialog active, deleting\n");
      sip_destroy(peer->call);
   }
   if (!(p = peer->call = sip_alloc(NULL, NULL, 0, SIP_OPTIONS)))
      return -1;
   
   p->sa = peer->addr;
   p->recv = peer->addr;
   ast_copy_flags(&p->flags[0], &peer->flags[0], SIP_FLAGS_TO_COPY);
   ast_copy_flags(&p->flags[1], &peer->flags[1], SIP_PAGE2_FLAGS_TO_COPY);

   /* Send OPTIONs to peer's fullcontact */
   if (!ast_strlen_zero(peer->fullcontact))
      ast_string_field_set(p, fullcontact, peer->fullcontact);

   if (!ast_strlen_zero(peer->tohost))
      ast_string_field_set(p, tohost, peer->tohost);
   else
      ast_string_field_set(p, tohost, ast_inet_ntoa(peer->addr.sin_addr));

   /* Recalculate our side, and recalculate Call ID */
   if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
      p->ourip = __ourip;
   build_via(p);
   build_callid_pvt(p);

   if (peer->pokeexpire > -1)
      ast_sched_del(sched, peer->pokeexpire);
   p->relatedpeer = peer;
   ast_set_flag(&p->flags[0], SIP_OUTGOING);
#ifdef VOCAL_DATA_HACK
   ast_copy_string(p->username, "__VOCAL_DATA_SHOULD_READ_THE_SIP_SPEC__", sizeof(p->username));
   transmit_invite(p, SIP_INVITE, 0, 2);
#else
   transmit_invite(p, SIP_OPTIONS, 0, 2);
#endif
   gettimeofday(&peer->ps, NULL);
   peer->pokeexpire = ast_sched_add(sched, DEFAULT_MAXMS * 2, sip_poke_noanswer, peer);

   return 0;
}

static int sip_poke_peer_s

(

void *

data

)

[static]

Poke peer (send qualify to check if peer is alive and well).

Definition at line 7607 of file chan_sip.c.

References sip_peer::pokeexpire, and sip_poke_peer().

Referenced by handle_response_peerpoke(), reg_source_db(), sip_poke_all_peers(), and sip_poke_noanswer().

{
   struct sip_peer *peer = data;

   peer->pokeexpire = -1;
   sip_poke_peer(peer);
   return 0;
}

static int sip_prune_realtime	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Remove temporary realtime objects from memory (CLI).

Definition at line 9763 of file chan_sip.c.

References ast_cli(), ast_test_flag, ASTOBJ_CONTAINER_PRUNE_MARKED, ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_CONTAINER_UNLOCK, ASTOBJ_CONTAINER_WRLOCK, ASTOBJ_MARK, ASTOBJ_RDLOCK, ASTOBJ_UNLOCK, FALSE, name, peerl, RESULT_SHOWUSAGE, sip_destroy_peer(), SIP_PAGE2_RTCACHEFRIENDS, and TRUE.

{
   struct sip_peer *peer;
   struct sip_user *user;
   int pruneuser = FALSE;
   int prunepeer = FALSE;
   int multi = FALSE;
   char *name = NULL;
   regex_t regexbuf;

   switch (argc) {
   case 4:
      if (!strcasecmp(argv[3], "user"))
         return RESULT_SHOWUSAGE;
      if (!strcasecmp(argv[3], "peer"))
         return RESULT_SHOWUSAGE;
      if (!strcasecmp(argv[3], "like"))
         return RESULT_SHOWUSAGE;
      if (!strcasecmp(argv[3], "all")) {
         multi = TRUE;
         pruneuser = prunepeer = TRUE;
      } else {
         pruneuser = prunepeer = TRUE;
         name = argv[3];
      }
      break;
   case 5:
      if (!strcasecmp(argv[4], "like"))
         return RESULT_SHOWUSAGE;
      if (!strcasecmp(argv[3], "all"))
         return RESULT_SHOWUSAGE;
      if (!strcasecmp(argv[3], "like")) {
         multi = TRUE;
         name = argv[4];
         pruneuser = prunepeer = TRUE;
      } else if (!strcasecmp(argv[3], "user")) {
         pruneuser = TRUE;
         if (!strcasecmp(argv[4], "all"))
            multi = TRUE;
         else
            name = argv[4];
      } else if (!strcasecmp(argv[3], "peer")) {
         prunepeer = TRUE;
         if (!strcasecmp(argv[4], "all"))
            multi = TRUE;
         else
            name = argv[4];
      } else
         return RESULT_SHOWUSAGE;
      break;
   case 6:
      if (strcasecmp(argv[4], "like"))
         return RESULT_SHOWUSAGE;
      if (!strcasecmp(argv[3], "user")) {
         pruneuser = TRUE;
         name = argv[5];
      } else if (!strcasecmp(argv[3], "peer")) {
         prunepeer = TRUE;
         name = argv[5];
      } else
         return RESULT_SHOWUSAGE;
      break;
   default:
      return RESULT_SHOWUSAGE;
   }

   if (multi && name) {
      if (regcomp(&regexbuf, name, REG_EXTENDED | REG_NOSUB))
         return RESULT_SHOWUSAGE;
   }

   if (multi) {
      if (prunepeer) {
         int pruned = 0;

         ASTOBJ_CONTAINER_WRLOCK(&peerl);
         ASTOBJ_CONTAINER_TRAVERSE(&peerl, 1, do {
            ASTOBJ_RDLOCK(iterator);
            if (name && regexec(&regexbuf, iterator->name, 0, NULL, 0)) {
               ASTOBJ_UNLOCK(iterator);
               continue;
            };
            if (ast_test_flag(&iterator->flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
               ASTOBJ_MARK(iterator);
               pruned++;
            }
            ASTOBJ_UNLOCK(iterator);
         } while (0) );
         if (pruned) {
            ASTOBJ_CONTAINER_PRUNE_MARKED(&peerl, sip_destroy_peer);
            ast_cli(fd, "%d peers pruned.\n", pruned);
         } else
            ast_cli(fd, "No peers found to prune.\n");
         ASTOBJ_CONTAINER_UNLOCK(&peerl);
      }
      if (pruneuser) {
         int pruned = 0;

         ASTOBJ_CONTAINER_WRLOCK(&userl);
         ASTOBJ_CONTAINER_TRAVERSE(&userl, 1, do {
            ASTOBJ_RDLOCK(iterator);
            if (name && regexec(&regexbuf, iterator->name, 0, NULL, 0)) {
               ASTOBJ_UNLOCK(iterator);
               continue;
            };
            if (ast_test_flag(&iterator->flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
               ASTOBJ_MARK(iterator);
               pruned++;
            }
            ASTOBJ_UNLOCK(iterator);
         } while (0) );
         if (pruned) {
            ASTOBJ_CONTAINER_PRUNE_MARKED(&userl, sip_destroy_user);
            ast_cli(fd, "%d users pruned.\n", pruned);
         } else
            ast_cli(fd, "No users found to prune.\n");
         ASTOBJ_CONTAINER_UNLOCK(&userl);
      }
   } else {
      if (prunepeer) {
         if ((peer = ASTOBJ_CONTAINER_FIND_UNLINK(&peerl, name))) {
            if (!ast_test_flag(&peer->flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
               ast_cli(fd, "Peer '%s' is not a Realtime peer, cannot be pruned.\n", name);
               ASTOBJ_CONTAINER_LINK(&peerl, peer);
            } else
               ast_cli(fd, "Peer '%s' pruned.\n", name);
            ASTOBJ_UNREF(peer, sip_destroy_peer);
         } else
            ast_cli(fd, "Peer '%s' not found.\n", name);
      }
      if (pruneuser) {
         if ((user = ASTOBJ_CONTAINER_FIND_UNLINK(&userl, name))) {
            if (!ast_test_flag(&user->flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
               ast_cli(fd, "User '%s' is not a Realtime user, cannot be pruned.\n", name);
               ASTOBJ_CONTAINER_LINK(&userl, user);
            } else
               ast_cli(fd, "User '%s' pruned.\n", name);
            ASTOBJ_UNREF(user, sip_destroy_user);
         } else
            ast_cli(fd, "User '%s' not found.\n", name);
      }
   }

   return RESULT_SUCCESS;
}

static struct ast_frame * sip_read

(

struct ast_channel *

ast

)

[static]

Read SIP RTP from channel.

Definition at line 4119 of file chan_sip.c.

References ast_bridged_channel(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_set_flag, ast_test_flag, FALSE, sip_pvt::flags, sip_pvt::lastrtprx, sip_pvt::lock, LOG_DEBUG, option_debug, sip_pvt::pendinginvite, SIP_GOTREFER, SIP_NEEDREINVITE, SIP_PAGE2_T38SUPPORT_UDPTL, SIP_PENDINGBYE, sip_rtp_read(), t38properties::state, sip_pvt::t38, T38_DISABLED, T38_LOCAL_REINVITE, t38properties::t38support, ast_channel::tech_pvt, and transmit_reinvite_with_t38_sdp().

{
   struct ast_frame *fr;
   struct sip_pvt *p;
   
   if( ast == NULL )
       return NULL;
   
   p = ast->tech_pvt;
   int faxdetected = FALSE;

   if( p == NULL )
       return NULL;  

   ast_mutex_lock(&p->lock);
   fr = sip_rtp_read(ast, p, &faxdetected);
   p->lastrtprx = time(NULL);

   /* If we are NOT bridged to another channel, and we have detected fax tone we issue T38 re-invite to a peer */
   /* If we are bridged then it is the responsibility of the SIP device to issue T38 re-invite if it detects CNG or fax preamble */
   if (faxdetected && ast_test_flag(&p->t38.t38support, SIP_PAGE2_T38SUPPORT_UDPTL) && (p->t38.state == T38_DISABLED) && !(ast_bridged_channel(ast))) {
      if (!ast_test_flag(&p->flags[0], SIP_GOTREFER)) {
         if (!p->pendinginvite) {
            if (option_debug > 2)
               ast_log(LOG_DEBUG, "Sending reinvite on SIP (%s) for T.38 negotiation.\n",ast->name);
            p->t38.state = T38_LOCAL_REINVITE;
            transmit_reinvite_with_t38_sdp(p);
            if (option_debug > 1)
               ast_log(LOG_DEBUG, "T38 state changed to %d on channel %s\n", p->t38.state, ast->name);
         }
      } else if (!ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
         if (option_debug > 2)
            ast_log(LOG_DEBUG, "Deferring reinvite on SIP (%s) - it will be re-negotiated for T.38\n", ast->name);
         ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
      }
   }

   ast_mutex_unlock(&p->lock);
   return fr;
}

static struct sockaddr_in * sip_real_dst

(

const struct sip_pvt *

p

)

[static]

The real destination address for a write.

Definition at line 1727 of file chan_sip.c.

References ast_test_flag, sip_pvt::flags, sip_pvt::recv, sip_pvt::sa, SIP_NAT, and SIP_NAT_ROUTE.

Referenced by __sip_xmit(), check_via(), retrans_pkt(), send_response(), and sip_debug_test_pvt().

{
   return ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE ? &p->recv : &p->sa;
}

static int sip_refer_allocate

(

struct sip_pvt *

p

)

[static]

Allocate SIP refer structure.

Definition at line 7418 of file chan_sip.c.

References ast_calloc, and sip_pvt::refer.

Referenced by handle_request_invite(), handle_request_refer(), and transmit_refer().

{
   p->refer = ast_calloc(1, sizeof(struct sip_refer)); 
   return p->refer ? 1 : 0;
}

static int sip_reg_timeout

(

void *

data

)

[static]

Registration timeout, register again.

Definition at line 7175 of file chan_sip.c.

References __sip_pretend_ack(), ast_log(), ast_set_flag, ASTOBJ_REF, ASTOBJ_UNREF, sip_registry::call, EVENT_FLAG_SYSTEM, sip_pvt::flags, LOG_NOTICE, manager_event(), REG_STATE_FAILED, REG_STATE_UNREGISTERED, sip_registry::regattempts, sip_pvt::registry, sip_registry::regstate, regstate2str(), SIP_NEEDDESTROY, SIP_REGISTER, sip_registry_destroy(), sip_registry::timeout, and transmit_register().

Referenced by transmit_register().

{

   /* if we are here, our registration timed out, so we'll just do it over */
   struct sip_registry *r = ASTOBJ_REF((struct sip_registry *) data);
   struct sip_pvt *p;
   int res;

   /* if we couldn't get a reference to the registry object, punt */
   if (!r)
      return 0;

   ast_log(LOG_NOTICE, "   -- Registration for '%s@%s' timed out, trying again (Attempt #%d)\n", r->username, r->hostname, r->regattempts); 
   if (r->call) {
      /* Unlink us, destroy old call.  Locking is not relevant here because all this happens
         in the single SIP manager thread. */
      p = r->call;
      if (p->registry)
         ASTOBJ_UNREF(p->registry, sip_registry_destroy);
      r->call = NULL;
      ast_set_flag(&p->flags[0], SIP_NEEDDESTROY); 
      /* Pretend to ACK anything just in case */
      __sip_pretend_ack(p); /* XXX we need p locked, not sure we have */
   }
   /* If we have a limit, stop registration and give up */
   if (global_regattempts_max && (r->regattempts > global_regattempts_max)) {
      /* Ok, enough is enough. Don't try any more */
      /* We could add an external notification here... 
         steal it from app_voicemail :-) */
      ast_log(LOG_NOTICE, "   -- Giving up forever trying to register '%s@%s'\n", r->username, r->hostname);
      r->regstate = REG_STATE_FAILED;
   } else {
      r->regstate = REG_STATE_UNREGISTERED;
      r->timeout = -1;
      res=transmit_register(r, SIP_REGISTER, NULL, NULL);
   }
   manager_event(EVENT_FLAG_SYSTEM, "Registry", "ChannelDriver: SIP\r\nUsername: %s\r\nDomain: %s\r\nStatus: %s\r\n", r->username, r->hostname, regstate2str(r->regstate));
   ASTOBJ_UNREF(r, sip_registry_destroy);
   return 0;
}

static int sip_register	(	char *	value,
		int	lineno
	)			[static]

Parse register=> line in sip.conf and add to registry.

Definition at line 4446 of file chan_sip.c.

References ast_calloc, ast_log(), ast_string_field_init, ast_string_field_set, ast_strlen_zero(), ASTOBJ_CONTAINER_LINK, ASTOBJ_INIT, ASTOBJ_UNREF, FALSE, free, hostname, INITIAL_CSEQ, LOG_ERROR, LOG_WARNING, regl, secret, sip_registry_destroy(), and username.

{
   struct sip_registry *reg;
   int portnum = 0;
   char username[256] = "";
   char *hostname=NULL, *secret=NULL, *authuser=NULL;
   char *porta=NULL;
   char *contact=NULL;

   if (!value)
      return -1;
   ast_copy_string(username, value, sizeof(username));
   /* First split around the last '@' then parse the two components. */
   hostname = strrchr(username, '@'); /* allow @ in the first part */
   if (hostname)
      *hostname++ = '\0';
   if (ast_strlen_zero(username) || ast_strlen_zero(hostname)) {
      ast_log(LOG_WARNING, "Format for registration is user[:secret[:authuser]]@host[:port][/contact] at line %d\n", lineno);
      return -1;
   }
   /* split user[:secret[:authuser]] */
   secret = strchr(username, ':');
   if (secret) {
      *secret++ = '\0';
      authuser = strchr(secret, ':');
      if (authuser)
         *authuser++ = '\0';
   }
   /* split host[:port][/contact] */
   contact = strchr(hostname, '/');
   if (contact)
      *contact++ = '\0';
   if (ast_strlen_zero(contact))
      contact = "s";
   porta = strchr(hostname, ':');
   if (porta) {
      *porta++ = '\0';
      portnum = atoi(porta);
      if (portnum == 0) {
         ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
         return -1;
      }
   }
   if (!(reg = ast_calloc(1, sizeof(*reg)))) {
      ast_log(LOG_ERROR, "Out of memory. Can't allocate SIP registry entry\n");
      return -1;
   }

   if (ast_string_field_init(reg, 256)) {
      ast_log(LOG_ERROR, "Out of memory. Can't allocate SIP registry strings\n");
      free(reg);
      return -1;
   }

   regobjs++;
   ASTOBJ_INIT(reg);
   ast_string_field_set(reg, contact, contact);
   if (username)
      ast_string_field_set(reg, username, username);
   if (hostname)
      ast_string_field_set(reg, hostname, hostname);
   if (authuser)
      ast_string_field_set(reg, authuser, authuser);
   if (secret)
      ast_string_field_set(reg, secret, secret);
   reg->expire = -1;
   reg->timeout =  -1;
   reg->refresh = default_expiry;
   reg->portno = portnum;
   reg->callid_valid = FALSE;
   reg->ocseq = INITIAL_CSEQ;
   ASTOBJ_CONTAINER_LINK(&regl, reg);  /* Add the new registry entry to the list */
   ASTOBJ_UNREF(reg,sip_registry_destroy);
   return 0;
}

static void sip_registry_destroy

(

struct sip_registry *

reg

)

[static]

Destroy registry object Objects created with the register= statement in static configuration.

Definition at line 2859 of file chan_sip.c.

References ast_log(), ast_sched_del(), ast_string_field_free_pools, sip_registry::call, sip_registry::expire, free, LOG_DEBUG, option_debug, sip_pvt::registry, sched, sip_destroy(), and sip_registry::timeout.

Referenced by __sip_destroy(), handle_response_register(), sip_reg_timeout(), sip_register(), sip_reregister(), and unload_module().

{
   /* Really delete */
   if (option_debug > 2)
      ast_log(LOG_DEBUG, "Destroying registry entry for %s@%s\n", reg->username, reg->hostname);

   if (reg->call) {
      /* Clear registry before destroying to ensure
         we don't get reentered trying to grab the registry lock */
      reg->call->registry = NULL;
      if (option_debug > 2)
         ast_log(LOG_DEBUG, "Destroying active SIP dialog for registry %s@%s\n", reg->username, reg->hostname);
      sip_destroy(reg->call);
   }
   if (reg->expire > -1)
      ast_sched_del(sched, reg->expire);
   if (reg->timeout > -1)
      ast_sched_del(sched, reg->timeout);
   ast_string_field_free_pools(reg);
   regobjs--;
   free(reg);
   
}

static int sip_reload	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Force reload of module from cli.

Definition at line 17267 of file chan_sip.c.

References ast_mutex_lock(), ast_mutex_unlock(), ast_verbose(), CHANNEL_CLI_RELOAD, CHANNEL_MODULE_RELOAD, restart_monitor(), and TRUE.

Referenced by reload().

{
   ast_mutex_lock(&sip_reload_lock);
   if (sip_reloading) 
      ast_verbose("Previous SIP reload not yet done\n");
   else {
      sip_reloading = TRUE;
      if (fd)
         sip_reloadreason = CHANNEL_CLI_RELOAD;
      else
         sip_reloadreason = CHANNEL_MODULE_RELOAD;
   }
   ast_mutex_unlock(&sip_reload_lock);
   restart_monitor();

   return 0;
}

static struct ast_channel * sip_request_call	(	const char *	type,
		int	format,
		void *	data,
		int *	cause
	)			[static]

PBX interface function -build SIP pvt structure SIP calls initiated by the PBX arrive here.

Note:

This is added to help splitting up chan_sip.c into several files in coming releases

Definition at line 15387 of file chan_sip.c.

References __ourip, ast_calloc, AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, AST_CAUSE_SWITCH_CONGESTION, AST_CAUSE_UNREGISTERED, AST_FORMAT_MAX_AUDIO, ast_getformatname(), ast_getformatname_multiple(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_set_flag, ast_sip_ouraddrfor(), AST_STATE_DOWN, ast_string_field_free, ast_string_field_set, ast_strlen_zero(), ast_update_use_count(), build_callid_pvt(), build_via(), create_addr(), ext, sip_pvt::flags, LOG_DEBUG, LOG_ERROR, LOG_NOTICE, option_debug, sip_pvt::options, restart_monitor(), sip_alloc(), sip_destroy(), SIP_INVITE, sip_new(), SIP_PAGE2_OUTGOING_CALL, and username.

{
   int oldformat;
   struct sip_pvt *p;
   struct ast_channel *tmpc = NULL;
   char *ext, *host;
   char tmp[256];
   char *dest = data;

   oldformat = format;
   if (!(format &= ((AST_FORMAT_MAX_AUDIO << 1) - 1))) {
      ast_log(LOG_NOTICE, "Asked to get a channel of unsupported format %s while capability is %s\n", ast_getformatname(oldformat), ast_getformatname(global_capability));
      *cause = AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;   /* Can't find codec to connect to host */
      return NULL;
   }
   if (option_debug)
      ast_log(LOG_DEBUG, "Asked to create a SIP channel with formats: %s\n", ast_getformatname_multiple(tmp, sizeof(tmp), oldformat));

   if (!(p = sip_alloc(NULL, NULL, 0, SIP_INVITE))) {
      ast_log(LOG_ERROR, "Unable to build sip pvt data for '%s' (Out of memory or socket error)\n", (char *)data);
      *cause = AST_CAUSE_SWITCH_CONGESTION;
      return NULL;
   }

   ast_set_flag(&p->flags[1], SIP_PAGE2_OUTGOING_CALL);

   if (!(p->options = ast_calloc(1, sizeof(*p->options)))) {
      sip_destroy(p);
      ast_log(LOG_ERROR, "Unable to build option SIP data structure - Out of memory\n");
      *cause = AST_CAUSE_SWITCH_CONGESTION;
      return NULL;
   }

   ast_copy_string(tmp, dest, sizeof(tmp));
   host = strchr(tmp, '@');
   if (host) {
      *host++ = '\0';
      ext = tmp;
   } else {
      ext = strchr(tmp, '/');
      if (ext) 
         *ext++ = '\0';
      host = tmp;
   }

   if (create_addr(p, host)) {
      *cause = AST_CAUSE_UNREGISTERED;
      if (option_debug > 2)
         ast_log(LOG_DEBUG, "Cant create SIP call - target device not registred\n");
      sip_destroy(p);
      return NULL;
   }
   if (ast_strlen_zero(p->peername) && ext)
      ast_string_field_set(p, peername, ext);
   /* Recalculate our side, and recalculate Call ID */
   if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
      p->ourip = __ourip;
   build_via(p);
   build_callid_pvt(p);
   
   /* We have an extension to call, don't use the full contact here */
   /* This to enable dialing registered peers with extension dialling,
      like SIP/peername/extension   
      SIP/peername will still use the full contact */
   if (ext) {
      ast_string_field_set(p, username, ext);
      ast_string_field_free(p, fullcontact);
   }
#if 0
   printf("Setting up to call extension '%s' at '%s'\n", ext ? ext : "<none>", host);
#endif
   p->prefcodec = oldformat;           /* Format for this call */
   ast_mutex_lock(&p->lock);
   tmpc = sip_new(p, AST_STATE_DOWN, host);  /* Place the call */
   ast_mutex_unlock(&p->lock);
   if (!tmpc)
      sip_destroy(p);
   ast_update_use_count();
   restart_monitor();
   return tmpc;
}

static int sip_reregister

(

void *

data

)

[static]

Update registration with SIP Proxy.

Definition at line 7143 of file chan_sip.c.

References __sip_do_register(), append_history, ast_log(), ast_test_flag, ASTOBJ_REF, ASTOBJ_UNREF, sip_registry::call, sip_registry::expire, sip_pvt::flags, LOG_NOTICE, SIP_NO_HISTORY, sip_registry_destroy(), and sipdebug.

Referenced by handle_response_register(), and sip_send_all_registers().

{
   /* if we are here, we know that we need to reregister. */
   struct sip_registry *r= ASTOBJ_REF((struct sip_registry *) data);

   /* if we couldn't get a reference to the registry object, punt */
   if (!r)
      return 0;

   if (r->call && !ast_test_flag(&r->call->flags[0], SIP_NO_HISTORY))
      append_history(r->call, "RegistryRenew", "Account: %s@%s", r->username, r->hostname);
   /* Since registry's are only added/removed by the the monitor thread, this
      may be overkill to reference/dereference at all here */
   if (sipdebug)
      ast_log(LOG_NOTICE, "   -- Re-registration for  %s@%s\n", r->username, r->hostname);

   r->expire = -1;
   __sip_do_register(r);
   ASTOBJ_UNREF(r, sip_registry_destroy);
   return 0;
}

static struct ast_frame * sip_rtp_read	(	struct ast_channel *	ast,
		struct sip_pvt *	p,
		int *	faxdetect
	)			[static]

Read RTP from network.

Definition at line 4049 of file chan_sip.c.

References ast_dsp_process(), AST_FORMAT_AUDIO_MASK, AST_FORMAT_VIDEO_MASK, AST_FRAME_DTMF, AST_FRAME_VOICE, ast_getformatname(), ast_log(), ast_null_frame, ast_rtcp_read(), ast_rtp_read(), ast_set_read_format(), ast_set_write_format(), ast_test_flag, ast_udptl_read(), f, ast_channel::fdno, sip_pvt::flags, sip_pvt::jointcapability, LOG_DEBUG, ast_channel::nativeformats, option_debug, sip_pvt::owner, ast_channel::readformat, sip_pvt::rtp, SIP_DTMF, SIP_DTMF_INBAND, SIP_DTMF_RFC2833, SIP_PAGE2_T38SUPPORT_UDPTL, sip_pvt::t38, t38properties::t38support, sip_pvt::udptl, sip_pvt::vad, sip_pvt::vrtp, and ast_channel::writeformat.

Referenced by sip_read().

{
   /* Retrieve audio/etc from channel.  Assumes p->lock is already held. */
   struct ast_frame *f;
   
   if (!p->rtp) {
      /* We have no RTP allocated for this channel */
      return &ast_null_frame;
   }

   switch(ast->fdno) {
   case 0:
      f = ast_rtp_read(p->rtp);  /* RTP Audio */
      break;
   case 1:
      f = ast_rtcp_read(p->rtp); /* RTCP Control Channel */
      break;
   case 2:
      f = ast_rtp_read(p->vrtp); /* RTP Video */
      break;
   case 3:
      f = ast_rtcp_read(p->vrtp);   /* RTCP Control Channel for video */
      break;
   case 5:
      f = ast_udptl_read(p->udptl); /* UDPTL for T.38 */
      break;
   default:
      f = &ast_null_frame;
   }
   /* Don't forward RFC2833 if we're not supposed to */
   if (f && (f->frametype == AST_FRAME_DTMF) &&
       (ast_test_flag(&p->flags[0], SIP_DTMF) != SIP_DTMF_RFC2833))
      return &ast_null_frame;

      /* We already hold the channel lock */
   if (!p->owner || f->frametype != AST_FRAME_VOICE)
      return f;

   if (f->subclass != (p->owner->nativeformats & AST_FORMAT_AUDIO_MASK)) {
      if (!(f->subclass & p->jointcapability)) {
         if (option_debug) {
            ast_log(LOG_DEBUG, "Bogus frame of format '%s' received from '%s'!\n",
               ast_getformatname(f->subclass), p->owner->name);
         }
         return &ast_null_frame;
      }
      if (option_debug)
         ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
      p->owner->nativeformats = (p->owner->nativeformats & AST_FORMAT_VIDEO_MASK) | f->subclass;
      ast_set_read_format(p->owner, p->owner->readformat);
      ast_set_write_format(p->owner, p->owner->writeformat);
   }

   if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_INBAND) && p->vad) {
      f = ast_dsp_process(p->owner, p->vad, f);
      if (f && f->frametype == AST_FRAME_DTMF) {
         if (ast_test_flag(&p->t38.t38support, SIP_PAGE2_T38SUPPORT_UDPTL) && f->subclass == 'f') {
            if (option_debug)
               ast_log(LOG_DEBUG, "Fax CNG detected on %s\n", ast->name);
            *faxdetect = 1;
         } else if (option_debug) {
            ast_log(LOG_DEBUG, "* Detected inband DTMF '%c'\n", f->subclass);
         }
      }
   }
   
   return f;
}

static void sip_scheddestroy	(	struct sip_pvt *	p,
		int	ms
	)			[static]

Schedule destruction of SIP dialog.

Definition at line 2027 of file chan_sip.c.

References __sip_autodestruct(), append_history, ast_sched_add(), ast_sched_del(), ast_test_flag, ast_verbose(), sip_pvt::flags, sip_pvt::method, sched, sip_debug_test_pvt(), sip_methods, SIP_NO_HISTORY, cfsip_methods::text, and sip_pvt::timer_t1.

Referenced by __sip_autodestruct(), cb_extensionstate(), check_auth(), check_pendings(), handle_invite_replaces(), handle_request(), handle_request_bye(), handle_request_cancel(), handle_request_info(), handle_request_invite(), handle_request_notify(), handle_request_options(), handle_request_register(), handle_request_subscribe(), handle_response_invite(), handle_response_register(), receive_message(), sip_hangup(), sip_notify(), sip_send_mwi_to_peer(), and sip_sipredirect().

{
   if (ms < 0) {
      if (p->timer_t1 == 0)
         p->timer_t1 = 500;   /* Set timer T1 if not set (RFC 3261) */
      ms = p->timer_t1 * 64;
   }
   if (sip_debug_test_pvt(p))
      ast_verbose("Scheduling destruction of SIP dialog '%s' in %d ms (Method: %s)\n", p->callid, ms, sip_methods[p->method].text);
   if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
      append_history(p, "SchedDestroy", "%d ms", ms);

   if (p->autokillid > -1)
      ast_sched_del(sched, p->autokillid);
   p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, p);
}

static void sip_send_all_registers

(

void

)

[static]

Send all known registrations.

Definition at line 17194 of file chan_sip.c.

References ast_sched_add(), ast_sched_del(), ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_UNLOCK, ASTOBJ_WRLOCK, regl, sched, and sip_reregister().

Referenced by load_module().

{
   int ms;
   int regspacing;
   if (!regobjs)
      return;
   regspacing = default_expiry * 1000/regobjs;
   if (regspacing > 100)
      regspacing = 100;
   ms = regspacing;
   ASTOBJ_CONTAINER_TRAVERSE(&regl, 1, do {
      ASTOBJ_WRLOCK(iterator);
      if (iterator->expire > -1)
         ast_sched_del(sched, iterator->expire);
      ms += regspacing;
      iterator->expire = ast_sched_add(sched, ms, sip_reregister, iterator);
      ASTOBJ_UNLOCK(iterator);
   } while (0)
   );
}

static int sip_send_mwi_to_peer

(

struct sip_peer *

peer

)

[static]

Send message waiting indication to alert peer that they've got voicemail.

Definition at line 14957 of file chan_sip.c.

References __ourip, ast_app_inboxcount(), ast_set_flag, ast_sip_ouraddrfor(), build_callid_pvt(), build_via(), create_addr_from_peer(), DEFAULT_TRANS_TIMEOUT, sip_pvt::flags, sip_peer::lastmsgcheck, sip_peer::lastmsgssent, sip_peer::mailbox, sip_peer::mwipvt, sip_pvt::ourip, sip_pvt::sa, sip_alloc(), sip_destroy(), SIP_NOTIFY, SIP_OUTGOING, sip_scheddestroy(), transmit_notify_with_mwi(), and sip_peer::vmexten.

Referenced by handle_request_subscribe().

{
   /* Called with peerl lock, but releases it */
   struct sip_pvt *p;
   int newmsgs, oldmsgs;

   /* Check for messages */
   ast_app_inboxcount(peer->mailbox, &newmsgs, &oldmsgs);
   
   peer->lastmsgcheck = time(NULL);
   
   /* Return now if it's the same thing we told them last time */
   if (((newmsgs > 0x7fff ? 0x7fff0000 : (newmsgs << 16)) | (oldmsgs > 0xffff ? 0xffff : oldmsgs)) == peer->lastmsgssent) {
      return 0;
   }
   
   
   peer->lastmsgssent = ((newmsgs > 0x7fff ? 0x7fff0000 : (newmsgs << 16)) | (oldmsgs > 0xffff ? 0xffff : oldmsgs));

   if (peer->mwipvt) {
      /* Base message on subscription */
      p = peer->mwipvt;
   } else {
      /* Build temporary dialog for this message */
      if (!(p = sip_alloc(NULL, NULL, 0, SIP_NOTIFY))) 
         return -1;
      if (create_addr_from_peer(p, peer)) {
         /* Maybe they're not registered, etc. */
         sip_destroy(p);
         return 0;
      }
      /* Recalculate our side, and recalculate Call ID */
      if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
         p->ourip = __ourip;
      build_via(p);
      build_callid_pvt(p);
      /* Destroy this session after 32 secs */
      sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
   }
   /* Send MWI */
   ast_set_flag(&p->flags[0], SIP_OUTGOING);
   transmit_notify_with_mwi(p, newmsgs, oldmsgs, peer->vmexten);
   return 0;
}

static int sip_senddigit_begin	(	struct ast_channel *	ast,
		char	digit
	)			[static]

Definition at line 3597 of file chan_sip.c.

References ast_mutex_lock(), ast_mutex_unlock(), ast_rtp_senddigit_begin(), ast_test_flag, sip_pvt::flags, sip_pvt::lock, sip_pvt::rtp, SIP_DTMF, SIP_DTMF_INBAND, SIP_DTMF_RFC2833, and ast_channel::tech_pvt.

{
   struct sip_pvt *p = ast->tech_pvt;
   int res = 0;

   ast_mutex_lock(&p->lock);
   switch (ast_test_flag(&p->flags[0], SIP_DTMF)) {
   case SIP_DTMF_INBAND:
      res = -1; /* Tell Asterisk to generate inband indications */
      break;
   case SIP_DTMF_RFC2833:
      if (p->rtp)
         ast_rtp_senddigit_begin(p->rtp, digit);
      break;
   default:
      break;
   }
   ast_mutex_unlock(&p->lock);

   return res;
}

static int sip_senddigit_end	(	struct ast_channel *	ast,
		char	digit,
		unsigned int	duration
	)			[static]

Send DTMF character on SIP channel within one call, we're able to transmit in many methods simultaneously.

Definition at line 3621 of file chan_sip.c.

References ast_mutex_lock(), ast_mutex_unlock(), ast_rtp_senddigit_end(), ast_test_flag, sip_pvt::flags, sip_pvt::lock, SIP_DTMF, SIP_DTMF_INBAND, SIP_DTMF_INFO, SIP_DTMF_RFC2833, ast_channel::tech_pvt, and transmit_info_with_digit().

{
   struct sip_pvt *p = ast->tech_pvt;
   int res = 0;

   ast_mutex_lock(&p->lock);
   switch (ast_test_flag(&p->flags[0], SIP_DTMF)) {
   case SIP_DTMF_INFO:
      transmit_info_with_digit(p, digit, duration);
      break;
   case SIP_DTMF_RFC2833:
      if (p->rtp)
         ast_rtp_senddigit_end(p->rtp, digit);
      break;
   case SIP_DTMF_INBAND:
      res = -1; /* Tell Asterisk to stop inband indications */
      break;
   }
   ast_mutex_unlock(&p->lock);

   return res;
}

static int sip_sendtext	(	struct ast_channel *	ast,
		const char *	text
	)			[static]

Send SIP MESSAGE text within a call Called from PBX core sendtext() application.

Definition at line 2270 of file chan_sip.c.

References ast_strlen_zero(), ast_verbose(), debug, sip_debug_test_pvt(), ast_channel::tech_pvt, and transmit_message_with_text().

{
   struct sip_pvt *p = ast->tech_pvt;
   int debug = sip_debug_test_pvt(p);

   if (debug)
      ast_verbose("Sending text %s on %s\n", text, ast->name);
   if (!p)
      return -1;
   if (ast_strlen_zero(text))
      return 0;
   if (debug)
      ast_verbose("Really sending text %s on %s\n", text, ast->name);
   transmit_message_with_text(p, text);
   return 0;   
}

static int sip_set_rtp_peer	(	struct ast_channel *	chan,
		struct ast_rtp *	rtp,
		struct ast_rtp *	vrtp,
		int	codecs,
		int	nat_active
	)			[static]

Set the RTP peer for this call.

Definition at line 16934 of file chan_sip.c.

References ast_channel::_state, append_history, ast_inet_ntoa(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_rtp_get_peer(), ast_set_flag, AST_STATE_UP, ast_test_flag, sip_pvt::flags, sip_pvt::lastrtprx, sip_pvt::lastrtptx, sip_pvt::lock, LOG_DEBUG, sip_pvt::ourip, sip_pvt::pendinginvite, sip_pvt::redircodecs, sip_pvt::redirip, sip_pvt::rtp, SIP_ALREADYGONE, SIP_CAN_REINVITE_NAT, SIP_GOTREFER, SIP_NEEDREINVITE, SIP_NO_HISTORY, SIP_PENDINGBYE, ast_channel::tech_pvt, transmit_reinvite_with_sdp(), sip_pvt::vredirip, and sip_pvt::vrtp.

{
   struct sip_pvt *p;
   int changed = 0;

   p = chan->tech_pvt;
   if (!p) 
      return -1;

   /* Disable early RTP bridge  */
   if (chan->_state != AST_STATE_UP && !global_directrtpsetup)    /* We are in early state */
      return 0;

   ast_mutex_lock(&p->lock);
   if (ast_test_flag(&p->flags[0], SIP_ALREADYGONE)) {
      /* If we're destroyed, don't bother */
      ast_mutex_unlock(&p->lock);
      return 0;
   }

   /* if this peer cannot handle reinvites of the media stream to devices
      that are known to be behind a NAT, then stop the process now
   */
   if (nat_active && !ast_test_flag(&p->flags[0], SIP_CAN_REINVITE_NAT)) {
      ast_mutex_unlock(&p->lock);
      return 0;
   }

   if (rtp) {
      changed |= ast_rtp_get_peer(rtp, &p->redirip);
   } else if (p->redirip.sin_addr.s_addr || ntohs(p->redirip.sin_port) != 0) {
      memset(&p->redirip, 0, sizeof(p->redirip));
      changed = 1;
   }
   if (vrtp) {
      changed |= ast_rtp_get_peer(vrtp, &p->vredirip);
   } else if (p->vredirip.sin_addr.s_addr || ntohs(p->vredirip.sin_port) != 0) {
      memset(&p->vredirip, 0, sizeof(p->vredirip));
      changed = 1;
   }
   if (codecs && (p->redircodecs != codecs)) {
      p->redircodecs = codecs;
      changed = 1;
   }
   if (changed && !ast_test_flag(&p->flags[0], SIP_GOTREFER)) {
      if (chan->_state != AST_STATE_UP) { /* We are in early state */
         if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
            append_history(p, "ExtInv", "Initial invite sent with remote bridge proposal.");
         if (option_debug)
            ast_log(LOG_DEBUG, "Early remote bridge setting SIP '%s' - Sending media to %s\n", p->callid, ast_inet_ntoa(rtp ? p->redirip.sin_addr : p->ourip));
      } else if (!p->pendinginvite) {     /* We are up, and have no outstanding invite */
         if (option_debug > 2) {
            ast_log(LOG_DEBUG, "Sending reinvite on SIP '%s' - It's audio soon redirected to IP %s\n", p->callid, ast_inet_ntoa(rtp ? p->redirip.sin_addr : p->ourip));
         }
         transmit_reinvite_with_sdp(p);
      } else if (!ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
         if (option_debug > 2) {
            ast_log(LOG_DEBUG, "Deferring reinvite on SIP '%s' - It's audio will be redirected to IP %s\n", p->callid, ast_inet_ntoa(rtp ? p->redirip.sin_addr : p->ourip));
         }
         /* We have a pending Invite. Send re-invite when we're done with the invite */
         ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);   
      }
   }
   /* Reset lastrtprx timer */
   p->lastrtprx = p->lastrtptx = time(NULL);
   ast_mutex_unlock(&p->lock);
   return 0;
}

static int sip_set_udptl_peer	(	struct ast_channel *	chan,
		struct ast_udptl *	udptl
	)			[static]

Definition at line 16761 of file chan_sip.c.

References ast_inet_ntoa(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_set_flag, ast_test_flag, ast_udptl_get_peer(), sip_pvt::flags, sip_pvt::lastrtprx, sip_pvt::lastrtptx, sip_pvt::lock, LOG_DEBUG, sip_pvt::ourip, sip_pvt::pendinginvite, SIP_GOTREFER, SIP_NEEDREINVITE, SIP_PENDINGBYE, ast_channel::tech_pvt, transmit_reinvite_with_t38_sdp(), sip_pvt::udptl, and sip_pvt::udptlredirip.

{
   struct sip_pvt *p;
   
   p = chan->tech_pvt;
   if (!p)
      return -1;
   ast_mutex_lock(&p->lock);
   if (udptl)
      ast_udptl_get_peer(udptl, &p->udptlredirip);
   else
      memset(&p->udptlredirip, 0, sizeof(p->udptlredirip));
   if (!ast_test_flag(&p->flags[0], SIP_GOTREFER)) {
      if (!p->pendinginvite) {
         if (option_debug > 2) {
            ast_log(LOG_DEBUG, "Sending reinvite on SIP '%s' - It's UDPTL soon redirected to IP %s:%d\n", p->callid, ast_inet_ntoa(udptl ? p->udptlredirip.sin_addr : p->ourip), udptl ? ntohs(p->udptlredirip.sin_port) : 0);
         }
         transmit_reinvite_with_t38_sdp(p);
      } else if (!ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
         if (option_debug > 2) {
            ast_log(LOG_DEBUG, "Deferring reinvite on SIP '%s' - It's UDPTL will be redirected to IP %s:%d\n", p->callid, ast_inet_ntoa(udptl ? p->udptlredirip.sin_addr : p->ourip), udptl ? ntohs(p->udptlredirip.sin_port) : 0);
         }
         ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
      }
   }
   /* Reset lastrtprx timer */
   p->lastrtprx = p->lastrtptx = time(NULL);
   ast_mutex_unlock(&p->lock);
   return 0;
}

static int sip_show_channel	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Show details of one active dialog.

Definition at line 10637 of file chan_sip.c.

References sip_pvt::allowtransfer, ast_cli(), ast_getformatname_multiple(), ast_inet_ntoa(), ast_mutex_lock(), ast_strlen_zero(), ast_test_flag, sip_pvt::capability, dtmfmode2str(), sip_pvt::flags, sip_route::hop, iflist, sip_pvt::jointcapability, sip_pvt::lastmsg, len, sip_pvt::maxcallbitrate, nat2str(), ast_channel::nativeformats, sip_pvt::next, sip_pvt::noncodeccapability, NONE, sip_pvt::ourip, sip_pvt::owner, sip_pvt::peercapability, sip_pvt::recv, sip_pvt::redirip, RESULT_SHOWUSAGE, sip_pvt::route, sip_pvt::sa, SIP_DTMF, SIP_NAT, SIP_NEEDDESTROY, sip_options, SIP_OUTGOING, SIP_PROMISCREDIR, sip_pvt::sipoptions, sip_pvt::subscribed, subscription_type2str(), sip_pvt::tag, text, and transfermode2str().

{
   struct sip_pvt *cur;
   size_t len;
   int found = 0;

   if (argc != 4)
      return RESULT_SHOWUSAGE;
   len = strlen(argv[3]);
   ast_mutex_lock(&iflock);
   for (cur = iflist; cur; cur = cur->next) {
      if (!strncasecmp(cur->callid, argv[3], len)) {
         char formatbuf[BUFSIZ/2];
         ast_cli(fd,"\n");
         if (cur->subscribed != NONE)
            ast_cli(fd, "  * Subscription (type: %s)\n", subscription_type2str(cur->subscribed));
         else
            ast_cli(fd, "  * SIP Call\n");
         ast_cli(fd, "  Curr. trans. direction:  %s\n", ast_test_flag(&cur->flags[0], SIP_OUTGOING) ? "Outgoing" : "Incoming");
         ast_cli(fd, "  Call-ID:                %s\n", cur->callid);
         ast_cli(fd, "  Owner channel ID:       %s\n", cur->owner ? cur->owner->name : "<none>");
         ast_cli(fd, "  Our Codec Capability:   %d\n", cur->capability);
         ast_cli(fd, "  Non-Codec Capability (DTMF):   %d\n", cur->noncodeccapability);
         ast_cli(fd, "  Their Codec Capability:   %d\n", cur->peercapability);
         ast_cli(fd, "  Joint Codec Capability:   %d\n", cur->jointcapability);
         ast_cli(fd, "  Format:                 %s\n", ast_getformatname_multiple(formatbuf, sizeof(formatbuf), cur->owner ? cur->owner->nativeformats : 0) );
         ast_cli(fd, "  MaxCallBR:              %d kbps\n", cur->maxcallbitrate);
         ast_cli(fd, "  Theoretical Address:    %s:%d\n", ast_inet_ntoa(cur->sa.sin_addr), ntohs(cur->sa.sin_port));
         ast_cli(fd, "  Received Address:       %s:%d\n", ast_inet_ntoa(cur->recv.sin_addr), ntohs(cur->recv.sin_port));
         ast_cli(fd, "  SIP Transfer mode:      %s\n", transfermode2str(cur->allowtransfer));
         ast_cli(fd, "  NAT Support:            %s\n", nat2str(ast_test_flag(&cur->flags[0], SIP_NAT)));
         ast_cli(fd, "  Audio IP:               %s %s\n", ast_inet_ntoa(cur->redirip.sin_addr.s_addr ? cur->redirip.sin_addr : cur->ourip), cur->redirip.sin_addr.s_addr ? "(Outside bridge)" : "(local)" );
         ast_cli(fd, "  Our Tag:                %s\n", cur->tag);
         ast_cli(fd, "  Their Tag:              %s\n", cur->theirtag);
         ast_cli(fd, "  SIP User agent:         %s\n", cur->useragent);
         if (!ast_strlen_zero(cur->username))
            ast_cli(fd, "  Username:               %s\n", cur->username);
         if (!ast_strlen_zero(cur->peername))
            ast_cli(fd, "  Peername:               %s\n", cur->peername);
         if (!ast_strlen_zero(cur->uri))
            ast_cli(fd, "  Original uri:           %s\n", cur->uri);
         if (!ast_strlen_zero(cur->cid_num))
            ast_cli(fd, "  Caller-ID:              %s\n", cur->cid_num);
         ast_cli(fd, "  Need Destroy:           %d\n", ast_test_flag(&cur->flags[0], SIP_NEEDDESTROY));
         ast_cli(fd, "  Last Message:           %s\n", cur->lastmsg);
         ast_cli(fd, "  Promiscuous Redir:      %s\n", ast_test_flag(&cur->flags[0], SIP_PROMISCREDIR) ? "Yes" : "No");
         ast_cli(fd, "  Route:                  %s\n", cur->route ? cur->route->hop : "N/A");
         ast_cli(fd, "  DTMF Mode:              %s\n", dtmfmode2str(ast_test_flag(&cur->flags[0], SIP_DTMF)));
         ast_cli(fd, "  SIP Options:            ");
         if (cur->sipoptions) {
            int x;
            for (x=0 ; (x < (sizeof(sip_options) / sizeof(sip_options[0]))); x++) {
               if (cur->sipoptions & sip_options[x].id)
                  ast_cli(fd, "%s ", sip_options[x].text);
            }
         } else
            ast_cli(fd, "(none)\n");
         ast_cli(fd, "\n\n");
         found++;
      }
   }
   ast_mutex_unlock(&iflock);
   if (!found) 
      ast_cli(fd, "No such SIP Call ID starting with '%s'\n", argv[3]);
   return RESULT_SUCCESS;
}

static int sip_show_channels	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Show active SIP channels.

Definition at line 10435 of file chan_sip.c.

References __sip_show_channels().

{
        return __sip_show_channels(fd, argc, argv, 0);
}

static int sip_show_domains	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

CLI command to list local domains.

Definition at line 9941 of file chan_sip.c.

References ast_cli(), AST_LIST_EMPTY, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, domain::context, domain::domain, domain_mode_to_text(), FORMAT, domain::mode, RESULT_SUCCESS, and S_OR.

{
   struct domain *d;
#define FORMAT "%-40.40s %-20.20s %-16.16s\n"

   if (AST_LIST_EMPTY(&domain_list)) {
      ast_cli(fd, "SIP Domain support not enabled.\n\n");
      return RESULT_SUCCESS;
   } else {
      ast_cli(fd, FORMAT, "Our local SIP domains:", "Context", "Set by");
      AST_LIST_LOCK(&domain_list);
      AST_LIST_TRAVERSE(&domain_list, d, list)
         ast_cli(fd, FORMAT, d->domain, S_OR(d->context, "(default)"),
            domain_mode_to_text(d->mode));
      AST_LIST_UNLOCK(&domain_list);
      ast_cli(fd, "\n");
      return RESULT_SUCCESS;
   }
}

static int sip_show_history	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Show history details of one dialog.

Definition at line 10705 of file chan_sip.c.

References ast_cli(), AST_LIST_TRAVERSE, ast_mutex_lock(), sip_pvt::history, iflist, len, sip_pvt::next, NONE, RESULT_SHOWUSAGE, and sip_pvt::subscribed.

{
   struct sip_pvt *cur;
   size_t len;
   int found = 0;

   if (argc != 4)
      return RESULT_SHOWUSAGE;
   if (!recordhistory)
      ast_cli(fd, "\n***Note: History recording is currently DISABLED.  Use 'sip history' to ENABLE.\n");
   len = strlen(argv[3]);
   ast_mutex_lock(&iflock);
   for (cur = iflist; cur; cur = cur->next) {
      if (!strncasecmp(cur->callid, argv[3], len)) {
         struct sip_history *hist;
         int x = 0;

         ast_cli(fd,"\n");
         if (cur->subscribed != NONE)
            ast_cli(fd, "  * Subscription\n");
         else
            ast_cli(fd, "  * SIP Call\n");
         if (cur->history)
            AST_LIST_TRAVERSE(cur->history, hist, list)
               ast_cli(fd, "%d. %s\n", ++x, hist->event);
         if (x == 0)
            ast_cli(fd, "Call '%s' has no history\n", cur->callid);
         found++;
      }
   }
   ast_mutex_unlock(&iflock);
   if (!found) 
      ast_cli(fd, "No such SIP Call ID starting with '%s'\n", argv[3]);
   return RESULT_SUCCESS;
}

static int sip_show_inuse	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

CLI Command to show calls within limits set by call_limit.

Definition at line 9366 of file chan_sip.c.

References ast_cli(), ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_RDLOCK, ASTOBJ_UNLOCK, FALSE, FORMAT, FORMAT2, peerl, RESULT_SHOWUSAGE, RESULT_SUCCESS, TRUE, and userl.

{
#define FORMAT  "%-25.25s %-15.15s %-15.15s \n"
#define FORMAT2 "%-25.25s %-15.15s %-15.15s \n"
   char ilimits[40];
   char iused[40];
   int showall = FALSE;

   if (argc < 3) 
      return RESULT_SHOWUSAGE;

   if (argc == 4 && !strcmp(argv[3],"all")) 
         showall = TRUE;
   
   ast_cli(fd, FORMAT, "* User name", "In use", "Limit");
   ASTOBJ_CONTAINER_TRAVERSE(&userl, 1, do {
      ASTOBJ_RDLOCK(iterator);
      if (iterator->call_limit)
         snprintf(ilimits, sizeof(ilimits), "%d", iterator->call_limit);
      else 
         ast_copy_string(ilimits, "N/A", sizeof(ilimits));
      snprintf(iused, sizeof(iused), "%d", iterator->inUse);
      if (showall || iterator->call_limit)
         ast_cli(fd, FORMAT2, iterator->name, iused, ilimits);
      ASTOBJ_UNLOCK(iterator);
   } while (0) );

   ast_cli(fd, FORMAT, "* Peer name", "In use", "Limit");

   ASTOBJ_CONTAINER_TRAVERSE(&peerl, 1, do {
      ASTOBJ_RDLOCK(iterator);
      if (iterator->call_limit)
         snprintf(ilimits, sizeof(ilimits), "%d", iterator->call_limit);
      else 
         ast_copy_string(ilimits, "N/A", sizeof(ilimits));
      snprintf(iused, sizeof(iused), "%d/%d", iterator->inUse, iterator->inRinging);
      if (showall || iterator->call_limit)
         ast_cli(fd, FORMAT2, iterator->name, iused, ilimits);
      ASTOBJ_UNLOCK(iterator);
   } while (0) );

   return RESULT_SUCCESS;
#undef FORMAT
#undef FORMAT2
}

static int sip_show_objects	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

List all allocated SIP Objects (realtime or static).

Definition at line 9687 of file chan_sip.c.

References ast_cli(), ASTOBJ_CONTAINER_DUMP, peerl, regl, RESULT_SHOWUSAGE, RESULT_SUCCESS, and userl.

{
   char tmp[256];
   if (argc != 3)
      return RESULT_SHOWUSAGE;
   ast_cli(fd, "-= User objects: %d static, %d realtime =-\n\n", suserobjs, ruserobjs);
   ASTOBJ_CONTAINER_DUMP(fd, tmp, sizeof(tmp), &userl);
   ast_cli(fd, "-= Peer objects: %d static, %d realtime, %d autocreate =-\n\n", speerobjs, rpeerobjs, apeerobjs);
   ASTOBJ_CONTAINER_DUMP(fd, tmp, sizeof(tmp), &peerl);
   ast_cli(fd, "-= Registry objects: %d =-\n\n", regobjs);
   ASTOBJ_CONTAINER_DUMP(fd, tmp, sizeof(tmp), &regl);
   return RESULT_SUCCESS;
}

static int sip_show_peer	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Show one peer in detail.

Definition at line 9993 of file chan_sip.c.

References _sip_show_peer().

{
   return _sip_show_peer(0, fd, NULL, NULL, argc, (const char **) argv);
}

static int sip_show_peers	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

CLI Show Peers command.

Definition at line 9543 of file chan_sip.c.

References _sip_show_peers().

{
   return _sip_show_peers(fd, NULL, NULL, NULL, argc, (const char **) argv);
}

static int sip_show_registry	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Show SIP Registry (registrations with other SIP proxies.

Definition at line 10266 of file chan_sip.c.

References ast_cli(), ast_localtime(), ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_RDLOCK, ASTOBJ_UNLOCK, FORMAT, FORMAT2, regl, regstate2str(), RESULT_SHOWUSAGE, RESULT_SUCCESS, and STANDARD_SIP_PORT.

{
#define FORMAT2 "%-30.30s  %-12.12s  %8.8s %-20.20s %-25.25s\n"
#define FORMAT  "%-30.30s  %-12.12s  %8d %-20.20s %-25.25s\n"
   char host[80];
   char tmpdat[256];
   struct tm tm;


   if (argc != 3)
      return RESULT_SHOWUSAGE;
   ast_cli(fd, FORMAT2, "Host", "Username", "Refresh", "State", "Reg.Time");
   ASTOBJ_CONTAINER_TRAVERSE(&regl, 1, do {
      ASTOBJ_RDLOCK(iterator);
      snprintf(host, sizeof(host), "%s:%d", iterator->hostname, iterator->portno ? iterator->portno : STANDARD_SIP_PORT);
      if (iterator->regtime) {
         ast_localtime(&iterator->regtime, &tm, NULL);
         strftime(tmpdat, sizeof(tmpdat), "%a, %d %b %Y %T", &tm);
      } else {
         tmpdat[0] = 0;
      }
      ast_cli(fd, FORMAT, host, iterator->username, iterator->refresh, regstate2str(iterator->regstate), tmpdat);
      ASTOBJ_UNLOCK(iterator);
   } while(0));
   return RESULT_SUCCESS;
#undef FORMAT
#undef FORMAT2
}

static int sip_show_settings	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

List global settings for the SIP channel.

Definition at line 10296 of file chan_sip.c.

References ast_check_realtime(), ast_cli(), ast_getformatname_multiple(), ast_inet_ntoa(), AST_JB_ENABLED, AST_JB_FORCED, AST_JB_LOG, AST_LIST_EMPTY, ast_test_flag, ast_tos2str(), authl, bindaddr, default_prefs, dtmfmode2str(), global_flags, global_jbconf, ast_jb_conf::impl, ast_jb_conf::max_size, nat2str(), print_codec_to_cli(), RESULT_SHOWUSAGE, RESULT_SUCCESS, ast_jb_conf::resync_threshold, S_OR, SIP_DTMF, SIP_NAT, SIP_PAGE2_ALLOWOVERLAP, SIP_PAGE2_ALLOWSUBSCRIBE, SIP_PAGE2_IGNOREREGEXPIRE, SIP_PAGE2_RFC2833_COMPENSATE, SIP_PAGE2_RTCACHEFRIENDS, SIP_PAGE2_RTSAVE_SYSNAME, SIP_PAGE2_RTUPDATE, SIP_PAGE2_T38SUPPORT_RTP, SIP_PAGE2_T38SUPPORT_TCP, SIP_PAGE2_T38SUPPORT_UDPTL, SIP_PAGE2_VIDEOSUPPORT, SIP_PROG_INBAND, SIP_PROG_INBAND_NEVER, SIP_PROG_INBAND_NO, SIP_PROMISCREDIR, SIP_USECLIENTCODE, SIP_USEREQPHONE, and transfermode2str().

{
   int realtimepeers;
   int realtimeusers;
   char codec_buf[BUFSIZ];

   realtimepeers = ast_check_realtime("sippeers");
   realtimeusers = ast_check_realtime("sipusers");

   if (argc != 3)
      return RESULT_SHOWUSAGE;
   ast_cli(fd, "\n\nGlobal Settings:\n");
   ast_cli(fd, "----------------\n");
   ast_cli(fd, "  SIP Port:               %d\n", ntohs(bindaddr.sin_port));
   ast_cli(fd, "  Bindaddress:            %s\n", ast_inet_ntoa(bindaddr.sin_addr));
   ast_cli(fd, "  Videosupport:           %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_VIDEOSUPPORT) ? "Yes" : "No");
   ast_cli(fd, "  AutoCreatePeer:         %s\n", autocreatepeer ? "Yes" : "No");
   ast_cli(fd, "  Allow unknown access:   %s\n", global_allowguest ? "Yes" : "No");
   ast_cli(fd, "  Allow subscriptions:    %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_ALLOWSUBSCRIBE) ? "Yes" : "No");
   ast_cli(fd, "  Allow overlap dialing:  %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_ALLOWOVERLAP) ? "Yes" : "No");
   ast_cli(fd, "  Promsic. redir:         %s\n", ast_test_flag(&global_flags[0], SIP_PROMISCREDIR) ? "Yes" : "No");
   ast_cli(fd, "  SIP domain support:     %s\n", AST_LIST_EMPTY(&domain_list) ? "No" : "Yes");
   ast_cli(fd, "  Call to non-local dom.: %s\n", allow_external_domains ? "Yes" : "No");
   ast_cli(fd, "  URI user is phone no:   %s\n", ast_test_flag(&global_flags[0], SIP_USEREQPHONE) ? "Yes" : "No");
   ast_cli(fd, "  Our auth realm          %s\n", global_realm);
   ast_cli(fd, "  Realm. auth:            %s\n", authl ? "Yes": "No");
   ast_cli(fd, "  Always auth rejects:    %s\n", global_alwaysauthreject ? "Yes" : "No");
   ast_cli(fd, "  Call limit peers only:  %s\n", global_limitonpeers ? "Yes" : "No");
   ast_cli(fd, "  Direct RTP setup:       %s\n", global_directrtpsetup ? "Yes" : "No");
   ast_cli(fd, "  User Agent:             %s\n", global_useragent);
   ast_cli(fd, "  MWI checking interval:  %d secs\n", global_mwitime);
   ast_cli(fd, "  Reg. context:           %s\n", S_OR(global_regcontext, "(not set)"));
   ast_cli(fd, "  Caller ID:              %s\n", default_callerid);
   ast_cli(fd, "  From: Domain:           %s\n", default_fromdomain);
   ast_cli(fd, "  Record SIP history:     %s\n", recordhistory ? "On" : "Off");
   ast_cli(fd, "  Call Events:            %s\n", global_callevents ? "On" : "Off");
   ast_cli(fd, "  IP ToS SIP:             %s\n", ast_tos2str(global_tos_sip));
   ast_cli(fd, "  IP ToS RTP audio:       %s\n", ast_tos2str(global_tos_audio));
   ast_cli(fd, "  IP ToS RTP video:       %s\n", ast_tos2str(global_tos_video));
   ast_cli(fd, "  T38 fax pt UDPTL:       %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_T38SUPPORT_UDPTL) ? "Yes" : "No");
#ifdef WHEN_WE_HAVE_T38_FOR_OTHER_TRANSPORTS
   ast_cli(fd, "  T38 fax pt RTP:         %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_T38SUPPORT_RTP) ? "Yes" : "No");
   ast_cli(fd, "  T38 fax pt TCP:         %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_T38SUPPORT_TCP) ? "Yes" : "No");
#endif
   ast_cli(fd, "  RFC2833 Compensation:   %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_RFC2833_COMPENSATE) ? "Yes" : "No");
   ast_cli(fd, "  Jitterbuffer enabled:   %s\n", ast_test_flag(&global_jbconf, AST_JB_ENABLED) ? "Yes" : "No");
   ast_cli(fd, "  Jitterbuffer forced:    %s\n", ast_test_flag(&global_jbconf, AST_JB_FORCED) ? "Yes" : "No");
   ast_cli(fd, "  Jitterbuffer max size:  %ld\n", global_jbconf.max_size);
   ast_cli(fd, "  Jitterbuffer resync:    %ld\n", global_jbconf.resync_threshold);
   ast_cli(fd, "  Jitterbuffer impl:      %s\n", global_jbconf.impl);
   ast_cli(fd, "  Jitterbuffer log:       %s\n", ast_test_flag(&global_jbconf, AST_JB_LOG) ? "Yes" : "No");
   if (!realtimepeers && !realtimeusers)
      ast_cli(fd, "  SIP realtime:           Disabled\n" );
   else
      ast_cli(fd, "  SIP realtime:           Enabled\n" );

   ast_cli(fd, "\nGlobal Signalling Settings:\n");
   ast_cli(fd, "---------------------------\n");
   ast_cli(fd, "  Codecs:                 ");
   ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, global_capability);
   ast_cli(fd, "%s\n", codec_buf);
   ast_cli(fd, "  Codec Order:            ");
   print_codec_to_cli(fd, &default_prefs);
   ast_cli(fd, "\n");
   ast_cli(fd, "  T1 minimum:             %d\n", global_t1min);
   ast_cli(fd, "  Relax DTMF:             %s\n", global_relaxdtmf ? "Yes" : "No");
   ast_cli(fd, "  Compact SIP headers:    %s\n", compactheaders ? "Yes" : "No");
   ast_cli(fd, "  RTP Keepalive:          %d %s\n", global_rtpkeepalive, global_rtpkeepalive ? "" : "(Disabled)" );
   ast_cli(fd, "  RTP Timeout:            %d %s\n", global_rtptimeout, global_rtptimeout ? "" : "(Disabled)" );
   ast_cli(fd, "  RTP Hold Timeout:       %d %s\n", global_rtpholdtimeout, global_rtpholdtimeout ? "" : "(Disabled)");
   ast_cli(fd, "  MWI NOTIFY mime type:   %s\n", default_notifymime);
   ast_cli(fd, "  DNS SRV lookup:         %s\n", srvlookup ? "Yes" : "No");
   ast_cli(fd, "  Pedantic SIP support:   %s\n", pedanticsipchecking ? "Yes" : "No");
   ast_cli(fd, "  Reg. min duration       %d secs\n", min_expiry);
   ast_cli(fd, "  Reg. max duration:      %d secs\n", max_expiry);
   ast_cli(fd, "  Reg. default duration:  %d secs\n", default_expiry);
   ast_cli(fd, "  Outbound reg. timeout:  %d secs\n", global_reg_timeout);
   ast_cli(fd, "  Outbound reg. attempts: %d\n", global_regattempts_max);
   ast_cli(fd, "  Notify ringing state:   %s\n", global_notifyringing ? "Yes" : "No");
   ast_cli(fd, "  Notify hold state:      %s\n", global_notifyhold ? "Yes" : "No");
   ast_cli(fd, "  SIP Transfer mode:      %s\n", transfermode2str(global_allowtransfer));
   ast_cli(fd, "  Max Call Bitrate:       %d kbps\r\n", default_maxcallbitrate);
   ast_cli(fd, "  Auto-Framing:           %s \r\n", global_autoframing ? "Yes" : "No");
   ast_cli(fd, "\nDefault Settings:\n");
   ast_cli(fd, "-----------------\n");
   ast_cli(fd, "  Context:                %s\n", default_context);
   ast_cli(fd, "  Nat:                    %s\n", nat2str(ast_test_flag(&global_flags[0], SIP_NAT)));
   ast_cli(fd, "  DTMF:                   %s\n", dtmfmode2str(ast_test_flag(&global_flags[0], SIP_DTMF)));
   ast_cli(fd, "  Qualify:                %d\n", default_qualify);
   ast_cli(fd, "  Use ClientCode:         %s\n", ast_test_flag(&global_flags[0], SIP_USECLIENTCODE) ? "Yes" : "No");
   ast_cli(fd, "  Progress inband:        %s\n", (ast_test_flag(&global_flags[0], SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER) ? "Never" : (ast_test_flag(&global_flags[0], SIP_PROG_INBAND) == SIP_PROG_INBAND_NO) ? "No" : "Yes" );
   ast_cli(fd, "  Language:               %s\n", S_OR(default_language, "(Defaults to English)"));
   ast_cli(fd, "  MOH Interpret:          %s\n", default_mohinterpret);
   ast_cli(fd, "  MOH Suggest:            %s\n", default_mohsuggest);
   ast_cli(fd, "  Voice Mail Extension:   %s\n", default_vmexten);

   
   if (realtimepeers || realtimeusers) {
      ast_cli(fd, "\nRealtime SIP Settings:\n");
      ast_cli(fd, "----------------------\n");
      ast_cli(fd, "  Realtime Peers:         %s\n", realtimepeers ? "Yes" : "No");
      ast_cli(fd, "  Realtime Users:         %s\n", realtimeusers ? "Yes" : "No");
      ast_cli(fd, "  Cache Friends:          %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS) ? "Yes" : "No");
      ast_cli(fd, "  Update:                 %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_RTUPDATE) ? "Yes" : "No");
      ast_cli(fd, "  Ignore Reg. Expire:     %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_IGNOREREGEXPIRE) ? "Yes" : "No");
      ast_cli(fd, "  Save sys. name:         %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_RTSAVE_SYSNAME) ? "Yes" : "No");
      ast_cli(fd, "  Auto Clear:             %d\n", global_rtautoclear);
   }
   ast_cli(fd, "\n----\n");
   return RESULT_SUCCESS;
}

static int sip_show_subscriptions	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Show active SIP subscriptions.

Definition at line 10441 of file chan_sip.c.

References __sip_show_channels().

{
        return __sip_show_channels(fd, argc, argv, 1);
}

static int sip_show_user	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Show one user in detail.

Definition at line 10211 of file chan_sip.c.

References sip_user::accountcode, sip_user::allowtransfer, sip_user::amaflags, ast_callerid_merge(), ast_cdr_flags2str(), ast_cli(), ast_describe_caller_presentation(), ast_strlen_zero(), ASTOBJ_UNREF, sip_user::autoframing, sip_user::call_limit, sip_user::callgroup, sip_user::callingpres, sip_user::chanvars, sip_user::cid_name, sip_user::cid_num, sip_user::context, FALSE, find_user(), sip_user::ha, sip_user::language, sip_user::maxcallbitrate, sip_user::md5secret, ast_variable::name, ast_variable::next, sip_user::pickupgroup, sip_user::prefs, print_codec_to_cli(), print_group(), RESULT_SHOWUSAGE, RESULT_SUCCESS, sip_user::secret, sip_destroy_user(), transfermode2str(), TRUE, and ast_variable::value.

{
   char cbuf[256];
   struct sip_user *user;
   struct ast_variable *v;
   int load_realtime;

   if (argc < 4)
      return RESULT_SHOWUSAGE;

   /* Load from realtime storage? */
   load_realtime = (argc == 5 && !strcmp(argv[4], "load")) ? TRUE : FALSE;

   user = find_user(argv[3], load_realtime);
   if (user) {
      ast_cli(fd,"\n\n");
      ast_cli(fd, "  * Name       : %s\n", user->name);
      ast_cli(fd, "  Secret       : %s\n", ast_strlen_zero(user->secret)?"<Not set>":"<Set>");
      ast_cli(fd, "  MD5Secret    : %s\n", ast_strlen_zero(user->md5secret)?"<Not set>":"<Set>");
      ast_cli(fd, "  Context      : %s\n", user->context);
      ast_cli(fd, "  Language     : %s\n", user->language);
      if (!ast_strlen_zero(user->accountcode))
         ast_cli(fd, "  Accountcode  : %s\n", user->accountcode);
      ast_cli(fd, "  AMA flags    : %s\n", ast_cdr_flags2str(user->amaflags));
      ast_cli(fd, "  Transfer mode: %s\n", transfermode2str(user->allowtransfer));
      ast_cli(fd, "  MaxCallBR    : %d kbps\n", user->maxcallbitrate);
      ast_cli(fd, "  CallingPres  : %s\n", ast_describe_caller_presentation(user->callingpres));
      ast_cli(fd, "  Call limit   : %d\n", user->call_limit);
      ast_cli(fd, "  Callgroup    : ");
      print_group(fd, user->callgroup, 0);
      ast_cli(fd, "  Pickupgroup  : ");
      print_group(fd, user->pickupgroup, 0);
      ast_cli(fd, "  Callerid     : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), user->cid_name, user->cid_num, "<unspecified>"));
      ast_cli(fd, "  ACL          : %s\n", (user->ha?"Yes":"No"));
      ast_cli(fd, "  Codec Order  : (");
      print_codec_to_cli(fd, &user->prefs);
      ast_cli(fd, ")\n");

      ast_cli(fd, "  Auto-Framing:  %s \n", user->autoframing ? "Yes" : "No");
      if (user->chanvars) {
         ast_cli(fd, "  Variables    :\n");
         for (v = user->chanvars ; v ; v = v->next)
            ast_cli(fd, "                 %s = %s\n", v->name, v->value);
      }
      ast_cli(fd,"\n");
      ASTOBJ_UNREF(user,sip_destroy_user);
   } else {
      ast_cli(fd,"User %s not found.\n", argv[3]);
      ast_cli(fd,"\n");
   }

   return RESULT_SUCCESS;
}

static int sip_show_users	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

CLI Command 'SIP Show Users'.

Definition at line 9466 of file chan_sip.c.

References ast_cli(), ast_test_flag, ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_RDLOCK, ASTOBJ_UNLOCK, FALSE, FORMAT, nat2str(), RESULT_SHOWUSAGE, SIP_NAT, TRUE, and userl.

{
   regex_t regexbuf;
   int havepattern = FALSE;

#define FORMAT  "%-25.25s  %-15.15s  %-15.15s  %-15.15s  %-5.5s%-10.10s\n"

   switch (argc) {
   case 5:
      if (!strcasecmp(argv[3], "like")) {
         if (regcomp(&regexbuf, argv[4], REG_EXTENDED | REG_NOSUB))
            return RESULT_SHOWUSAGE;
         havepattern = TRUE;
      } else
         return RESULT_SHOWUSAGE;
   case 3:
      break;
   default:
      return RESULT_SHOWUSAGE;
   }

   ast_cli(fd, FORMAT, "Username", "Secret", "Accountcode", "Def.Context", "ACL", "NAT");
   ASTOBJ_CONTAINER_TRAVERSE(&userl, 1, do {
      ASTOBJ_RDLOCK(iterator);

      if (havepattern && regexec(&regexbuf, iterator->name, 0, NULL, 0)) {
         ASTOBJ_UNLOCK(iterator);
         continue;
      }

      ast_cli(fd, FORMAT, iterator->name, 
         iterator->secret, 
         iterator->accountcode,
         iterator->context,
         iterator->ha ? "Yes" : "No",
         nat2str(ast_test_flag(&iterator->flags[0], SIP_NAT)));
      ASTOBJ_UNLOCK(iterator);
   } while (0)
   );

   if (havepattern)
      regfree(&regexbuf);

   return RESULT_SUCCESS;
#undef FORMAT
}

static int sip_sipredirect	(	struct sip_pvt *	p,
		const char *	dest
	)			[static]

Transfer call before connect with a 302 redirect.

Note:

Called by the transfer() dialplan application through the sip_transfer() pbx interface function if the call is in ringing state

Todo:

Fix this function so that we wait for reply to the REFER and react to errors, denials or other issues the other end might have.

Definition at line 17114 of file chan_sip.c.

References ast_log(), ast_strdupa, ast_string_field_build, ast_strlen_zero(), get_header(), sip_pvt::initreq, LOG_ERROR, sip_scheddestroy(), strsep(), and transmit_response_reliable().

Referenced by sip_transfer().

{
   char *cdest;
   char *extension, *host, *port;
   char tmp[80];
   
   cdest = ast_strdupa(dest);
   
   extension = strsep(&cdest, "@");
   host = strsep(&cdest, ":");
   port = strsep(&cdest, ":");
   if (ast_strlen_zero(extension)) {
      ast_log(LOG_ERROR, "Missing mandatory argument: extension\n");
      return 0;
   }

   /* we'll issue the redirect message here */
   if (!host) {
      char *localtmp;
      ast_copy_string(tmp, get_header(&p->initreq, "To"), sizeof(tmp));
      if (ast_strlen_zero(tmp)) {
         ast_log(LOG_ERROR, "Cannot retrieve the 'To' header from the original SIP request!\n");
         return 0;
      }
      if ((localtmp = strstr(tmp, "sip:")) && (localtmp = strchr(localtmp, '@'))) {
         char lhost[80], lport[80];
         memset(lhost, 0, sizeof(lhost));
         memset(lport, 0, sizeof(lport));
         localtmp++;
         /* This is okey because lhost and lport are as big as tmp */
         sscanf(localtmp, "%[^<>:; ]:%[^<>:; ]", lhost, lport);
         if (ast_strlen_zero(lhost)) {
            ast_log(LOG_ERROR, "Can't find the host address\n");
            return 0;
         }
         host = ast_strdupa(lhost);
         if (!ast_strlen_zero(lport)) {
            port = ast_strdupa(lport);
         }
      }
   }

   ast_string_field_build(p, our_contact, "Transfer <sip:%s@%s%s%s>", extension, host, port ? ":" : "", port ? port : "");
   transmit_response_reliable(p, "302 Moved Temporarily", &p->initreq);

   sip_scheddestroy(p, 32000);   /* Make sure we stop send this reply. */

   return 0;
}

static int sip_transfer	(	struct ast_channel *	ast,
		const char *	dest
	)			[static]

Transfer SIP call.

Definition at line 3645 of file chan_sip.c.

References ast_channel::_state, ast_mutex_lock(), ast_mutex_unlock(), AST_STATE_RING, sip_pvt::lock, sip_sipredirect(), ast_channel::tech_pvt, and transmit_refer().

{
   struct sip_pvt *p = ast->tech_pvt;
   int res;

   if (dest == NULL) /* functions below do not take a NULL */
      dest = "";
   ast_mutex_lock(&p->lock);
   if (ast->_state == AST_STATE_RING)
      res = sip_sipredirect(p, dest);
   else
      res = transmit_refer(p, dest);
   ast_mutex_unlock(&p->lock);
   return res;
}

static int sip_write	(	struct ast_channel *	ast,
		struct ast_frame *	frame
	)			[static]

Send frame to media channel (rtp).

Definition at line 3478 of file chan_sip.c.

References ast_channel::_state, ast_backtrace(), AST_FORMAT_AUDIO_MASK, ast_frame_dump(), AST_FRAME_IMAGE, AST_FRAME_MODEM, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_getformatname_multiple(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_rtp_write(), ast_set_flag, AST_STATE_UP, ast_test_flag, ast_udptl_write(), sip_pvt::flags, ast_frame::frametype, sip_pvt::initreq, sip_pvt::lastrtptx, sip_pvt::lock, LOG_WARNING, ast_channel::nativeformats, ast_channel::readformat, sip_pvt::rtp, SIP_OUTGOING, SIP_PROGRESS_SENT, ast_frame::subclass, ast_channel::tech_pvt, transmit_response_with_sdp(), sip_pvt::udptl, sip_pvt::vrtp, ast_channel::writeformat, and XMIT_UNRELIABLE.

{
   struct sip_pvt *p = ast->tech_pvt;
   int res = 0;

   switch (frame->frametype) {
   case AST_FRAME_VOICE:
      if (!(frame->subclass & ast->nativeformats)) {
         char s1[512], s2[512], s3[512];
         ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %s(%d) read/write = %s(%d)/%s(%d)\n",
            frame->subclass, 
            ast_getformatname_multiple(s1, sizeof(s1) - 1, ast->nativeformats & AST_FORMAT_AUDIO_MASK),
            ast->nativeformats & AST_FORMAT_AUDIO_MASK,
            ast_getformatname_multiple(s2, sizeof(s2) - 1, ast->readformat),
            ast->readformat,
            ast_getformatname_multiple(s3, sizeof(s3) - 1, ast->writeformat),
            ast->writeformat);
         ast_frame_dump(ast->name, frame, "<<");
         ast_backtrace();
         return 0;
      }
      if (p) {
         ast_mutex_lock(&p->lock);
         if (p->rtp) {
            /* If channel is not up, activate early media session */
            if ((ast->_state != AST_STATE_UP) &&
                !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
                !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
               transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, XMIT_UNRELIABLE);
               ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);  
            }
            p->lastrtptx = time(NULL);
            res = ast_rtp_write(p->rtp, frame);
         }
         ast_mutex_unlock(&p->lock);
      }
      break;
   case AST_FRAME_VIDEO:
      if (p) {
         ast_mutex_lock(&p->lock);
         if (p->vrtp) {
            /* Activate video early media */
            if ((ast->_state != AST_STATE_UP) &&
                !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
                !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
               transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, XMIT_UNRELIABLE);
               ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);  
            }
            p->lastrtptx = time(NULL);
            res = ast_rtp_write(p->vrtp, frame);
         }
         ast_mutex_unlock(&p->lock);
      }
      break;
   case AST_FRAME_IMAGE:
      return 0;
      break;
   case AST_FRAME_MODEM:
      if (p) {
         ast_mutex_lock(&p->lock);
         /* UDPTL requires two-way communication, so early media is not needed here.
            we simply forget the frames if we get modem frames before the bridge is up.
            Fax will re-transmit.
         */
         if (p->udptl && ast->_state == AST_STATE_UP) 
            res = ast_udptl_write(p->udptl, frame);
         ast_mutex_unlock(&p->lock);
      }
      break;
   default: 
      ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
      return 0;
   }

   return res;
}

static int sipsock_read	(	int *	id,
		int	fd,
		short	events,
		void *	ignore
	)			[static]

Read data from SIP socket.

Note:

sipsock_read locks the owner channel while we are processing the SIP message

Returns:

1 on error, 0 on success

Note:

Successful messages is connected to SIP call and forwarded to handle_request()

Definition at line 14856 of file chan_sip.c.

References append_history, ast_channel_trylock, ast_channel_unlock, ast_inet_ntoa(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_set_flag, ast_test_flag, ast_update_use_count(), ast_verbose(), find_call(), find_sip_method(), sip_pvt::flags, get_header(), handle_request(), len, sip_pvt::lock, LOG_DEBUG, LOG_ERROR, LOG_NOTICE, LOG_WARNING, lws2sws(), option_debug, sip_pvt::owner, parse_request(), sip_pvt::recv, S_OR, SIP_ACK, sip_debug_test_addr(), SIP_NO_HISTORY, SIP_PKT_DEBUG, sipsock, and transmit_response().

Referenced by do_monitor().

{
   struct sip_request req;
   struct sockaddr_in sin = { 0, };
   struct sip_pvt *p;
   int res;
   socklen_t len = sizeof(sin);
   int nounlock;
   int recount = 0;
   int lockretry;

   memset(&req, 0, sizeof(req));
   res = recvfrom(sipsock, req.data, sizeof(req.data) - 1, 0, (struct sockaddr *)&sin, &len);
   if (res < 0) {
#if !defined(__FreeBSD__)
      if (errno == EAGAIN)
         ast_log(LOG_NOTICE, "SIP: Received packet with bad UDP checksum\n");
      else 
#endif
      if (errno != ECONNREFUSED)
         ast_log(LOG_WARNING, "Recv error: %s\n", strerror(errno));
      return 1;
   }
   if (option_debug && res == sizeof(req.data)) {
      ast_log(LOG_DEBUG, "Received packet exceeds buffer. Data is possibly lost\n");
      req.data[sizeof(req.data) - 1] = '\0';
   } else
      req.data[res] = '\0';
   req.len = res;
   if(sip_debug_test_addr(&sin)) /* Set the debug flag early on packet level */
      ast_set_flag(&req, SIP_PKT_DEBUG);
   if (pedanticsipchecking)
      req.len = lws2sws(req.data, req.len);  /* Fix multiline headers */
   if (ast_test_flag(&req, SIP_PKT_DEBUG))
      ast_verbose("\n<--- SIP read from %s:%d --->\n%s\n<------------->\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), req.data);

   parse_request(&req);
   req.method = find_sip_method(req.rlPart1);

   if (ast_test_flag(&req, SIP_PKT_DEBUG))
      ast_verbose("--- (%d headers %d lines)%s ---\n", req.headers, req.lines, (req.headers + req.lines == 0) ? " Nat keepalive" : "");

   if (req.headers < 2) /* Must have at least two headers */
      return 1;

   /* Process request, with netlock held, and with usual deadlock avoidance */
   for (lockretry = 100; lockretry > 0; lockretry--) {
      ast_mutex_lock(&netlock);

      /* Find the active SIP dialog or create a new one */
      p = find_call(&req, &sin, req.method); /* returns p locked */
      if (p == NULL) {
         if (option_debug)
            ast_log(LOG_DEBUG, "Invalid SIP message - rejected , no callid, len %d\n", req.len);
         ast_mutex_unlock(&netlock);
         return 1;
      }
      /* Go ahead and lock the owner if it has one -- we may need it */
      /* becaues this is deadlock-prone, we need to try and unlock if failed */
      if (!p->owner || !ast_channel_trylock(p->owner))
         break;   /* locking succeeded */
      if (option_debug)
         ast_log(LOG_DEBUG, "Failed to grab owner channel lock, trying again. (SIP call %s)\n", p->callid);
      ast_mutex_unlock(&p->lock);
      ast_mutex_unlock(&netlock);
      /* Sleep for a very short amount of time */
      usleep(1);
   }
   p->recv = sin;

   if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY)) /* This is a request or response, note what it was for */
      append_history(p, "Rx", "%s / %s / %s", req.data, get_header(&req, "CSeq"), req.rlPart2);

   if (!lockretry) {
      if (p->owner)
         ast_log(LOG_ERROR, "We could NOT get the channel lock for %s! \n", S_OR(p->owner->name, "- no channel name ??? - "));
      ast_log(LOG_ERROR, "SIP transaction failed: %s \n", p->callid);
      if (req.method != SIP_ACK)
         transmit_response(p, "503 Server error", &req); /* We must respond according to RFC 3261 sec 12.2 */
      /* XXX We could add retry-after to make sure they come back */
      append_history(p, "LockFail", "Owner lock failed, transaction failed.");
      return 1;
   }
   nounlock = 0;
   if (handle_request(p, &req, &sin, &recount, &nounlock) == -1) {
      /* Request failed */
      if (option_debug)
         ast_log(LOG_DEBUG, "SIP message could not be handled, bad request: %-70.70s\n", p->callid[0] ? p->callid : "<no callid>");
   }
      
   if (p->owner && !nounlock)
      ast_channel_unlock(p->owner);
   ast_mutex_unlock(&p->lock);
   ast_mutex_unlock(&netlock);
   if (recount)
      ast_update_use_count();

   return 1;
}

static void stop_media_flows

(

struct sip_pvt *

p

)

[static]

Immediately stop RTP, VRTP and UDPTL as applicable.

Definition at line 12192 of file chan_sip.c.

References ast_rtp_stop(), ast_udptl_stop(), sip_pvt::rtp, sip_pvt::udptl, and sip_pvt::vrtp.

Referenced by handle_request_bye(), handle_request_cancel(), and handle_response().

{
   /* Immediately stop RTP, VRTP and UDPTL as applicable */
   if (p->rtp)
      ast_rtp_stop(p->rtp);
   if (p->vrtp)
      ast_rtp_stop(p->vrtp);
   if (p->udptl)
      ast_udptl_stop(p->udptl);
}

static const char * subscription_type2str

(

enum subscriptiontype

subtype

)

[static]

Show subscription type in string format.

Definition at line 10409 of file chan_sip.c.

References subscription_types, and type.

Referenced by sip_show_channel().

{
   int i;

   for (i = 1; (i < (sizeof(subscription_types) / sizeof(subscription_types[0]))); i++) {
      if (subscription_types[i].type == subtype) {
         return subscription_types[i].text;
      }
   }
   return subscription_types[0].text;
}

static int t38_get_rate

(

int

t38cap

)

[static]

Get Max T.38 Transmission rate from T38 capabilities.

Definition at line 5981 of file chan_sip.c.

References ast_log(), LOG_DEBUG, option_debug, T38FAX_RATE_12000, T38FAX_RATE_14400, T38FAX_RATE_2400, T38FAX_RATE_4800, T38FAX_RATE_7200, and T38FAX_RATE_9600.

Referenced by add_t38_sdp().

{
   int maxrate = (t38cap & (T38FAX_RATE_14400 | T38FAX_RATE_12000 | T38FAX_RATE_9600 | T38FAX_RATE_7200 | T38FAX_RATE_4800 | T38FAX_RATE_2400));
   
   if (maxrate & T38FAX_RATE_14400) {
      if (option_debug > 1)
         ast_log(LOG_DEBUG, "T38MaxFaxRate 14400 found\n");
      return 14400;
   } else if (maxrate & T38FAX_RATE_12000) {
      if (option_debug > 1)
         ast_log(LOG_DEBUG, "T38MaxFaxRate 12000 found\n");
      return 12000;
   } else if (maxrate & T38FAX_RATE_9600) {
      if (option_debug > 1)
         ast_log(LOG_DEBUG, "T38MaxFaxRate 9600 found\n");
      return 9600;
   } else if (maxrate & T38FAX_RATE_7200) {
      if (option_debug > 1)
         ast_log(LOG_DEBUG, "T38MaxFaxRate 7200 found\n");
      return 7200;
   } else if (maxrate & T38FAX_RATE_4800) {
      if (option_debug > 1)
         ast_log(LOG_DEBUG, "T38MaxFaxRate 4800 found\n");
      return 4800;
   } else if (maxrate & T38FAX_RATE_2400) {
      if (option_debug > 1)
         ast_log(LOG_DEBUG, "T38MaxFaxRate 2400 found\n");
      return 2400;
   } else {
      if (option_debug > 1)
         ast_log(LOG_DEBUG, "Strange, T38MaxFaxRate NOT found in peers T38 SDP.\n");
      return 0;
   }
}

static struct sip_peer * temp_peer

(

const char *

name

)

[static]

Create temporary peer (used in autocreatepeer mode).

Definition at line 15924 of file chan_sip.c.

References ast_calloc, ast_set_flag, ASTOBJ_INIT, default_prefs, reg_source_db(), set_peer_defaults(), SIP_PAGE2_DYNAMIC, and SIP_PAGE2_SELFDESTRUCT.

Referenced by register_verify().

{
   struct sip_peer *peer;

   if (!(peer = ast_calloc(1, sizeof(*peer))))
      return NULL;

   apeerobjs++;
   ASTOBJ_INIT(peer);
   set_peer_defaults(peer);

   ast_copy_string(peer->name, name, sizeof(peer->name));

   ast_set_flag(&peer->flags[1], SIP_PAGE2_SELFDESTRUCT);
   ast_set_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC);
   peer->prefs = default_prefs;
   reg_source_db(peer);

   return peer;
}

static void temp_pvt_cleanup

(

void *

)

[static]

Definition at line 5760 of file chan_sip.c.

References ast_string_field_free_pools, and free.

{
   struct sip_pvt *p = data;

   ast_string_field_free_pools(p);

   free(data);
}

static char * transfermode2str

(

enum transfermodes

mode

)

const [static]

Convert transfer mode to text string.

Definition at line 9413 of file chan_sip.c.

References TRANSFER_CLOSED, and TRANSFER_OPENFORALL.

Referenced by _sip_show_peer(), sip_show_channel(), sip_show_settings(), and sip_show_user().

{
   if (mode == TRANSFER_OPENFORALL)
      return "open";
   else if (mode == TRANSFER_CLOSED)
      return "closed";
   return "strict";
}

static void transmit_fake_auth_response	(	struct sip_pvt *	p,
		struct sip_request *	req,
		int	reliable
	)			[static]

Send a fake 401 Unauthorized response when the administrator wants to hide the names of local users/peers from fishers.

Definition at line 8255 of file chan_sip.c.

References ast_random(), ast_string_field_build, and transmit_response_with_auth().

Referenced by handle_request_invite(), handle_request_subscribe(), and register_verify().

{
   ast_string_field_build(p, randdata, "%08lx", ast_random()); /* Create nonce for challenge */
   transmit_response_with_auth(p, "401 Unauthorized", req, p->randdata, reliable, "WWW-Authenticate", 0);
}

static int transmit_info_with_digit	(	struct sip_pvt *	p,
		const char	digit,
		unsigned int	duration
	)			[static]

Send SIP INFO dtmf message, see Cisco documentation on cisco.com.

Definition at line 7500 of file chan_sip.c.

References add_digit(), sip_pvt::ocseq, reqprep(), send_request(), SIP_INFO, and XMIT_RELIABLE.

Referenced by sip_senddigit_end().

{
   struct sip_request req;

   reqprep(&req, p, SIP_INFO, 0, 1);
   add_digit(&req, digit, duration);
   return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
}

static int transmit_info_with_vidupdate

(

struct sip_pvt *

p

)

[static]

Send SIP INFO with video update request.

Definition at line 7510 of file chan_sip.c.

References add_vidupdate(), sip_pvt::ocseq, reqprep(), send_request(), SIP_INFO, and XMIT_RELIABLE.

Referenced by sip_indicate().

{
   struct sip_request req;

   reqprep(&req, p, SIP_INFO, 0, 1);
   add_vidupdate(&req);
   return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
}

static int transmit_invite	(	struct sip_pvt *	p,
		int	sipmethod,
		int	sdp,
		int	init
	)			[static]

Build REFER/INVITE/OPTIONS message and transmit it.

Definition at line 6781 of file chan_sip.c.

References add_header(), add_header_contentLength(), add_sdp(), add_t38_sdp(), sip_invite_param::addsipheaders, ALLOWED_METHODS, append_date(), AST_LIST_TRAVERSE, ast_log(), ast_random(), ast_strdupa, ast_strlen_zero(), ast_udptl_offered_from_local(), ast_var_name(), ast_var_value(), sip_invite_param::auth, sip_invite_param::authheader, sip_pvt::branch, build_via(), sip_request::headers, initialize_initreq(), sip_pvt::initreq, initreqprep(), sip_pvt::lastinvite, LOG_DEBUG, LOG_WARNING, sip_request::method, sip_pvt::ocseq, option_debug, sip_pvt::options, sip_pvt::owner, sip_pvt::refer, sip_refer::refer_to, sip_refer::referred_by, sip_refer::referred_by_name, sip_invite_param::replaces, reqprep(), sip_pvt::rtp, send_request(), SIP_REFER, sipdebug, t38properties::state, SUPPORTED_EXTENSIONS, sip_pvt::t38, T38_LOCAL_DIRECT, sip_pvt::udptl, ast_channel::varshead, XMIT_CRITICAL, and XMIT_RELIABLE.

Referenced by do_proxy_auth(), sip_call(), and sip_poke_peer().

{
   struct sip_request req;
   
   req.method = sipmethod;
   if (init) {    /* Seems like init always is 2 */
      /* Bump branch even on initial requests */
      p->branch ^= ast_random();
      build_via(p);
      if (init > 1)
         initreqprep(&req, p, sipmethod);
      else
         reqprep(&req, p, sipmethod, 0, 1);
   } else
      reqprep(&req, p, sipmethod, 0, 1);
      
   if (p->options && p->options->auth)
      add_header(&req, p->options->authheader, p->options->auth);
   append_date(&req);
   if (sipmethod == SIP_REFER) { /* Call transfer */
      if (p->refer) {
         char buf[BUFSIZ];
         if (!ast_strlen_zero(p->refer->refer_to))
            add_header(&req, "Refer-To", p->refer->refer_to);
         if (!ast_strlen_zero(p->refer->referred_by)) {
            sprintf(buf, "%s <%s>", p->refer->referred_by_name, p->refer->referred_by);
            add_header(&req, "Referred-By", buf);
         }
      }
   }
   /* This new INVITE is part of an attended transfer. Make sure that the
   other end knows and replace the current call with this new call */
   if (p->options && p->options->replaces && !ast_strlen_zero(p->options->replaces)) {
      add_header(&req, "Replaces", p->options->replaces);
      add_header(&req, "Require", "replaces");
   }

   add_header(&req, "Allow", ALLOWED_METHODS);
   add_header(&req, "Supported", SUPPORTED_EXTENSIONS);
   if (p->options && p->options->addsipheaders && p->owner) {
      struct ast_channel *ast = p->owner; /* The owner channel */
      struct varshead *headp = &ast->varshead;

         if (!headp)
            ast_log(LOG_WARNING,"No Headp for the channel...ooops!\n");
         else {
            const struct ast_var_t *current;
            AST_LIST_TRAVERSE(headp, current, entries) {  
               /* SIPADDHEADER: Add SIP header to outgoing call */
               if (!strncasecmp(ast_var_name(current), "SIPADDHEADER", strlen("SIPADDHEADER"))) {
                  char *content, *end;
                  const char *header = ast_var_value(current);
                  char *headdup = ast_strdupa(header);

                  /* Strip of the starting " (if it's there) */
                  if (*headdup == '"')
                     headdup++;
                  if ((content = strchr(headdup, ':'))) {
                     *content++ = '\0';
                     content = ast_skip_blanks(content); /* Skip white space */
                     /* Strip the ending " (if it's there) */
                     end = content + strlen(content) -1; 
                     if (*end == '"')
                        *end = '\0';
                  
                     add_header(&req, headdup, content);
                     if (sipdebug)
                        ast_log(LOG_DEBUG, "Adding SIP Header \"%s\" with content :%s: \n", headdup, content);
                  }
               }
            }
         }
   }
   if (sdp) {
      if (p->udptl && p->t38.state == T38_LOCAL_DIRECT) {
         ast_udptl_offered_from_local(p->udptl, 1);
         if (option_debug)
            ast_log(LOG_DEBUG, "T38 is in state %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
         add_t38_sdp(&req, p);
      } else if (p->rtp) 
         add_sdp(&req, p);
   } else {
      add_header_contentLength(&req, 0);
   }

   if (!p->initreq.headers)
      initialize_initreq(p, &req);
   p->lastinvite = p->ocseq;
   return send_request(p, &req, init ? XMIT_CRITICAL : XMIT_RELIABLE, p->ocseq);
}

static int transmit_message_with_text	(	struct sip_pvt *	p,
		const char *	text
	)			[static]

Transmit text with SIP MESSAGE method.

Definition at line 7408 of file chan_sip.c.

References add_text(), sip_pvt::ocseq, reqprep(), send_request(), SIP_MESSAGE, and XMIT_RELIABLE.

Referenced by sip_park_thread(), and sip_sendtext().

{
   struct sip_request req;

   reqprep(&req, p, SIP_MESSAGE, 0, 1);
   add_text(&req, text);
   return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
}

static int transmit_notify_with_mwi	(	struct sip_pvt *	p,
		int	newmsgs,
		int	oldmsgs,
		char *	vmexten
	)			[static]

Notify user of messages waiting in voicemail.

Note:

- Notification only works for registered peers with mailbox= definitions in sip.conf

• We use the SIP Event package message-summary MIME type defaults to "application/simple-message-summary";

Definition at line 7048 of file chan_sip.c.

References add_header(), add_header_contentLength(), add_line(), ast_build_string(), ast_inet_ntoa(), ast_log(), ast_test_flag, sip_pvt::expiry, sip_pvt::flags, sip_request::headers, initialize_initreq(), sip_pvt::initreq, initreqprep(), LOG_WARNING, sip_pvt::ocseq, sip_pvt::ourip, S_OR, send_request(), SIP_NOTIFY, SIP_PAGE2_BUGGY_MWI, sip_pvt::subscribed, t, and XMIT_RELIABLE.

Referenced by sip_send_mwi_to_peer().

{
   struct sip_request req;
   char tmp[500];
   char *t = tmp;
   size_t maxbytes = sizeof(tmp);

   initreqprep(&req, p, SIP_NOTIFY);
   add_header(&req, "Event", "message-summary");
   add_header(&req, "Content-Type", default_notifymime);

   ast_build_string(&t, &maxbytes, "Messages-Waiting: %s\r\n", newmsgs ? "yes" : "no");
   ast_build_string(&t, &maxbytes, "Message-Account: sip:%s@%s\r\n",
      S_OR(vmexten, default_vmexten), S_OR(p->fromdomain, ast_inet_ntoa(p->ourip)));
   /* Cisco has a bug in the SIP stack where it can't accept the
      (0/0) notification. This can temporarily be disabled in
      sip.conf with the "buggymwi" option */
   ast_build_string(&t, &maxbytes, "Voice-Message: %d/%d%s\r\n", newmsgs, oldmsgs, (ast_test_flag(&p->flags[1], SIP_PAGE2_BUGGY_MWI) ? "" : " (0/0)"));

   if (p->subscribed) {
      if (p->expiry)
         add_header(&req, "Subscription-State", "active");
      else  /* Expired */
         add_header(&req, "Subscription-State", "terminated;reason=timeout");
   }

   if (t > tmp + sizeof(tmp))
      ast_log(LOG_WARNING, "Buffer overflow detected!!  (Please file a bug report)\n");

   add_header_contentLength(&req, strlen(tmp));
   add_line(&req, tmp);

   if (!p->initreq.headers) 
      initialize_initreq(p, &req);
   return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
}

static int transmit_notify_with_sipfrag	(	struct sip_pvt *	p,
		int	cseq,
		char *	message,
		int	terminate
	)			[static]

Notify a transferring party of the status of transfer.

Definition at line 7094 of file chan_sip.c.

References add_header(), add_header_contentLength(), add_line(), ALLOWED_METHODS, sip_request::headers, initialize_initreq(), sip_pvt::initreq, sip_pvt::ocseq, reqprep(), send_request(), SIP_NOTIFY, SUPPORTED_EXTENSIONS, and XMIT_RELIABLE.

Referenced by handle_request_refer(), local_attended_transfer(), and sip_park_thread().

{
   struct sip_request req;
   char tmp[BUFSIZ/2];

   reqprep(&req, p, SIP_NOTIFY, 0, 1);
   snprintf(tmp, sizeof(tmp), "refer;id=%d", cseq);
   add_header(&req, "Event", tmp);
   add_header(&req, "Subscription-state", terminate ? "terminated;reason=noresource" : "active");
   add_header(&req, "Content-Type", "message/sipfrag;version=2.0");
   add_header(&req, "Allow", ALLOWED_METHODS);
   add_header(&req, "Supported", SUPPORTED_EXTENSIONS);

   snprintf(tmp, sizeof(tmp), "SIP/2.0 %s\r\n", message);
   add_header_contentLength(&req, strlen(tmp));
   add_line(&req, tmp);

   if (!p->initreq.headers)
      initialize_initreq(p, &req);

   return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
}

static int transmit_refer	(	struct sip_pvt *	p,
		const char *	dest
	)			[static]

Transmit SIP REFER message (initiated by the transfer() dialplan application.

Note:

this is currently broken as we have no way of telling the dialplan engine whether a transfer succeeds or fails.

Todo:

Fix the transfer() dialplan function so that a transfer may fail

Todo:

In theory, we should hang around and wait for a reply, before returning to the dial plan here. Don't know really how that would affect the transfer() app or the pbx, but, well, to make this useful we should have a STATUS code on transfer().

Definition at line 7429 of file chan_sip.c.

References add_header(), ALLOWED_METHODS, ast_log(), ast_strdupa, ast_string_field_set, ast_strlen_zero(), ast_test_flag, DEFAULT_MAX_FORWARDS, sip_pvt::flags, get_header(), get_in_brackets(), sip_request::headers, sip_pvt::initreq, LOG_DEBUG, LOG_NOTICE, sip_pvt::ocseq, option_debug, sip_pvt::refer, REFER_SENT, sip_refer::refer_to, sip_refer::referred_by, reqprep(), send_request(), SIP_OUTGOING, SIP_REFER, sip_refer_allocate(), sipdebug, sip_refer::status, SUPPORTED_EXTENSIONS, sip_pvt::tag, and XMIT_RELIABLE.

Referenced by sip_transfer().

{
   struct sip_request req = { 
      .headers = 0,  
   };
   char from[256];
   const char *of;
   char *c;
   char referto[256];
   char *ttag, *ftag;
   char *theirtag = ast_strdupa(p->theirtag);

   if (option_debug || sipdebug)
      ast_log(LOG_DEBUG, "SIP transfer of %s to %s\n", p->callid, dest);

   /* Are we transfering an inbound or outbound call ? */
   if (ast_test_flag(&p->flags[0], SIP_OUTGOING))  {
      of = get_header(&p->initreq, "To");
      ttag = theirtag;
      ftag = p->tag;
   } else {
      of = get_header(&p->initreq, "From");
      ftag = theirtag;
      ttag = p->tag;
   }

   ast_copy_string(from, of, sizeof(from));
   of = get_in_brackets(from);
   ast_string_field_set(p, from, of);
   if (strncmp(of, "sip:", 4))
      ast_log(LOG_NOTICE, "From address missing 'sip:', using it anyway\n");
   else
      of += 4;
   /* Get just the username part */
   if ((c = strchr(dest, '@')))
      c = NULL;
   else if ((c = strchr(of, '@')))
      *c++ = '\0';
   if (c) 
      snprintf(referto, sizeof(referto), "<sip:%s@%s>", dest, c);
   else
      snprintf(referto, sizeof(referto), "<sip:%s>", dest);

   /* save in case we get 407 challenge */
   sip_refer_allocate(p);
   ast_copy_string(p->refer->refer_to, referto, sizeof(p->refer->refer_to));
   ast_copy_string(p->refer->referred_by, p->our_contact, sizeof(p->refer->referred_by));
   p->refer->status = REFER_SENT;   /* Set refer status */

   reqprep(&req, p, SIP_REFER, 0, 1);
   add_header(&req, "Max-Forwards", DEFAULT_MAX_FORWARDS);

   add_header(&req, "Refer-To", referto);
   add_header(&req, "Allow", ALLOWED_METHODS);
   add_header(&req, "Supported", SUPPORTED_EXTENSIONS);
   if (!ast_strlen_zero(p->our_contact))
      add_header(&req, "Referred-By", p->our_contact);

   return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
   /* We should propably wait for a NOTIFY here until we ack the transfer */
   /* Maybe fork a new thread and wait for a STATUS of REFER_200OK on the refer status before returning to app_transfer */

   /*! \todo In theory, we should hang around and wait for a reply, before
   returning to the dial plan here. Don't know really how that would
   affect the transfer() app or the pbx, but, well, to make this
   useful we should have a STATUS code on transfer().
   */
}

static int transmit_register	(	struct sip_registry *	r,
		int	sipmethod,
		const char *	auth,
		const char *	authheader
	)			[static]

Transmit register to SIP proxy or UA.

Definition at line 7217 of file chan_sip.c.

References __ourip, add_header(), add_header_contentLength(), append_history, ast_log(), ast_random(), ast_sched_add(), ast_sched_del(), ast_set_flag, ast_sip_ouraddrfor(), ast_string_field_free, ast_string_field_set, ast_strlen_zero(), ast_test_flag, ast_verbose(), ASTOBJ_REF, bindaddr, sip_pvt::branch, build_callid_registry(), build_contact(), build_reply_digest(), build_via(), sip_registry::call, sip_registry::callid_valid, create_addr(), DEFAULT_MAX_FORWARDS, exten, sip_pvt::flags, sip_request::headers, init_req(), initialize_initreq(), sip_pvt::initreq, sip_request::lines, LOG_DEBUG, LOG_NOTICE, LOG_WARNING, make_our_tag(), sip_pvt::noncecount, sip_registry::noncecount, sip_pvt::ocseq, sip_registry::ocseq, option_debug, sip_registry::portno, REG_STATE_AUTHSENT, REG_STATE_REGSENT, sip_registry::regattempts, sip_pvt::registry, sip_registry::regstate, sched, send_request(), sip_alloc(), sip_debug_test_pvt(), sip_destroy(), sip_methods, SIP_NO_HISTORY, SIP_OUTGOING, sip_reg_timeout(), SIP_REGISTER, sipdebug, STANDARD_SIP_PORT, sip_pvt::tag, cfsip_methods::text, sip_registry::timeout, TRUE, username, and XMIT_CRITICAL.

Referenced by __sip_do_register(), do_register_auth(), and sip_reg_timeout().

{
   struct sip_request req;
   char from[256];
   char to[256];
   char tmp[80];
   char addr[80];
   struct sip_pvt *p;

   /* exit if we are already in process with this registrar ?*/
   if ( r == NULL || ((auth==NULL) && (r->regstate==REG_STATE_REGSENT || r->regstate==REG_STATE_AUTHSENT))) {
      ast_log(LOG_NOTICE, "Strange, trying to register %s@%s when registration already pending\n", r->username, r->hostname);
      return 0;
   }

   if (r->call) { /* We have a registration */
      if (!auth) {
         ast_log(LOG_WARNING, "Already have a REGISTER going on to %s@%s?? \n", r->username, r->hostname);
         return 0;
      } else {
         p = r->call;
         make_our_tag(p->tag, sizeof(p->tag));  /* create a new local tag for every register attempt */
         ast_string_field_free(p, theirtag); /* forget their old tag, so we don't match tags when getting response */
      }
   } else {
      /* Build callid for registration if we haven't registered before */
      if (!r->callid_valid) {
         build_callid_registry(r, __ourip, default_fromdomain);
         r->callid_valid = TRUE;
      }
      /* Allocate SIP packet for registration */
      if (!(p = sip_alloc( r->callid, NULL, 0, SIP_REGISTER))) {
         ast_log(LOG_WARNING, "Unable to allocate registration transaction (memory or socket error)\n");
         return 0;
      }
      if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
         append_history(p, "RegistryInit", "Account: %s@%s", r->username, r->hostname);
      /* Find address to hostname */
      if (create_addr(p, r->hostname)) {
         /* we have what we hope is a temporary network error,
          * probably DNS.  We need to reschedule a registration try */
         sip_destroy(p);
         if (r->timeout > -1) {
            ast_sched_del(sched, r->timeout);
            r->timeout = ast_sched_add(sched, global_reg_timeout*1000, sip_reg_timeout, r);
            ast_log(LOG_WARNING, "Still have a registration timeout for %s@%s (create_addr() error), %d\n", r->username, r->hostname, r->timeout);
         } else {
            r->timeout = ast_sched_add(sched, global_reg_timeout*1000, sip_reg_timeout, r);
            ast_log(LOG_WARNING, "Probably a DNS error for registration to %s@%s, trying REGISTER again (after %d seconds)\n", r->username, r->hostname, global_reg_timeout);
         }
         r->regattempts++;
         return 0;
      }
      /* Copy back Call-ID in case create_addr changed it */
      ast_string_field_set(r, callid, p->callid);
      if (r->portno)
         p->sa.sin_port = htons(r->portno);
      else  /* Set registry port to the port set from the peer definition/srv or default */
         r->portno = ntohs(p->sa.sin_port);
      ast_set_flag(&p->flags[0], SIP_OUTGOING); /* Registration is outgoing call */
      r->call=p;        /* Save pointer to SIP packet */
      p->registry = ASTOBJ_REF(r);  /* Add pointer to registry in packet */
      if (!ast_strlen_zero(r->secret)) /* Secret (password) */
         ast_string_field_set(p, peersecret, r->secret);
      if (!ast_strlen_zero(r->md5secret))
         ast_string_field_set(p, peermd5secret, r->md5secret);
      /* User name in this realm  
      - if authuser is set, use that, otherwise use username */
      if (!ast_strlen_zero(r->authuser)) {   
         ast_string_field_set(p, peername, r->authuser);
         ast_string_field_set(p, authname, r->authuser);
      } else if (!ast_strlen_zero(r->username)) {
         ast_string_field_set(p, peername, r->username);
         ast_string_field_set(p, authname, r->username);
         ast_string_field_set(p, fromuser, r->username);
      }
      if (!ast_strlen_zero(r->username))
         ast_string_field_set(p, username, r->username);
      /* Save extension in packet */
      ast_string_field_set(p, exten, r->contact);

      /*
        check which address we should use in our contact header 
        based on whether the remote host is on the external or
        internal network so we can register through nat
       */
      if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
         p->ourip = bindaddr.sin_addr;
      build_contact(p);
   }

   /* set up a timeout */
   if (auth == NULL)  {
      if (r->timeout > -1) {
         ast_log(LOG_WARNING, "Still have a registration timeout, #%d - deleting it\n", r->timeout);
         ast_sched_del(sched, r->timeout);
      }
      r->timeout = ast_sched_add(sched, global_reg_timeout * 1000, sip_reg_timeout, r);
      if (option_debug)
         ast_log(LOG_DEBUG, "Scheduled a registration timeout for %s id  #%d \n", r->hostname, r->timeout);
   }

   if (strchr(r->username, '@')) {
      snprintf(from, sizeof(from), "<sip:%s>;tag=%s", r->username, p->tag);
      if (!ast_strlen_zero(p->theirtag))
         snprintf(to, sizeof(to), "<sip:%s>;tag=%s", r->username, p->theirtag);
      else
         snprintf(to, sizeof(to), "<sip:%s>", r->username);
   } else {
      snprintf(from, sizeof(from), "<sip:%s@%s>;tag=%s", r->username, p->tohost, p->tag);
      if (!ast_strlen_zero(p->theirtag))
         snprintf(to, sizeof(to), "<sip:%s@%s>;tag=%s", r->username, p->tohost, p->theirtag);
      else
         snprintf(to, sizeof(to), "<sip:%s@%s>", r->username, p->tohost);
   }
   
   /* Fromdomain is what we are registering to, regardless of actual
      host name from SRV */
   if (!ast_strlen_zero(p->fromdomain)) {
      if (r->portno && r->portno != STANDARD_SIP_PORT)
         snprintf(addr, sizeof(addr), "sip:%s:%d", p->fromdomain, r->portno);
      else
         snprintf(addr, sizeof(addr), "sip:%s", p->fromdomain);
   } else {
      if (r->portno && r->portno != STANDARD_SIP_PORT)
         snprintf(addr, sizeof(addr), "sip:%s:%d", r->hostname, r->portno);
      else
         snprintf(addr, sizeof(addr), "sip:%s", r->hostname);
   }
   ast_string_field_set(p, uri, addr);

   p->branch ^= ast_random();

   init_req(&req, sipmethod, addr);

   /* Add to CSEQ */
   snprintf(tmp, sizeof(tmp), "%u %s", ++r->ocseq, sip_methods[sipmethod].text);
   p->ocseq = r->ocseq;

   build_via(p);
   add_header(&req, "Via", p->via);
   add_header(&req, "From", from);
   add_header(&req, "To", to);
   add_header(&req, "Call-ID", p->callid);
   add_header(&req, "CSeq", tmp);
   if (!ast_strlen_zero(global_useragent))
      add_header(&req, "User-Agent", global_useragent);
   add_header(&req, "Max-Forwards", DEFAULT_MAX_FORWARDS);

   
   if (auth)   /* Add auth header */
      add_header(&req, authheader, auth);
   else if (!ast_strlen_zero(r->nonce)) {
      char digest[1024];

      /* We have auth data to reuse, build a digest header! */
      if (sipdebug)
         ast_log(LOG_DEBUG, "   >>> Re-using Auth data for %s@%s\n", r->username, r->hostname);
      ast_string_field_set(p, realm, r->realm);
      ast_string_field_set(p, nonce, r->nonce);
      ast_string_field_set(p, domain, r->domain);
      ast_string_field_set(p, opaque, r->opaque);
      ast_string_field_set(p, qop, r->qop);
      r->noncecount++;
      p->noncecount = r->noncecount;

      memset(digest,0,sizeof(digest));
      if(!build_reply_digest(p, sipmethod, digest, sizeof(digest)))
         add_header(&req, "Authorization", digest);
      else
         ast_log(LOG_NOTICE, "No authorization available for authentication of registration to %s@%s\n", r->username, r->hostname);
   
   }

   snprintf(tmp, sizeof(tmp), "%d", default_expiry);
   add_header(&req, "Expires", tmp);
   add_header(&req, "Contact", p->our_contact);
   add_header(&req, "Event", "registration");
   add_header_contentLength(&req, 0);

   initialize_initreq(p, &req);
   if (sip_debug_test_pvt(p))
      ast_verbose("REGISTER %d headers, %d lines\n", p->initreq.headers, p->initreq.lines);
   r->regstate = auth ? REG_STATE_AUTHSENT : REG_STATE_REGSENT;
   r->regattempts++; /* Another attempt */
   if (option_debug > 3)
      ast_verbose("REGISTER attempt %d to %s@%s\n", r->regattempts, r->username, r->hostname);
   return send_request(p, &req, XMIT_CRITICAL, p->ocseq);
}

static int transmit_reinvite_with_sdp

(

struct sip_pvt *

p

)

[static]

Transmit reinvite with SDP.

Note:

A re-invite is basically a new INVITE with the same CALL-ID and TAG as the INVITE that opened the SIP dialogue We reinvite so that the audio stream (RTP) go directly between the SIP UAs. SIP Signalling stays with * in the path.

Definition at line 6501 of file chan_sip.c.

References add_header(), add_sdp(), ALLOWED_METHODS, append_history, ast_set_flag, ast_test_flag, sip_pvt::flags, initialize_initreq(), reqprep(), send_request(), SIP_INVITE, SIP_NO_HISTORY, SIP_OUTGOING, SIP_REINVITE_UPDATE, SIP_UPDATE, sipdebug, SUPPORTED_EXTENSIONS, and XMIT_CRITICAL.

Referenced by check_pendings(), and sip_set_rtp_peer().

{
   struct sip_request req;

   reqprep(&req, p, ast_test_flag(&p->flags[0], SIP_REINVITE_UPDATE) ?  SIP_UPDATE : SIP_INVITE, 0, 1);
   
   add_header(&req, "Allow", ALLOWED_METHODS);
   add_header(&req, "Supported", SUPPORTED_EXTENSIONS);
   if (sipdebug)
      add_header(&req, "X-asterisk-Info", "SIP re-invite (External RTP bridge)");
   if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
      append_history(p, "ReInv", "Re-invite sent");
   add_sdp(&req, p);
   /* Use this as the basis */
   initialize_initreq(p, &req);
   p->lastinvite = p->ocseq;
   ast_set_flag(&p->flags[0], SIP_OUTGOING);    /* Change direction of this dialog */
   return send_request(p, &req, XMIT_CRITICAL, p->ocseq);
}

static int transmit_reinvite_with_t38_sdp

(

struct sip_pvt *

p

)

[static]

Transmit reinvite with T38 SDP We reinvite so that the T38 processing can take place. SIP Signalling stays with * in the path.

Definition at line 6525 of file chan_sip.c.

References add_header(), add_t38_sdp(), ALLOWED_METHODS, ast_set_flag, ast_test_flag, ast_udptl_offered_from_local(), sip_pvt::flags, initialize_initreq(), sip_pvt::lastinvite, sip_pvt::ocseq, reqprep(), send_request(), SIP_INVITE, SIP_OUTGOING, SIP_REINVITE_UPDATE, SIP_UPDATE, sipdebug, SUPPORTED_EXTENSIONS, sip_pvt::udptl, and XMIT_CRITICAL.

Referenced by sip_handle_t38_reinvite(), sip_read(), and sip_set_udptl_peer().

{
   struct sip_request req;

   reqprep(&req, p, ast_test_flag(&p->flags[0], SIP_REINVITE_UPDATE) ?  SIP_UPDATE : SIP_INVITE, 0, 1);
   
   add_header(&req, "Allow", ALLOWED_METHODS);
   add_header(&req, "Supported", SUPPORTED_EXTENSIONS);
   if (sipdebug)
      add_header(&req, "X-asterisk-info", "SIP re-invite (T38 switchover)");
   ast_udptl_offered_from_local(p->udptl, 1);
   add_t38_sdp(&req, p);
   /* Use this as the basis */
   initialize_initreq(p, &req);
   ast_set_flag(&p->flags[0], SIP_OUTGOING);    /* Change direction of this dialog */
   p->lastinvite = p->ocseq;
   return send_request(p, &req, XMIT_CRITICAL, p->ocseq);
}

static int transmit_request	(	struct sip_pvt *	p,
		int	sipmethod,
		int	inc,
		enum xmittype	reliable,
		int	newbranch
	)			[static]

Transmit generic SIP request.

Definition at line 7520 of file chan_sip.c.

References add_header_contentLength(), INV_CONFIRMED, sip_pvt::invitestate, sip_pvt::ocseq, reqprep(), send_request(), and SIP_ACK.

Referenced by check_pendings(), handle_response(), handle_response_invite(), and sip_hangup().

{
   struct sip_request resp;

   if (sipmethod == SIP_ACK)
      p->invitestate = INV_CONFIRMED;

   reqprep(&resp, p, sipmethod, seqno, newbranch);
   add_header_contentLength(&resp, 0);
   return send_request(p, &resp, reliable, seqno ? seqno : p->ocseq);
}

static int transmit_request_with_auth	(	struct sip_pvt *	p,
		int	sipmethod,
		int	seqno,
		enum xmittype	reliable,
		int	newbranch
	)			[static]

Transmit SIP request, auth added.

Definition at line 7533 of file chan_sip.c.

References add_header(), add_header_contentLength(), ast_cause2str(), ast_log(), ast_strlen_zero(), sip_invite_param::auth_type, build_reply_digest(), ast_channel::hangupcause, LOG_WARNING, sip_pvt::ocseq, sip_pvt::options, sip_pvt::owner, PROXY_AUTH, reqprep(), send_request(), SIP_BYE, and WWW_AUTH.

Referenced by __sip_autodestruct(), check_pendings(), and sip_hangup().

{
   struct sip_request resp;

   reqprep(&resp, p, sipmethod, seqno, newbranch);
   if (!ast_strlen_zero(p->realm)) {
      char digest[1024];

      memset(digest, 0, sizeof(digest));
      if(!build_reply_digest(p, sipmethod, digest, sizeof(digest))) {
         if (p->options && p->options->auth_type == PROXY_AUTH)
            add_header(&resp, "Proxy-Authorization", digest);
         else if (p->options && p->options->auth_type == WWW_AUTH)
            add_header(&resp, "Authorization", digest);
         else  /* Default, to be backwards compatible (maybe being too careful, but leaving it for now) */
            add_header(&resp, "Proxy-Authorization", digest);
      } else
         ast_log(LOG_WARNING, "No authentication available for call %s\n", p->callid);
   }
   /* If we are hanging up and know a cause for that, send it in clear text to make
      debugging easier. */
   if (sipmethod == SIP_BYE && 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);
   }

   add_header_contentLength(&resp, 0);
   return send_request(p, &resp, reliable, seqno ? seqno : p->ocseq);   
}

static int transmit_response	(	struct sip_pvt *	p,
		const char *	msg,
		const struct sip_request *	req
	)			[static]

Transmit response, no retransmits.

Definition at line 5820 of file chan_sip.c.

References __transmit_response(), and XMIT_UNRELIABLE.

{
   return __transmit_response(p, msg, req, XMIT_UNRELIABLE);
}

static int transmit_response_reliable	(	struct sip_pvt *	p,
		const char *	msg,
		const struct sip_request *	req
	)			[static]

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.

Definition at line 5839 of file chan_sip.c.

References __transmit_response(), and XMIT_CRITICAL.

Referenced by handle_invite_replaces(), handle_request(), handle_request_bye(), handle_request_cancel(), handle_request_invite(), handle_request_subscribe(), sip_hangup(), and sip_sipredirect().

{
   return __transmit_response(p, msg, req, XMIT_CRITICAL);
}

static int transmit_response_using_temp	(	ast_string_field	callid,
		struct sockaddr_in *	sin,
		int	useglobal_nat,
		const int	intended_method,
		const struct sip_request *	req,
		const char *	msg
	)			[static]

Transmit response, no retransmits, using a temporary pvt structure.

Definition at line 5770 of file chan_sip.c.

References __ourip, __transmit_response(), ast_copy_flags, ast_log(), ast_random(), ast_set_flag, ast_sip_ouraddrfor(), ast_string_field_free_all, ast_string_field_init, ast_string_field_set, ast_test_flag, build_via(), do_setnat(), global_flags, INITIAL_CSEQ, LOG_NOTICE, make_our_tag(), SIP_NAT, SIP_NAT_ROUTE, SIP_NO_HISTORY, and XMIT_UNRELIABLE.

{
   struct sip_pvt *p = NULL;

   if (!(p = ast_threadstorage_get(&ts_temp_pvt, sizeof(*p)))) {
      ast_log(LOG_NOTICE, "Failed to get temporary pvt\n");
      return -1;
   }

   /* if the structure was just allocated, initialize it */
   if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY)) {
      ast_set_flag(&p->flags[0], SIP_NO_HISTORY);
      if (ast_string_field_init(p, 512))
         return -1;
   }

   /* Initialize the bare minimum */
   p->method = intended_method;

   if (sin) {
      p->sa = *sin;
      if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
         p->ourip = __ourip;
   } else
      p->ourip = __ourip;

   p->branch = ast_random();
   make_our_tag(p->tag, sizeof(p->tag));
   p->ocseq = INITIAL_CSEQ;

   if (useglobal_nat && sin) {
      ast_copy_flags(&p->flags[0], &global_flags[0], SIP_NAT);
      p->recv = *sin;
      do_setnat(p, ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE);
   }

   ast_string_field_set(p, fromdomain, default_fromdomain);
   build_via(p);
   ast_string_field_set(p, callid, callid);

   /* Use this temporary pvt structure to send the message */
   __transmit_response(p, msg, req, XMIT_UNRELIABLE);

   /* Free the string fields, but not the pool space */
   ast_string_field_free_all(p);

   return 0;
}

static int transmit_response_with_allow	(	struct sip_pvt *	p,
		const char *	msg,
		const struct sip_request *	req,
		enum xmittype	reliable
	)			[static]

Append Accept header, content length before transmitting response.

Definition at line 5867 of file chan_sip.c.

References add_header(), add_header_contentLength(), respprep(), and send_response().

Referenced by handle_request(), and handle_request_options().

{
   struct sip_request resp;
   respprep(&resp, p, msg, req);
   add_header(&resp, "Accept", "application/sdp");
   add_header_contentLength(&resp, 0);
   return send_response(p, &resp, reliable, 0);
}

static int transmit_response_with_auth	(	struct sip_pvt *	p,
		const char *	msg,
		const struct sip_request *	req,
		const char *	rand,
		enum xmittype	reliable,
		const char *	header,
		int	stale
	)			[static]

Respond with authorization request.

Definition at line 5877 of file chan_sip.c.

References add_header(), add_header_contentLength(), append_history, ast_log(), get_header(), LOG_WARNING, sip_pvt::noncecount, respprep(), and send_response().

Referenced by check_auth(), and transmit_fake_auth_response().

{
   struct sip_request resp;
   char tmp[512];
   int seqno = 0;

   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;
   }
   /* Stale means that they sent us correct authentication, but 
      based it on an old challenge (nonce) */
   snprintf(tmp, sizeof(tmp), "Digest algorithm=MD5, realm=\"%s\", nonce=\"%s\"%s", global_realm, randdata, stale ? ", stale=true" : "");
   respprep(&resp, p, msg, req);
   add_header(&resp, header, tmp);
   add_header_contentLength(&resp, 0);
   append_history(p, "AuthChal", "Auth challenge sent for %s - nc %d", p->username, p->noncecount);
   return send_response(p, &resp, reliable, seqno);
}

static int transmit_response_with_date	(	struct sip_pvt *	p,
		const char *	msg,
		const struct sip_request *	req
	)			[static]

Append date and content length before transmitting response.

Definition at line 5857 of file chan_sip.c.

References add_header_contentLength(), append_date(), respprep(), send_response(), and XMIT_UNRELIABLE.

Referenced by register_verify().

{
   struct sip_request resp;
   respprep(&resp, p, msg, req);
   append_date(&resp);
   add_header_contentLength(&resp, 0);
   return send_response(p, &resp, XMIT_UNRELIABLE, 0);
}

static int transmit_response_with_sdp	(	struct sip_pvt *	p,
		const char *	msg,
		const struct sip_request *	req,
		enum xmittype	reliable
	)			[static]

Used for 200 OK and 183 early media.

Definition at line 6430 of file chan_sip.c.

References add_sdp(), ast_log(), ast_rtp_codec_setpref(), ast_test_flag, sip_pvt::autoframing, sip_pvt::flags, get_header(), LOG_DEBUG, LOG_ERROR, LOG_WARNING, option_debug, sip_pvt::pendinginvite, sip_pvt::prefs, respprep(), sip_pvt::rtp, send_response(), SIP_OUTGOING, and try_suggested_sip_codec().

Referenced by handle_invite_replaces(), handle_request_invite(), sip_answer(), sip_indicate(), and sip_write().

{
   struct sip_request resp;
   int seqno;
   if (sscanf(get_header(req, "CSeq"), "%d ", &seqno) != 1) {
      ast_log(LOG_WARNING, "Unable to get seqno from '%s'\n", get_header(req, "CSeq"));
      return -1;
   }
   respprep(&resp, p, msg, req);
   if (p->rtp) {
      if (!p->autoframing && !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
         if (option_debug)
            ast_log(LOG_DEBUG, "Setting framing from config on incoming call\n");
         ast_rtp_codec_setpref(p->rtp, &p->prefs);
      }
      try_suggested_sip_codec(p);   
      add_sdp(&resp, p);
   } else 
      ast_log(LOG_ERROR, "Can't add SDP to response, since we have no RTP session allocated. Call-ID %s\n", p->callid);
   if (reliable && !p->pendinginvite)
      p->pendinginvite = seqno;     /* Buggy clients sends ACK on RINGING too */
   return send_response(p, &resp, reliable, seqno);
}

static int transmit_response_with_t38_sdp	(	struct sip_pvt *	p,
		char *	msg,
		struct sip_request *	req,
		int	retrans
	)			[static]

Used for 200 OK and 183 early media.

Definition at line 6392 of file chan_sip.c.

References add_t38_sdp(), ast_log(), ast_udptl_offered_from_local(), get_header(), LOG_ERROR, LOG_WARNING, sip_pvt::pendinginvite, respprep(), send_response(), and sip_pvt::udptl.

Referenced by handle_request_invite(), sip_answer(), and sip_handle_t38_reinvite().

{
   struct sip_request resp;
   int seqno;
   
   if (sscanf(get_header(req, "CSeq"), "%d ", &seqno) != 1) {
      ast_log(LOG_WARNING, "Unable to get seqno from '%s'\n", get_header(req, "CSeq"));
      return -1;
   }
   respprep(&resp, p, msg, req);
   if (p->udptl) {
      ast_udptl_offered_from_local(p->udptl, 0);
      add_t38_sdp(&resp, p);
   } else 
      ast_log(LOG_ERROR, "Can't add SDP to response, since we have no UDPTL session allocated. Call-ID %s\n", p->callid);
   if (retrans && !p->pendinginvite)
      p->pendinginvite = seqno;     /* Buggy clients sends ACK on RINGING too */
   return send_response(p, &resp, retrans, seqno);
}

static int transmit_response_with_unsupported	(	struct sip_pvt *	p,
		const char *	msg,
		const struct sip_request *	req,
		const char *	unsupported
	)			[static]

Transmit response, no retransmits.

Definition at line 5826 of file chan_sip.c.

References add_header(), add_header_contentLength(), append_date(), respprep(), send_response(), and XMIT_UNRELIABLE.

Referenced by handle_request_invite().

{
   struct sip_request resp;
   respprep(&resp, p, msg, req);
   append_date(&resp);
   add_header(&resp, "Unsupported", unsupported);
   add_header_contentLength(&resp, 0);
   return send_response(p, &resp, XMIT_UNRELIABLE, 0);
}

static int transmit_sip_request	(	struct sip_pvt *	p,
		struct sip_request *	req
	)			[static]

Transmit SIP request unreliably (only used in sip_notify subsystem).

Definition at line 7086 of file chan_sip.c.

References sip_request::headers, initialize_initreq(), sip_pvt::initreq, sip_pvt::ocseq, send_request(), and XMIT_UNRELIABLE.

Referenced by sip_notify().

{
   if (!p->initreq.headers)   /* Initialize first request before sending */
      initialize_initreq(p, req);
   return send_request(p, req, XMIT_UNRELIABLE, p->ocseq);
}

static int transmit_state_notify	(	struct sip_pvt *	p,
		int	state,
		int	full,
		int	timeout
	)			[static]

Used in the SUBSCRIBE notification subsystem.

Definition at line 6873 of file chan_sip.c.

References add_header(), add_header_contentLength(), add_line(), ast_build_string(), ast_device_state(), AST_DEVICE_UNAVAILABLE, AST_EXTENSION_BUSY, AST_EXTENSION_DEACTIVATED, AST_EXTENSION_INUSE, AST_EXTENSION_NOT_INUSE, AST_EXTENSION_ONHOLD, AST_EXTENSION_REMOVED, AST_EXTENSION_RINGING, AST_EXTENSION_UNAVAILABLE, ast_get_hint(), ast_log(), AST_MAX_EXTENSION, CPIM_PIDF_XML, DIALOG_INFO_XML, sip_pvt::dialogver, sip_pvt::expiry, find_subscription_type(), get_header(), get_in_brackets(), sip_pvt::initreq, LOG_WARNING, NONE, sip_pvt::ocseq, PIDF_XML, reqprep(), send_request(), SIP_NOTIFY, strsep(), sip_pvt::subscribed, t, XMIT_RELIABLE, and XPIDF_XML.

Referenced by __sip_autodestruct(), cb_extensionstate(), and handle_request_subscribe().

{
   char tmp[4000], from[256], to[256];
   char *t = tmp, *c, *mfrom, *mto;
   size_t maxbytes = sizeof(tmp);
   struct sip_request req;
   char hint[AST_MAX_EXTENSION];
   char *statestring = "terminated";
   const struct cfsubscription_types *subscriptiontype;
   enum state { NOTIFY_OPEN, NOTIFY_INUSE, NOTIFY_CLOSED } local_state = NOTIFY_OPEN;
   char *pidfstate = "--";
   char *pidfnote= "Ready";

   memset(from, 0, sizeof(from));
   memset(to, 0, sizeof(to));
   memset(tmp, 0, sizeof(tmp));

   switch (state) {
   case (AST_EXTENSION_RINGING | AST_EXTENSION_INUSE):
      statestring = (global_notifyringing) ? "early" : "confirmed";
      local_state = NOTIFY_INUSE;
      pidfstate = "busy";
      pidfnote = "Ringing";
      break;
   case AST_EXTENSION_RINGING:
      statestring = "early";
      local_state = NOTIFY_INUSE;
      pidfstate = "busy";
      pidfnote = "Ringing";
      break;
   case AST_EXTENSION_INUSE:
      statestring = "confirmed";
      local_state = NOTIFY_INUSE;
      pidfstate = "busy";
      pidfnote = "On the phone";
      break;
   case AST_EXTENSION_BUSY:
      statestring = "confirmed";
      local_state = NOTIFY_CLOSED;
      pidfstate = "busy";
      pidfnote = "On the phone";
      break;
   case AST_EXTENSION_UNAVAILABLE:
      statestring = "terminated";
      local_state = NOTIFY_CLOSED;
      pidfstate = "away";
      pidfnote = "Unavailable";
      break;
   case AST_EXTENSION_ONHOLD:
      statestring = "confirmed";
      local_state = NOTIFY_INUSE;
      pidfstate = "busy";
      pidfnote = "On Hold";
      break;
   case AST_EXTENSION_NOT_INUSE:
   default:
      /* Default setting */
      break;
   }

   subscriptiontype = find_subscription_type(p->subscribed);
   
   /* Check which device/devices we are watching  and if they are registered */
   if (ast_get_hint(hint, sizeof(hint), NULL, 0, NULL, p->context, p->exten)) {
      /* If they are not registered, we will override notification and show no availability */
      if (ast_device_state(hint) == AST_DEVICE_UNAVAILABLE) {
         local_state = NOTIFY_CLOSED;
         pidfstate = "away";
         pidfnote = "Not online";
      }
   }

   ast_copy_string(from, get_header(&p->initreq, "From"), sizeof(from));
   c = get_in_brackets(from);
   if (strncmp(c, "sip:", 4)) {
      ast_log(LOG_WARNING, "Huh?  Not a SIP header (%s)?\n", c);
      return -1;
   }
   mfrom = strsep(&c, ";");   /* trim ; and beyond */

   ast_copy_string(to, get_header(&p->initreq, "To"), sizeof(to));
   c = get_in_brackets(to);
   if (strncmp(c, "sip:", 4)) {
      ast_log(LOG_WARNING, "Huh?  Not a SIP header (%s)?\n", c);
      return -1;
   }
   mto = strsep(&c, ";");  /* trim ; and beyond */

   reqprep(&req, p, SIP_NOTIFY, 0, 1);

   
   add_header(&req, "Event", subscriptiontype->event);
   add_header(&req, "Content-Type", subscriptiontype->mediatype);
   switch(state) {
   case AST_EXTENSION_DEACTIVATED:
      if (timeout)
         add_header(&req, "Subscription-State", "terminated;reason=timeout");
      else {
         add_header(&req, "Subscription-State", "terminated;reason=probation");
         add_header(&req, "Retry-After", "60");
      }
      break;
   case AST_EXTENSION_REMOVED:
      add_header(&req, "Subscription-State", "terminated;reason=noresource");
      break;
   default:
      if (p->expiry)
         add_header(&req, "Subscription-State", "active");
      else  /* Expired */
         add_header(&req, "Subscription-State", "terminated;reason=timeout");
   }
   switch (p->subscribed) {
   case XPIDF_XML:
   case CPIM_PIDF_XML:
      ast_build_string(&t, &maxbytes, "<?xml version=\"1.0\"?>\n");
      ast_build_string(&t, &maxbytes, "<!DOCTYPE presence PUBLIC \"-//IETF//DTD RFCxxxx XPIDF 1.0//EN\" \"xpidf.dtd\">\n");
      ast_build_string(&t, &maxbytes, "<presence>\n");
      ast_build_string(&t, &maxbytes, "<presentity uri=\"%s;method=SUBSCRIBE\" />\n", mfrom);
      ast_build_string(&t, &maxbytes, "<atom id=\"%s\">\n", p->exten);
      ast_build_string(&t, &maxbytes, "<address uri=\"%s;user=ip\" priority=\"0.800000\">\n", mto);
      ast_build_string(&t, &maxbytes, "<status status=\"%s\" />\n", (local_state ==  NOTIFY_OPEN) ? "open" : (local_state == NOTIFY_INUSE) ? "inuse" : "closed");
      ast_build_string(&t, &maxbytes, "<msnsubstatus substatus=\"%s\" />\n", (local_state == NOTIFY_OPEN) ? "online" : (local_state == NOTIFY_INUSE) ? "onthephone" : "offline");
      ast_build_string(&t, &maxbytes, "</address>\n</atom>\n</presence>\n");
      break;
   case PIDF_XML: /* Eyebeam supports this format */
      ast_build_string(&t, &maxbytes, "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n");
      ast_build_string(&t, &maxbytes, "<presence xmlns=\"urn:ietf:params:xml:ns:pidf\" \nxmlns:pp=\"urn:ietf:params:xml:ns:pidf:person\"\nxmlns:es=\"urn:ietf:params:xml:ns:pidf:rpid:status:rpid-status\"\nxmlns:ep=\"urn:ietf:params:xml:ns:pidf:rpid:rpid-person\"\nentity=\"%s\">\n", mfrom);
      ast_build_string(&t, &maxbytes, "<pp:person><status>\n");
      if (pidfstate[0] != '-')
         ast_build_string(&t, &maxbytes, "<ep:activities><ep:%s/></ep:activities>\n", pidfstate);
      ast_build_string(&t, &maxbytes, "</status></pp:person>\n");
      ast_build_string(&t, &maxbytes, "<note>%s</note>\n", pidfnote); /* Note */
      ast_build_string(&t, &maxbytes, "<tuple id=\"%s\">\n", p->exten); /* Tuple start */
      ast_build_string(&t, &maxbytes, "<contact priority=\"1\">%s</contact>\n", mto);
      if (pidfstate[0] == 'b') /* Busy? Still open ... */
         ast_build_string(&t, &maxbytes, "<status><basic>open</basic></status>\n");
      else
         ast_build_string(&t, &maxbytes, "<status><basic>%s</basic></status>\n", (local_state != NOTIFY_CLOSED) ? "open" : "closed");
      ast_build_string(&t, &maxbytes, "</tuple>\n</presence>\n");
      break;
   case DIALOG_INFO_XML: /* SNOM subscribes in this format */
      ast_build_string(&t, &maxbytes, "<?xml version=\"1.0\"?>\n");
      ast_build_string(&t, &maxbytes, "<dialog-info xmlns=\"urn:ietf:params:xml:ns:dialog-info\" version=\"%d\" state=\"%s\" entity=\"%s\">\n", p->dialogver++, full ? "full":"partial", mto);
      if ((state & AST_EXTENSION_RINGING) && global_notifyringing)
         ast_build_string(&t, &maxbytes, "<dialog id=\"%s\" direction=\"recipient\">\n", p->exten);
      else
         ast_build_string(&t, &maxbytes, "<dialog id=\"%s\">\n", p->exten);
      ast_build_string(&t, &maxbytes, "<state>%s</state>\n", statestring);
      if (state == AST_EXTENSION_ONHOLD) {
         ast_build_string(&t, &maxbytes, "<local>\n<target uri=\"%s\">\n"
                                         "<param pname=\"+sip.rendering\" pvalue=\"no\">\n"
                                         "</target>\n</local>\n", mto);
      }
      ast_build_string(&t, &maxbytes, "</dialog>\n</dialog-info>\n");
      break;
   case NONE:
   default:
      break;
   }

   if (t > tmp + sizeof(tmp))
      ast_log(LOG_WARNING, "Buffer overflow detected!!  (Please file a bug report)\n");

   add_header_contentLength(&req, strlen(tmp));
   add_line(&req, tmp);

   return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
}

static void try_suggested_sip_codec

(

struct sip_pvt *

p

)

[static]

Try setting codec suggested by the SIP_CODEC channel variable.

Definition at line 3429 of file chan_sip.c.

References ast_getformatbyname(), ast_log(), sip_pvt::capability, fmt, sip_pvt::jointcapability, LOG_NOTICE, sip_pvt::owner, and pbx_builtin_getvar_helper().

Referenced by sip_answer(), and transmit_response_with_sdp().

{
   int fmt;
   const char *codec;

   codec = pbx_builtin_getvar_helper(p->owner, "SIP_CODEC");
   if (!codec) 
      return;

   fmt = ast_getformatbyname(codec);
   if (fmt) {
      ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC} variable\n", codec);
      if (p->jointcapability & fmt) {
         p->jointcapability &= fmt;
         p->capability &= fmt;
      } else
         ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because it is not shared by both ends.\n");
   } else
      ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n", codec);
   return;  
}

static int unload_module

(

void

)

[static]

PBX unload module API.

Definition at line 17465 of file chan_sip.c.

References __sip_destroy(), ast_channel_unregister(), ast_cli_unregister_multiple(), ast_custom_function_unregister(), ast_free_ha(), ast_manager_unregister(), ast_mutex_lock(), ast_mutex_unlock(), AST_PTHREADT_STOP, ast_rtp_proto_unregister(), ast_softhangup(), AST_SOFTHANGUP_APPUNLOAD, ast_udptl_proto_unregister(), ast_unregister_application(), ASTOBJ_CONTAINER_DESTROY, ASTOBJ_CONTAINER_DESTROYALL, authl, checksipdomain_function, clear_realm_authentication(), clear_sip_domains(), cli_sip, iflist, localaddr, sip_pvt::next, sip_pvt::owner, peerl, regl, sched, sched_context_destroy(), sip_destroy_peer(), sip_destroy_user(), sip_header_function, sip_registry_destroy(), sip_rtp, sip_tech, sip_udptl, sipchaninfo_function, sippeer_function, sipsock, TRUE, and userl.

{
   struct sip_pvt *p, *pl;
   
   /* First, take us out of the channel type list */
   ast_channel_unregister(&sip_tech);

   /* Unregister dial plan functions */
   ast_custom_function_unregister(&sipchaninfo_function);
   ast_custom_function_unregister(&sippeer_function);
   ast_custom_function_unregister(&sip_header_function);
   ast_custom_function_unregister(&checksipdomain_function);

   /* Unregister dial plan applications */
   ast_unregister_application(app_dtmfmode);
   ast_unregister_application(app_sipaddheader);

   /* Unregister CLI commands */
   ast_cli_unregister_multiple(cli_sip, sizeof(cli_sip) / sizeof(struct ast_cli_entry));

   /* Disconnect from the RTP subsystem */
   ast_rtp_proto_unregister(&sip_rtp);

   /* Disconnect from UDPTL */
   ast_udptl_proto_unregister(&sip_udptl);

   /* Unregister AMI actions */
   ast_manager_unregister("SIPpeers");
   ast_manager_unregister("SIPshowpeer");

   ast_mutex_lock(&iflock);
   /* Hangup all interfaces if they have an owner */
   for (p = iflist; p ; p = p->next) {
      if (p->owner)
         ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
   }
   ast_mutex_unlock(&iflock);

   ast_mutex_lock(&monlock);
   if (monitor_thread && (monitor_thread != AST_PTHREADT_STOP)) {
      pthread_cancel(monitor_thread);
      pthread_kill(monitor_thread, SIGURG);
      pthread_join(monitor_thread, NULL);
   }
   monitor_thread = AST_PTHREADT_STOP;
   ast_mutex_unlock(&monlock);

   ast_mutex_lock(&iflock);
   /* Destroy all the interfaces and free their memory */
   p = iflist;
   while (p) {
      pl = p;
      p = p->next;
      __sip_destroy(pl, TRUE);
   }
   iflist = NULL;
   ast_mutex_unlock(&iflock);

   /* Free memory for local network address mask */
   ast_free_ha(localaddr);

   ASTOBJ_CONTAINER_DESTROYALL(&userl, sip_destroy_user);
   ASTOBJ_CONTAINER_DESTROY(&userl);
   ASTOBJ_CONTAINER_DESTROYALL(&peerl, sip_destroy_peer);
   ASTOBJ_CONTAINER_DESTROY(&peerl);
   ASTOBJ_CONTAINER_DESTROYALL(&regl, sip_registry_destroy);
   ASTOBJ_CONTAINER_DESTROY(&regl);

   clear_realm_authentication(authl);
   clear_sip_domains();
   close(sipsock);
   sched_context_destroy(sched);
      
   return 0;
}

static int update_call_counter	(	struct sip_pvt *	fup,
		int	event
	)			[static]

update_call_counter: Handle call_limit for SIP users Setting a call-limit will cause calls above the limit not to be accepted.

Remember that for a type=friend, there's one limit for the user and another for the peer, not a combined call limit. This will cause unexpected behaviour in subscriptions, since a "friend" is *two* devices in Asterisk, not one.

Thought: For realtime, we should propably update storage with inuse counter...

Returns:

0 if call is ok (no call limit, below treshold) -1 on rejection of call

Definition at line 2995 of file chan_sip.c.

References ast_clear_flag, ast_device_state_changed(), ast_log(), ast_set_flag, ast_strlen_zero(), ast_test_flag, ASTOBJ_UNREF, sip_peer::call_limit, sip_user::call_limit, DEC_CALL_LIMIT, DEC_CALL_RINGING, FALSE, find_peer(), find_user(), sip_pvt::flags, INC_CALL_LIMIT, INC_CALL_RINGING, sip_peer::inRinging, sip_peer::inUse, sip_user::inUse, inuse, LOG_DEBUG, LOG_ERROR, LOG_WARNING, name, option_debug, SIP_CALL_LIMIT, sip_destroy_peer(), sip_destroy_user(), SIP_INC_COUNT, SIP_PAGE2_CALL_ONHOLD, SIP_PAGE2_INC_RINGING, SIP_PAGE2_OUTGOING_CALL, sip_peer_hold(), and sipdebug.

Referenced by __sip_destroy(), handle_request_invite(), handle_response_invite(), sip_call(), and sip_hangup().

{
   char name[256];
   int *inuse = NULL, *call_limit = NULL, *inringing = NULL;
   int outgoing = ast_test_flag(&fup->flags[1], SIP_PAGE2_OUTGOING_CALL);
   struct sip_user *u = NULL;
   struct sip_peer *p = NULL;

   if (option_debug > 2)
      ast_log(LOG_DEBUG, "Updating call counter for %s call\n", outgoing ? "outgoing" : "incoming");
   /* Test if we need to check call limits, in order to avoid 
      realtime lookups if we do not need it */
   if (!ast_test_flag(&fup->flags[0], SIP_CALL_LIMIT))
      return 0;

   ast_copy_string(name, fup->username, sizeof(name));

   /* Check the list of users only for incoming calls */
   if (global_limitonpeers == FALSE && !outgoing && (u = find_user(name, 1)))  {
      inuse = &u->inUse;
      call_limit = &u->call_limit;
      inringing = NULL;
   } else if ( (p = find_peer(ast_strlen_zero(fup->peername) ? name : fup->peername, NULL, 1) ) ) { /* Try to find peer */
      inuse = &p->inUse;
      call_limit = &p->call_limit;
      inringing = &p->inRinging;
      ast_copy_string(name, fup->peername, sizeof(name));
   } 
   if (!p && !u) {
      if (option_debug > 1)
         ast_log(LOG_DEBUG, "%s is not a local device, no call limit\n", name);
      return 0;
   }

   switch(event) {
   /* incoming and outgoing affects the inUse counter */
   case DEC_CALL_LIMIT:
      if ( *inuse > 0 ) {
         if (ast_test_flag(&fup->flags[0], SIP_INC_COUNT)) {
            (*inuse)--;
            ast_clear_flag(&fup->flags[0], SIP_INC_COUNT);
         }
      } else {
         *inuse = 0;
      }
      if (inringing) {
         if (ast_test_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING)) {
            if (*inringing > 0)
               (*inringing)--;
            else
               ast_log(LOG_WARNING, "Inringing for peer '%s' < 0?\n", fup->peername);
            ast_clear_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING);
         }
      }
      if (ast_test_flag(&fup->flags[1], SIP_PAGE2_CALL_ONHOLD) && global_notifyhold)
         sip_peer_hold(fup, 0);
      if (option_debug > 1 || sipdebug) {
         ast_log(LOG_DEBUG, "Call %s %s '%s' removed from call limit %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *call_limit);
      }
      break;

   case INC_CALL_RINGING:
   case INC_CALL_LIMIT:
      if (*call_limit > 0 ) {
         if (*inuse >= *call_limit) {
            ast_log(LOG_ERROR, "Call %s %s '%s' rejected due to usage limit of %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *call_limit);
            if (u)
               ASTOBJ_UNREF(u, sip_destroy_user);
            else
               ASTOBJ_UNREF(p, sip_destroy_peer);
            return -1; 
         }
      }
      if (inringing && (event == INC_CALL_RINGING)) {
         if (!ast_test_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING)) {
            (*inringing)++;
            ast_set_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING);
         }
      }
      /* Continue */
      (*inuse)++;
      ast_set_flag(&fup->flags[0], SIP_INC_COUNT);
      if (option_debug > 1 || sipdebug) {
         ast_log(LOG_DEBUG, "Call %s %s '%s' is %d out of %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *inuse, *call_limit);
      }
      break;

   case DEC_CALL_RINGING:
      if (inringing) {
         if (ast_test_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING)) {
            if (*inringing > 0)
               (*inringing)--;
            else
               ast_log(LOG_WARNING, "Inringing for peer '%s' < 0?\n", p->name);
            ast_clear_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING);
         }
      }
      break;

   default:
      ast_log(LOG_ERROR, "update_call_counter(%s, %d) called with no event!\n", name, event);
   }
   if (p) {
      ast_device_state_changed("SIP/%s", p->name);
      ASTOBJ_UNREF(p, sip_destroy_peer);
   } else /* u must be set */
      ASTOBJ_UNREF(u, sip_destroy_user);
   return 0;
}

static void update_peer	(	struct sip_peer *	p,
		int	expiry
	)			[static]

Update peer data in database (if used).

Definition at line 2392 of file chan_sip.c.

References sip_peer::addr, ast_test_flag, sip_peer::flags, sip_peer::fullcontact, global_flags, realtime_update_peer(), SIP_PAGE2_RTCACHEFRIENDS, SIP_PAGE2_RTUPDATE, SIP_REALTIME, and sip_peer::username.

Referenced by register_verify().

{
   int rtcachefriends = ast_test_flag(&p->flags[1], SIP_PAGE2_RTCACHEFRIENDS);
   if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTUPDATE) &&
       (ast_test_flag(&p->flags[0], SIP_REALTIME) || rtcachefriends)) {
      realtime_update_peer(p->name, &p->addr, p->username, rtcachefriends ? p->fullcontact : NULL, expiry);
   }
}

---

Variable Documentation

struct in_addr __ourip [static]

Definition at line 1188 of file chan_sip.c.

int allow_external_domains [static]

Accept calls to external SIP domains?

Definition at line 554 of file chan_sip.c.

int apeerobjs = 0 [static]

Autocreated peer objects

Definition at line 570 of file chan_sip.c.

char* app_dtmfmode = "SIPDtmfMode" [static]

Definition at line 17005 of file chan_sip.c.

char* app_sipaddheader = "SIPAddHeader" [static]

Definition at line 17007 of file chan_sip.c.

struct sip_auth* authl = NULL [static]

Definition at line 1177 of file chan_sip.c.

Referenced by build_reply_digest(), sip_do_reload(), sip_show_settings(), and unload_module().

int autocreatepeer [static]

Auto creation of peers at registration? Default off.

Definition at line 534 of file chan_sip.c.

struct sockaddr_in bindaddr = { 0, } [static]

The address we bind to

Definition at line 1182 of file chan_sip.c.

struct ast_custom_function checksipdomain_function [static]

Definition at line 11427 of file chan_sip.c.

Referenced by load_module(), and unload_module().

struct ast_cli_entry cli_sip[] [static]

Definition at line 17301 of file chan_sip.c.

Referenced by load_module(), and unload_module().

struct ast_cli_entry cli_sip_debug_deprecated [static]

Initial value:

   { { "sip", "debug", NULL },
   sip_do_debug_deprecated, "Enable SIP debugging",
   debug_usage }

Definition at line 17291 of file chan_sip.c.

struct ast_cli_entry cli_sip_no_debug_deprecated [static]

Initial value:

   { { "sip", "no", "debug", NULL },
   sip_no_debug_deprecated, "Disable SIP debugging",
   debug_usage }

Definition at line 17296 of file chan_sip.c.

int compactheaders [static]

send compact sip headers

Definition at line 548 of file chan_sip.c.

const char config[] = "sip.conf" [static]

Definition at line 222 of file chan_sip.c.

char debug_usage[] [static]

Definition at line 11311 of file chan_sip.c.

struct sockaddr_in debugaddr [static]

Definition at line 1191 of file chan_sip.c.

Referenced by sip_do_debug(), sip_do_debug_deprecated(), sip_do_debug_ip(), and sip_do_debug_peer().

char default_callerid[AST_MAX_EXTENSION] [static]

Definition at line 514 of file chan_sip.c.

char default_context[AST_MAX_CONTEXT] [static]

Definition at line 511 of file chan_sip.c.

int default_expiry = DEFAULT_DEFAULT_EXPIRY [static]

Definition at line 185 of file chan_sip.c.

char default_fromdomain[AST_MAX_EXTENSION] [static]

Definition at line 515 of file chan_sip.c.

struct ast_jb_conf default_jbconf [static]

Global jitterbuffer configuration - by default, jb is disabled.

Definition at line 213 of file chan_sip.c.

char default_language[MAX_LANGUAGE] [static]

Definition at line 513 of file chan_sip.c.

int default_maxcallbitrate [static]

Maximum bitrate for call

Definition at line 522 of file chan_sip.c.

char default_mohinterpret[MAX_MUSICCLASS] [static]

Global setting for moh class to use when put on hold

Definition at line 519 of file chan_sip.c.

char default_mohsuggest[MAX_MUSICCLASS] [static]

Global setting for moh class to suggest when putting a bridged channel on hold

Definition at line 520 of file chan_sip.c.

char default_notifymime[AST_MAX_EXTENSION] [static]

Definition at line 516 of file chan_sip.c.

struct ast_codec_pref default_prefs [static]

Default codec prefs

Definition at line 523 of file chan_sip.c.

Referenced by build_device(), build_user(), reload_config(), set_peer_defaults(), sip_alloc(), sip_show_settings(), and temp_peer().

int default_qualify [static]

Default Qualify= setting

Definition at line 517 of file chan_sip.c.

char default_subscribecontext[AST_MAX_CONTEXT] [static]

Definition at line 512 of file chan_sip.c.

char default_vmexten[AST_MAX_EXTENSION] [static]

Definition at line 518 of file chan_sip.c.

char* descrip_dtmfmode = "SIPDtmfMode(inband|info|rfc2833): Changes the dtmfmode for a SIP call\n" [static]

Definition at line 17004 of file chan_sip.c.

char* descrip_sipaddheader [static]

Definition at line 17010 of file chan_sip.c.

int dumphistory [static]

Dump history to verbose before destroying SIP dialog

Definition at line 550 of file chan_sip.c.

int expiry = DEFAULT_EXPIRY [static]

Definition at line 186 of file chan_sip.c.

time_t externexpire = 0 [static]

Expiration counter for re-resolving external host name in dynamic DNS

Definition at line 1185 of file chan_sip.c.

Referenced by ast_sip_ouraddrfor(), and reload_config().

char externhost[MAXHOSTNAMELEN] [static]

External host name (possibly with dynamic DNS and DHCP

Definition at line 1184 of file chan_sip.c.

Referenced by ast_sip_ouraddrfor(), and reload_config().

struct sockaddr_in externip [static]

External IP address if we are behind NAT

Definition at line 1183 of file chan_sip.c.

int externrefresh = 10 [static]

Definition at line 1186 of file chan_sip.c.

Referenced by ast_sip_ouraddrfor(), and reload_config().

int global_allowguest [static]

allow unauthenticated users/peers to connect?

Definition at line 541 of file chan_sip.c.

int global_allowsubscribe [static]

Flag for disabling ALL subscriptions, this is FALSE only if all peers are FALSE the global setting is in globals_flags[1]

Definition at line 542 of file chan_sip.c.

enum transfermodes global_allowtransfer [static]

SIP Refer restriction scheme

Definition at line 558 of file chan_sip.c.

int global_alwaysauthreject [static]

Send 401 Unauthorized for all failing requests

Definition at line 531 of file chan_sip.c.

int global_autoframing [static]

Turn autoframing on or off.

Definition at line 557 of file chan_sip.c.

int global_callevents [static]

Whether we send manager events or not

Definition at line 555 of file chan_sip.c.

int global_capability = AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_GSM | AST_FORMAT_H263 [static]

Codecs that we support by default:.

Definition at line 563 of file chan_sip.c.

int global_directrtpsetup [static]

Enable support for Direct RTP setup (no re-invites)

Definition at line 526 of file chan_sip.c.

struct ast_flags global_flags[2] = {{0}} [static]

global SIP_ flags

Definition at line 573 of file chan_sip.c.

Referenced by build_peer(), build_radius_record(), build_user(), destroy_association(), get_destination(), load_module(), realtime_update_peer(), reload_config(), set_peer_defaults(), sip_alloc(), sip_do_debug(), sip_do_debug_deprecated(), sip_do_debug_ip(), sip_do_debug_peer(), sip_no_debug(), sip_no_debug_deprecated(), sip_show_settings(), transmit_response_using_temp(), and update_peer().

struct ast_jb_conf global_jbconf [static]

Definition at line 220 of file chan_sip.c.

int global_limitonpeers [static]

Match call limit on peers only

Definition at line 527 of file chan_sip.c.

int global_matchexterniplocally [static]

Match externip/externhost setting against localnet setting

Definition at line 560 of file chan_sip.c.

int global_mwitime [static]

Time between MWI checks for peers

Definition at line 544 of file chan_sip.c.

int global_notifyhold [static]

Send notifications on hold

Definition at line 530 of file chan_sip.c.

int global_notifyringing [static]

Send notifications on ringing

Definition at line 529 of file chan_sip.c.

char global_realm[MAXHOSTNAMELEN] [static]

Default realm

Definition at line 551 of file chan_sip.c.

int global_reg_timeout [static]

Definition at line 539 of file chan_sip.c.

int global_regattempts_max [static]

Registration attempts before giving up

Definition at line 540 of file chan_sip.c.

char global_regcontext[AST_MAX_CONTEXT] [static]

Context for auto-extensions

Definition at line 552 of file chan_sip.c.

int global_relaxdtmf [static]

Relax DTMF

Definition at line 535 of file chan_sip.c.

int global_rtautoclear [static]

Definition at line 528 of file chan_sip.c.

int global_rtpholdtimeout [static]

Definition at line 537 of file chan_sip.c.

int global_rtpkeepalive [static]

Send RTP keepalives

Definition at line 538 of file chan_sip.c.

int global_rtptimeout [static]

Time out call if no RTP

Definition at line 536 of file chan_sip.c.

int global_t1min [static]

T1 roundtrip time minimum

Definition at line 556 of file chan_sip.c.

int global_t38_capability = T38FAX_VERSION_0 | T38FAX_RATE_2400 | T38FAX_RATE_4800 | T38FAX_RATE_7200 | T38FAX_RATE_9600 [static]

Definition at line 820 of file chan_sip.c.

Referenced by create_addr_from_peer(), and sip_alloc().

unsigned int global_tos_audio [static]

IP type of service for audio RTP packets

Definition at line 546 of file chan_sip.c.

unsigned int global_tos_sip [static]

IP type of service for SIP packets

Definition at line 545 of file chan_sip.c.

unsigned int global_tos_video [static]

IP type of service for video RTP packets

Definition at line 547 of file chan_sip.c.

char global_useragent[AST_MAX_EXTENSION] [static]

Useragent for the SIP channel

Definition at line 553 of file chan_sip.c.

char history_usage[] [static]

Initial value:

 
"Usage: sip history\n"
"       Enables recording of SIP dialog history for debugging purposes.\n"
"Use 'sip show history' to view the history of a call number.\n"

Definition at line 11328 of file chan_sip.c.

struct sip_pvt * iflist [static]

sip_pvt: PVT structures are used for each SIP dialog, ie. a call, a registration, a subscribe

struct io_context* io [static]

The IO context

Definition at line 594 of file chan_sip.c.

struct ast_ha* localaddr [static]

List of local networks, on the same side of NAT as this Asterisk

Definition at line 1187 of file chan_sip.c.

Referenced by ast_sip_ouraddrfor(), reload_config(), and unload_module().

char mandescr_show_peer[] [static]

Initial value:

 
"Description: Show one SIP peer with details on current status.\n"
"Variables: \n"
"  Peer: <name>           The peer name you want to check.\n"
"  ActionID: <id>   Optional action ID for this AMI transaction.\n"

Definition at line 9962 of file chan_sip.c.

char mandescr_show_peers[] [static]

Initial value:

 
"Description: Lists SIP peers in text format with details on current status.\n"
"Variables: \n"
"  ActionID: <id> Action ID for this transaction. Will be returned.\n"

Definition at line 9513 of file chan_sip.c.

int max_expiry = DEFAULT_MAX_EXPIRY [static]

Maximum accepted registration time

Definition at line 184 of file chan_sip.c.

int min_expiry = DEFAULT_MIN_EXPIRY [static]

Minimum accepted registration time

Definition at line 183 of file chan_sip.c.

pthread_t monitor_thread = AST_PTHREADT_NULL [static]

This is the thread for the monitor which checks for input on the channels which are not currently in use.

Definition at line 588 of file chan_sip.c.

char no_debug_usage[] [static]

Initial value:

 
"Usage: sip set debug off\n"
"       Disables dumping of SIP packets for debugging purposes\n"

Definition at line 11320 of file chan_sip.c.

char no_history_usage[] [static]

Initial value:

 
"Usage: sip history off\n"
"       Disables recording of SIP dialog history for debugging purposes\n"

Definition at line 11324 of file chan_sip.c.

const char notify_config[] = "sip_notify.conf" [static]

Definition at line 223 of file chan_sip.c.

struct ast_config* notify_types [static]

The list of manual NOTIFY types we know how to send

Definition at line 1193 of file chan_sip.c.

Referenced by complete_sipnotify(), and sip_notify().

char notify_usage[] [static]

Initial value:

"Usage: sip notify <type> <peer> [<peer>...]\n"
"       Send a NOTIFY message to a SIP peer or peers\n"
"       Message types are defined in sip_notify.conf\n"

Definition at line 11260 of file chan_sip.c.

int ourport [static]

Definition at line 1190 of file chan_sip.c.

struct sockaddr_in outboundproxyip [static]

Definition at line 1189 of file chan_sip.c.

Referenced by reload_config().

int pedanticsipchecking [static]

Extra checking ? Default off

Definition at line 533 of file chan_sip.c.

struct ast_peer_list peerl [static]

The peer list: Peers and Friends.

char prune_realtime_usage[] [static]

Initial value:

"Usage: sip prune realtime [peer|user] [<name>|all|like <pattern>]\n"
"       Prunes object(s) from the cache.\n"
"       Optional regular expression pattern is used to filter the objects.\n"

Definition at line 11302 of file chan_sip.c.

int recordhistory [static]

Record SIP history. Off by default

Definition at line 549 of file chan_sip.c.

struct c_referstatusstring referstatusstrings[] [static]

Referenced by referstatus2str().

struct ast_register_list regl [static]

The register list: Other SIP proxys we register with and place calls to.

Referenced by load_module(), sip_do_reload(), sip_register(), sip_send_all_registers(), sip_show_objects(), sip_show_registry(), and unload_module().

int regobjs = 0 [static]

Registry objects

Definition at line 571 of file chan_sip.c.

int rpeerobjs = 0 [static]

Realtime peers

Definition at line 569 of file chan_sip.c.

int ruserobjs = 0 [static]

Realtime users

Definition at line 567 of file chan_sip.c.

struct sched_context* sched [static]

The scheduling context

Definition at line 593 of file chan_sip.c.

char show_channel_usage[] [static]

Initial value:

 
"Usage: sip show channel <channel>\n"
"       Provides detailed status on a given SIP channel.\n"

Definition at line 11284 of file chan_sip.c.

char show_channels_usage[] [static]

Initial value:

 
"Usage: sip show channels\n"
"       Lists all currently active SIP channels.\n"

Definition at line 11280 of file chan_sip.c.

char show_domains_usage[] [static]

Initial value:

 
"Usage: sip show domains\n"
"       Lists all configured SIP local domains.\n"
"       Asterisk only responds to SIP messages to local domains.\n"

Definition at line 11255 of file chan_sip.c.

char show_history_usage[] [static]

Initial value:

 
"Usage: sip show history <channel>\n"
"       Provides detailed dialog history on a given SIP channel.\n"

Definition at line 11288 of file chan_sip.c.

char show_inuse_usage[] [static]

Initial value:

 
"Usage: sip show inuse [all]\n"
"       List all SIP users and peers usage counters and limits.\n"
"       Add option \"all\" to show all devices, not only those with a limit.\n"

Definition at line 11275 of file chan_sip.c.

char show_objects_usage[] [static]

Initial value:

"Usage: sip show objects\n" 
"       Lists status of known SIP objects\n"

Definition at line 11341 of file chan_sip.c.

char show_peer_usage[] [static]

Initial value:

"Usage: sip show peer <name> [load]\n"
"       Shows all details on one SIP peer and the current status.\n"
"       Option \"load\" forces lookup of peer in realtime storage.\n"

Definition at line 11297 of file chan_sip.c.

char show_peers_usage[] [static]

Initial value:

 
"Usage: sip show peers [like <pattern>]\n"
"       Lists all known SIP peers.\n"
"       Optional regular expression pattern is used to filter the peer list.\n"

Definition at line 11292 of file chan_sip.c.

char show_reg_usage[] [static]

Initial value:

"Usage: sip show registry\n"
"       Lists all registration requests and status.\n"

Definition at line 11307 of file chan_sip.c.

char show_settings_usage[] [static]

Initial value:

 
"Usage: sip show settings\n"
"       Provides detailed list of the configuration of the SIP channel.\n"

Definition at line 11345 of file chan_sip.c.

char show_subscriptions_usage[] [static]

Initial value:

"Usage: sip show subscriptions\n" 
"       Lists active SIP subscriptions for extension states\n"

Definition at line 11337 of file chan_sip.c.

char show_user_usage[] [static]

Initial value:

"Usage: sip show user <name> [load]\n"
"       Shows all details on one SIP user and the current status.\n"
"       Option \"load\" forces lookup of peer in realtime storage.\n"

Definition at line 11270 of file chan_sip.c.

char show_users_usage[] [static]

Initial value:

 
"Usage: sip show users [like <pattern>]\n"
"       Lists all known SIP users.\n"
"       Optional regular expression pattern is used to filter the user list.\n"

Definition at line 11265 of file chan_sip.c.

struct ast_custom_function sip_header_function [static]

Definition at line 11403 of file chan_sip.c.

Referenced by load_module(), and unload_module().

struct cfsip_methods sip_methods[] [static]

XXX Note that sip_methods[i].id == i must hold or the code breaks

Referenced by __sip_ack(), __sip_autodestruct(), __sip_destroy(), __sip_pretend_ack(), __sip_semi_ack(), build_reply_digest(), check_auth(), do_proxy_auth(), find_sip_method(), get_destination(), handle_request(), handle_request_subscribe(), handle_response(), init_req(), initreqprep(), method_match(), reqprep(), retrans_pkt(), send_request(), send_response(), sip_alloc(), sip_scheddestroy(), and transmit_register().

struct cfsip_options sip_options[] [static]

List of well-known SIP options. If we get this in a require, we should check the list and answer accordingly.

Referenced by _sip_show_peer(), parse_sip_options(), and sip_show_channel().

char sip_reload_usage[] [static]

Initial value:

"Usage: sip reload\n"
"       Reloads SIP configuration from sip.conf\n"

Definition at line 11333 of file chan_sip.c.

int sip_reloading = FALSE [static]

Flag for avoiding multiple reloads at the same time

Definition at line 590 of file chan_sip.c.

enum channelreloadreason sip_reloadreason [static]

Reason for last reload/load of configuration

Definition at line 591 of file chan_sip.c.

struct ast_rtp_protocol sip_rtp [static]

Interface structure with callbacks used to connect to RTP module.

Definition at line 1588 of file chan_sip.c.

Referenced by load_module(), and unload_module().

struct ast_channel_tech sip_tech [static]

Definition of this channel for PBX channel registration.

Definition at line 1531 of file chan_sip.c.

Referenced by acf_channel_read(), func_header_read(), function_sipchaninfo_read(), handle_request_invite(), handle_response_invite(), load_module(), sip_dtmfmode(), sip_new(), and unload_module().

struct ast_channel_tech sip_tech_info [static]

This version of the sip channel tech has no send_digit_begin callback. This is for use with channels using SIP INFO DTMF so that the core knows that the channel doesn't want DTMF BEGIN frames.

Definition at line 1557 of file chan_sip.c.

Referenced by acf_channel_read(), func_header_read(), function_sipchaninfo_read(), handle_request_invite(), handle_response_invite(), sip_dtmfmode(), and sip_new().

struct ast_udptl_protocol sip_udptl [static]

Initial value:

 {
   type: "SIP",
   get_udptl_info: sip_get_udptl_peer,
   set_udptl_peer: sip_set_udptl_peer,
}

Interface structure with callbacks used to connect to UDPTL module.

Definition at line 1597 of file chan_sip.c.

Referenced by load_module(), and unload_module().

struct ast_custom_function sipchaninfo_function [static]

Structure to declare a dialplan function: SIPCHANINFO.

Definition at line 11582 of file chan_sip.c.

Referenced by load_module(), and unload_module().

struct ast_custom_function sippeer_function

Structure to declare a dialplan function: SIPPEER.

Definition at line 11502 of file chan_sip.c.

Referenced by load_module(), and unload_module().

int sipsock = -1 [static]

Main socket for SIP network communication

Definition at line 1181 of file chan_sip.c.

Referenced by __sip_xmit(), do_monitor(), reg_source_db(), sipsock_read(), and unload_module().

int* sipsock_read_id [static]

ID of IO entry for sipsock FD

Definition at line 595 of file chan_sip.c.

int speerobjs = 0 [static]

Statis peers

Definition at line 568 of file chan_sip.c.

int srvlookup [static]

SRV Lookup on or off. Default is off, RFC behavior is on

Definition at line 532 of file chan_sip.c.

struct cfsubscription_types subscription_types[] [static]

Referenced by find_subscription_type(), and subscription_type2str().

int suserobjs = 0 [static]

Static users

Definition at line 566 of file chan_sip.c.

char* synopsis_dtmfmode = "Change the dtmfmode for a SIP call" [static]

Definition at line 17003 of file chan_sip.c.

char* synopsis_sipaddheader = "Add a SIP header to the outbound call" [static]

Definition at line 17008 of file chan_sip.c.

struct ast_user_list userl [static]

The user list: Users and friends.

---