Thu Oct 9 06:44:50 2008

Asterisk developer's documentation

---

chan_sip.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2006, Digium, Inc.
 *
 * Mark Spencer <markster@digium.com>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*!
 * \file
 * \brief Implementation of Session Initiation Protocol
 * 
 * Implementation of RFC 3261 - without S/MIME, TCP and TLS support
 * Configuration file \link Config_sip sip.conf \endlink
 *
 * \todo SIP over TCP
 * \todo SIP over TLS
 * \todo Better support of forking
 */


#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.h"

ASTERISK_FILE_VERSION(__FILE__, "$Revision: 120109 $")

#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/lock.h"
#include "asterisk/sched.h"
#include "asterisk/io.h"
#include "asterisk/rtp.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/acl.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"

#ifdef OSP_SUPPORT
#include "asterisk/astosp.h"
#endif

#ifndef DEFAULT_USERAGENT
#define DEFAULT_USERAGENT "Asterisk PBX"
#endif
 
#define VIDEO_CODEC_MASK   0x1fc0000 /* Video codecs from H.261 thru AST_FORMAT_MAX_VIDEO */
#ifndef IPTOS_MINCOST
#define IPTOS_MINCOST      0x02
#endif

/* #define VOCAL_DATA_HACK */

#define SIPDUMPER
#define DEFAULT_DEFAULT_EXPIRY  120
#define DEFAULT_MAX_EXPIRY 3600
#define DEFAULT_REGISTRATION_TIMEOUT   20
#define DEFAULT_MAX_FORWARDS  "70"

/* guard limit must be larger than guard secs */
/* guard min must be < 1000, and should be >= 250 */
#define EXPIRY_GUARD_SECS  15 /* How long before expiry do we reregister */
#define EXPIRY_GUARD_LIMIT 30 /* Below here, we use EXPIRY_GUARD_PCT instead of 
                  EXPIRY_GUARD_SECS */
#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. */
#define EXPIRY_GUARD_PCT   0.20  /* Percentage of expires timeout to use when 
                  below EXPIRY_GUARD_LIMIT */

#define SIP_LEN_CONTACT    256

static int max_expiry = DEFAULT_MAX_EXPIRY;
static int default_expiry = DEFAULT_DEFAULT_EXPIRY;

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

#define CALLERID_UNKNOWN   "Unknown"



#define DEFAULT_MAXMS      2000     /* Must be faster than 2 seconds by default */
#define DEFAULT_FREQ_OK    60 * 1000   /* How often to check for the host to be up */
#define DEFAULT_FREQ_NOTOK 10 * 1000   /* How often to check, if the host is down... */

#define DEFAULT_RETRANS    1000     /* How frequently to retransmit */
                  /* 2 * 500 ms in RFC 3261 */
#define MAX_RETRANS     6     /* Try only 6 times for retransmissions, a total of 7 transmissions */
#define MAX_AUTHTRIES      3     /* Try authentication three times, then fail */


#define DEBUG_READ   0        /* Recieved data  */
#define DEBUG_SEND   1        /* Transmit data  */

static const char desc[] = "Session Initiation Protocol (SIP)";
static const char channeltype[] = "SIP";
static const char config[] = "sip.conf";
static const char notify_config[] = "sip_notify.conf";

#define RTP    1
#define NO_RTP 0

/* Do _NOT_ make any changes to this enum, or the array following it;
   if you think you are doing the right thing, you are probably
   not doing the right thing. If you think there are changes
   needed, get someone else to review them first _before_
   submitting a patch. If these two lists do not match properly
   bad things will happen.
*/

enum subscriptiontype { 
   NONE = 0,
   XPIDF_XML,
   DIALOG_INFO_XML,
   CPIM_PIDF_XML,
   PIDF_XML
};

static const struct cfsubscription_types {
   enum subscriptiontype type;
   const char * const event;
   const char * const mediatype;
   const char * const text;
} subscription_types[] = {
   { NONE,            "-",        "unknown",                   "unknown" },
   /* IETF draft: draft-ietf-sipping-dialog-package-05.txt */
   { DIALOG_INFO_XML, "dialog",   "application/dialog-info+xml", "dialog-info+xml" },
   { CPIM_PIDF_XML,   "presence", "application/cpim-pidf+xml",   "cpim-pidf+xml" },  /* RFC 3863 */
   { PIDF_XML,        "presence", "application/pidf+xml",        "pidf+xml" },       /* RFC 3863 */
   { XPIDF_XML,       "presence", "application/xpidf+xml",       "xpidf+xml" }       /* Pre-RFC 3863 with MS additions */
};

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

enum sip_auth_type {
   PROXY_AUTH,
   WWW_AUTH,
};

/*! XXX Note that sip_methods[i].id == i must hold or the code breaks */
static const struct  cfsip_methods { 
   enum sipmethod id;
   int need_rtp;     /*!< when this is the 'primary' use for a pvt structure, does it need RTP? */
   char * const text;
   int can_create;   /*!< 0=can't create, 1 can create, 2 can create, but not supported */
} sip_methods[] = {
   { SIP_UNKNOWN,  RTP,    "-UNKNOWN-", 2 },
   { SIP_RESPONSE,    NO_RTP, "SIP/2.0", 0 },
   { SIP_REGISTER,    NO_RTP, "REGISTER", 1 },
   { SIP_OPTIONS,  NO_RTP, "OPTIONS", 1 },
   { SIP_NOTIFY,   NO_RTP, "NOTIFY", 2 },
   { SIP_INVITE,   RTP,    "INVITE", 1 },
   { SIP_ACK,   NO_RTP, "ACK", 0 },
   { SIP_PRACK,    NO_RTP, "PRACK", 2 },
   { SIP_BYE,   NO_RTP, "BYE", 0 },
   { SIP_REFER,    NO_RTP, "REFER", 2 },
   { SIP_SUBSCRIBE, NO_RTP, "SUBSCRIBE", 1 },
   { SIP_MESSAGE,  NO_RTP, "MESSAGE", 1 },
   { SIP_UPDATE,   NO_RTP, "UPDATE", 0 },
   { SIP_INFO,  NO_RTP, "INFO", 0 },
   { SIP_CANCEL,   NO_RTP, "CANCEL", 0 },
   { SIP_PUBLISH,  NO_RTP, "PUBLISH", 1 }
};

/*! \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" },
};

/*!  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
*/
#define SUPPORTED    1
#define NOT_SUPPORTED      0

#define SIP_OPT_REPLACES   (1 << 0)
#define SIP_OPT_100REL     (1 << 1)
#define SIP_OPT_TIMER      (1 << 2)
#define SIP_OPT_EARLY_SESSION (1 << 3)
#define SIP_OPT_JOIN    (1 << 4)
#define SIP_OPT_PATH    (1 << 5)
#define SIP_OPT_PREF    (1 << 6)
#define SIP_OPT_PRECONDITION  (1 << 7)
#define SIP_OPT_PRIVACY    (1 << 8)
#define SIP_OPT_SDP_ANAT   (1 << 9)
#define SIP_OPT_SEC_AGREE  (1 << 10)
#define SIP_OPT_EVENTLIST  (1 << 11)
#define SIP_OPT_GRUU    (1 << 12)
#define SIP_OPT_TARGET_DIALOG (1 << 13)

/*! \brief List of well-known SIP options. If we get this in a require,
   we should check the list and answer accordingly. */
static const struct cfsip_options {
   int id;        /*!< Bitmap ID */
   int supported;    /*!< Supported by Asterisk ? */
   char * const text;   /*!< Text id, as in standard */
} sip_options[] = {
   /* Replaces: header for transfer */
   { SIP_OPT_REPLACES,  SUPPORTED,  "replaces" },  
   /* RFC3262: PRACK 100% reliability */
   { SIP_OPT_100REL, NOT_SUPPORTED, "100rel" }, 
   /* SIP Session Timers */
   { SIP_OPT_TIMER,  NOT_SUPPORTED, "timer" },
   /* RFC3959: SIP Early session support */
   { SIP_OPT_EARLY_SESSION, NOT_SUPPORTED,   "early-session" },
   /* SIP Join header support */
   { SIP_OPT_JOIN,      NOT_SUPPORTED, "join" },
   /* RFC3327: Path support */
   { SIP_OPT_PATH,      NOT_SUPPORTED, "path" },
   /* RFC3840: Callee preferences */
   { SIP_OPT_PREF,      NOT_SUPPORTED, "pref" },
   /* RFC3312: Precondition support */
   { SIP_OPT_PRECONDITION, NOT_SUPPORTED, "precondition" },
   /* RFC3323: Privacy with proxies*/
   { SIP_OPT_PRIVACY,   NOT_SUPPORTED, "privacy" },
   /* RFC4092: Usage of the SDP ANAT Semantics in the SIP */
   { SIP_OPT_SDP_ANAT,  NOT_SUPPORTED, "sdp-anat" },
   /* RFC3329: Security agreement mechanism */
   { SIP_OPT_SEC_AGREE, NOT_SUPPORTED, "sec_agree" },
   /* SIMPLE events:  draft-ietf-simple-event-list-07.txt */
   { SIP_OPT_EVENTLIST, NOT_SUPPORTED, "eventlist" },
   /* GRUU: Globally Routable User Agent URI's */
   { SIP_OPT_GRUU,      NOT_SUPPORTED, "gruu" },
   /* Target-dialog: draft-ietf-sip-target-dialog-00.txt */
   { SIP_OPT_TARGET_DIALOG,NOT_SUPPORTED, "target-dialog" },
};


/*! \brief SIP Methods we support */
#define ALLOWED_METHODS "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, SUBSCRIBE, NOTIFY"

/*! \brief SIP Extensions we support */
#define SUPPORTED_EXTENSIONS "replaces" 

#define DEFAULT_SIP_PORT   5060  /*!< From RFC 3261 (former 2543) */
#define SIP_MAX_PACKET     4096  /*!< Also from RFC 3261 (2543), should sub headers tho */

static char default_useragent[AST_MAX_EXTENSION] = DEFAULT_USERAGENT;

#define DEFAULT_CONTEXT "default"
static char default_context[AST_MAX_CONTEXT] = DEFAULT_CONTEXT;
static char default_subscribecontext[AST_MAX_CONTEXT];

#define DEFAULT_VMEXTEN "asterisk"
static char global_vmexten[AST_MAX_EXTENSION] = DEFAULT_VMEXTEN;

static char default_language[MAX_LANGUAGE] = "";

#define DEFAULT_CALLERID "asterisk"
static char default_callerid[AST_MAX_EXTENSION] = DEFAULT_CALLERID;

static char default_fromdomain[AST_MAX_EXTENSION] = "";

#define DEFAULT_NOTIFYMIME "application/simple-message-summary"
static char default_notifymime[AST_MAX_EXTENSION] = DEFAULT_NOTIFYMIME;

static int global_notifyringing = 1;   /*!< Send notifications on ringing */

static int global_alwaysauthreject = 0;   /*!< Send 401 Unauthorized for all failing requests */

static int default_qualify = 0;     /*!< Default Qualify= setting */

static struct ast_flags global_flags = {0};     /*!< global SIP_ flags */
static struct ast_flags global_flags_page2 = {0};  /*!< more global SIP_ flags */

static int srvlookup = 0;     /*!< SRV Lookup on or off. Default is off, RFC behavior is on */

static int pedanticsipchecking = 0; /*!< Extra checking ?  Default off */

static int autocreatepeer = 0;      /*!< Auto creation of peers at registration? Default off. */

static int relaxdtmf = 0;

static int global_rtptimeout = 0;

static int global_rtpholdtimeout = 0;

static int global_rtpkeepalive = 0;

static int global_reg_timeout = DEFAULT_REGISTRATION_TIMEOUT;  
static int global_regattempts_max = 0;

/* Object counters */
static int suserobjs = 0;
static int ruserobjs = 0;
static int speerobjs = 0;
static int rpeerobjs = 0;
static int apeerobjs = 0;
static int regobjs = 0;

static int global_allowguest = 1;    /*!< allow unauthenticated users/peers to connect? */

#define DEFAULT_MWITIME 10
static int global_mwitime = DEFAULT_MWITIME; /*!< Time between MWI checks for peers */

static int usecnt =0;
AST_MUTEX_DEFINE_STATIC(usecnt_lock);

AST_MUTEX_DEFINE_STATIC(rand_lock);

/*! \brief Protect the interface list (of sip_pvt's) */
AST_MUTEX_DEFINE_STATIC(iflock);

/*! \brief 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(netlock);

AST_MUTEX_DEFINE_STATIC(monlock);

/*! \brief This is the thread for the monitor which checks for input on the channels
   which are not currently in use.  */
static pthread_t monitor_thread = AST_PTHREADT_NULL;

static int restart_monitor(void);

/*! \brief Codecs that we support by default: */
static int global_capability = AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_GSM | AST_FORMAT_H263;

static struct in_addr __ourip;
static struct sockaddr_in outboundproxyip;
static int ourport;

#define SIP_DEBUG_CONFIG 1 << 0
#define SIP_DEBUG_CONSOLE 1 << 1
static int sipdebug = 0;
static struct sockaddr_in debugaddr;

static int tos = 0;

static int videosupport = 0;

static int compactheaders = 0;            /*!< send compact sip headers */

static int recordhistory = 0;          /*!< Record SIP history. Off by default */
static int dumphistory = 0;            /*!< Dump history to verbose before destroying SIP dialog */

static char global_musicclass[MAX_MUSICCLASS] = "";   /*!< Global music on hold class */
#define DEFAULT_REALM   "asterisk"
static char global_realm[MAXHOSTNAMELEN] = DEFAULT_REALM;   /*!< Default realm */
static char regcontext[AST_MAX_CONTEXT] = "";      /*!< Context for auto-extensions */

#define DEFAULT_EXPIRY 900          /*!< Expire slowly */
static int expiry = DEFAULT_EXPIRY;

#define DEFAULT_T1MIN   100            /*!< Minimial T1 roundtrip time - ms */

static struct sched_context *sched;
static struct io_context *io;
static int *sipsock_read_id;

#define SIP_MAX_HEADERS    64       /*!< Max amount of SIP headers to read */
#define SIP_MAX_LINES      64       /*!< Max amount of lines in SIP attachment (like SDP) */

#define DEC_CALL_LIMIT  0
#define INC_CALL_LIMIT  1

static struct ast_codec_pref prefs;


/*! \brief sip_request: The data grabbed from the UDP socket */
struct sip_request {
   char *rlPart1;       /*!< SIP Method Name or "SIP/2.0" protocol version */
   char *rlPart2;       /*!< The Request URI or Response Status */
   int len;    /*!< Length */
   int headers;      /*!< # of SIP Headers */
   int method;    /*!< Method of this request */
   char *header[SIP_MAX_HEADERS];
   int lines;     /*!< Body Content */
   char *line[SIP_MAX_LINES];
   char data[SIP_MAX_PACKET];
   int debug;     /*!< Debug flag for this packet */
   unsigned int flags;  /*!< SIP_PKT Flags for this packet */
   unsigned int sdp_start; /*!< the line number where the SDP begins */
   unsigned int sdp_end;   /*!< the line number where the SDP ends */
};

struct sip_pkt;

/*! \brief Parameters to the transmit_invite function */
struct sip_invite_param {
   char *distinctive_ring; /*!< Distinctive ring header */
   char *osptoken;      /*!< OSP token for this call */
   int addsipheaders;   /*!< Add extra SIP headers */
   char *uri_options;   /*!< URI options to add to the URI */
   char *vxml_url;      /*!< VXML url for Cisco phones */
   char *auth;    /*!< Authentication */
   char *authheader; /*!< Auth header */
   enum sip_auth_type auth_type; /*!< Authentication type */
};

struct sip_route {
   struct sip_route *next;
   char hop[0];
};

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

struct domain {
   char domain[MAXHOSTNAMELEN];     /*!< SIP domain we are responsible for */
   char context[AST_MAX_EXTENSION]; /*!< Incoming context for this domain */
   enum domain_mode mode;        /*!< How did we find this domain? */
   AST_LIST_ENTRY(domain) list;     /*!< List mechanics */
};

static AST_LIST_HEAD_STATIC(domain_list, domain);  /*!< The SIP domain list */

int allow_external_domains;      /*!< Accept calls to external SIP domains? */

/*! \brief sip_history: Structure for saving transactions within a SIP dialog */
struct sip_history {
   char event[80];
   struct sip_history *next;
};

/*! \brief sip_auth: Creadentials for authentication to other SIP services */
struct sip_auth {
   char realm[AST_MAX_EXTENSION];  /*!< Realm in which these credentials are valid */
   char username[256];             /*!< Username */
   char secret[256];               /*!< Secret */
   char md5secret[256];            /*!< MD5Secret */
   struct sip_auth *next;          /*!< Next auth structure in list */
};

#define SIP_ALREADYGONE    (1 << 0) /*!< Whether or not we've already been destroyed by our peer */
#define SIP_NEEDDESTROY    (1 << 1) /*!< if we need to be destroyed */
#define SIP_NOVIDEO     (1 << 2) /*!< Didn't get video in invite, don't offer */
#define SIP_RINGING     (1 << 3) /*!< Have sent 180 ringing */
#define SIP_PROGRESS_SENT  (1 << 4) /*!< Have sent 183 message progress */
#define SIP_NEEDREINVITE   (1 << 5) /*!< Do we need to send another reinvite? */
#define SIP_PENDINGBYE     (1 << 6) /*!< Need to send bye after we ack? */
#define SIP_GOTREFER    (1 << 7) /*!< Got a refer? */
#define SIP_PROMISCREDIR   (1 << 8) /*!< Promiscuous redirection */
#define SIP_TRUSTRPID      (1 << 9) /*!< Trust RPID headers? */
#define SIP_USEREQPHONE    (1 << 10)   /*!< Add user=phone to numeric URI. Default off */
#define SIP_REALTIME    (1 << 11)   /*!< Flag for realtime users */
#define SIP_USECLIENTCODE  (1 << 12)   /*!< Trust X-ClientCode info message */
#define SIP_OUTGOING    (1 << 13)   /*!< Is this an outgoing call? */
#define SIP_SELFDESTRUCT   (1 << 14)   /*!< This is an autocreated peer */
#define SIP_CAN_BYE     (1 << 15)   /*!< Can we send BYE for this dialog? */
/* --- Choices for DTMF support in SIP channel */
#define SIP_DTMF     (3 << 16)   /*!< three settings, uses two bits */
#define SIP_DTMF_RFC2833   (0 << 16)   /*!< RTP DTMF */
#define SIP_DTMF_INBAND    (1 << 16)   /*!< Inband audio, only for ULAW/ALAW */
#define SIP_DTMF_INFO      (2 << 16)   /*!< SIP Info messages */
#define SIP_DTMF_AUTO      (3 << 16)   /*!< AUTO switch between rfc2833 and in-band DTMF */
/* NAT settings */
#define SIP_NAT         (3 << 18)   /*!< four settings, uses two bits */
#define SIP_NAT_NEVER      (0 << 18)   /*!< No nat support */
#define SIP_NAT_RFC3581    (1 << 18)
#define SIP_NAT_ROUTE      (2 << 18)
#define SIP_NAT_ALWAYS     (3 << 18)
/* re-INVITE related settings */
#define SIP_REINVITE    (3 << 20)   /*!< two bits used */
#define SIP_CAN_REINVITE   (1 << 20)   /*!< allow peers to be reinvited to send media directly p2p */
#define SIP_REINVITE_UPDATE   (2 << 20)   /*!< use UPDATE (RFC3311) when reinviting this peer */
/* "insecure" settings */
#define SIP_INSECURE_PORT  (1 << 22)   /*!< don't require matching port for incoming requests */
#define SIP_INSECURE_INVITE   (1 << 23)   /*!< don't require authentication for incoming INVITEs */
/* Sending PROGRESS in-band settings */
#define SIP_PROG_INBAND    (3 << 24)   /*!< three settings, uses two bits */
#define SIP_PROG_INBAND_NEVER (0 << 24)
#define SIP_PROG_INBAND_NO (1 << 24)
#define SIP_PROG_INBAND_YES   (2 << 24)
/* Open Settlement Protocol authentication */
#define SIP_OSPAUTH     (3 << 26)   /*!< four settings, uses two bits */
#define SIP_OSPAUTH_NO     (0 << 26)
#define SIP_OSPAUTH_GATEWAY   (1 << 26)
#define SIP_OSPAUTH_PROXY  (2 << 26)
#define SIP_OSPAUTH_EXCLUSIVE (3 << 26)
/* Call states */
#define SIP_CALL_ONHOLD    (1 << 28)    
#define SIP_CALL_LIMIT     (1 << 29)
/* Remote Party-ID Support */
#define SIP_SENDRPID    (1 << 30)
#define SIP_INC_COUNT      (1 << 31)   /* Did this connection increment the counter of in-use calls? */

#define SIP_FLAGS_TO_COPY \
   (SIP_PROMISCREDIR | SIP_TRUSTRPID | SIP_SENDRPID | SIP_DTMF | SIP_REINVITE | \
    SIP_PROG_INBAND | SIP_OSPAUTH | SIP_USECLIENTCODE | SIP_NAT | \
    SIP_USEREQPHONE | SIP_INSECURE_PORT | SIP_INSECURE_INVITE)

/* a new page of flags for peer */
#define SIP_PAGE2_RTCACHEFRIENDS (1 << 0)
#define SIP_PAGE2_RTUPDATE    (1 << 1)
#define SIP_PAGE2_RTAUTOCLEAR    (1 << 2)
#define SIP_PAGE2_IGNOREREGEXPIRE   (1 << 3)
#define SIP_PAGE2_RT_FROMCONTACT    (1 << 4)
#define SIP_PAGE2_DYNAMIC     (1 << 5) /*!< Is this a dynamic peer? */

/* SIP packet flags */
#define SIP_PKT_DEBUG      (1 << 0) /*!< Debug this packet */
#define SIP_PKT_WITH_TOTAG (1 << 1) /*!< This packet has a to-tag */

static int global_rtautoclear;

/*! \brief sip_pvt: PVT structures are used for each SIP conversation, ie. a call  */
static struct sip_pvt {
   ast_mutex_t lock;       /*!< Channel private lock */
   int method;          /*!< SIP method of this packet */
   char callid[128];       /*!< Global CallID */
   char randdata[80];         /*!< Random data */
   struct ast_codec_pref prefs;     /*!< codec prefs */
   unsigned int ocseq;        /*!< Current outgoing seqno */
   unsigned int icseq;        /*!< Current incoming seqno */
   ast_group_t callgroup;        /*!< Call group */
   ast_group_t pickupgroup;      /*!< Pickup group */
   int lastinvite;            /*!< Last Cseq of invite */
   unsigned int flags;        /*!< SIP_ flags */   
   int timer_t1;           /*!< SIP timer T1, ms rtt */
   unsigned int sipoptions;      /*!< Supported SIP sipoptions on the other end */
   int capability;            /*!< Special capability (codec) */
   int jointcapability;       /*!< Supported capability at both ends (codecs ) */
   int peercapability;        /*!< Supported peer capability */
   int prefcodec;          /*!< Preferred codec (outbound only) */
   int noncodeccapability;
   int jointnoncodeccapability;
   int callingpres;        /*!< Calling presentation */
   int authtries;          /*!< Times we've tried to authenticate */
   int expiry;          /*!< How long we take to expire */
   int branch;          /*!< One random number */
   char tag[11];           /*!< Another random number */
   int sessionid;          /*!< SDP Session ID */
   int sessionversion;        /*!< SDP Session Version */
   struct sockaddr_in sa;        /*!< Our peer */
   struct sockaddr_in redirip;      /*!< Where our RTP should be going if not to us */
   struct sockaddr_in vredirip;     /*!< Where our Video RTP should be going if not to us */
   int redircodecs;        /*!< Redirect codecs */
   struct sockaddr_in recv;      /*!< Received as */
   struct in_addr ourip;         /*!< Our IP */
   struct ast_channel *owner;    /*!< Who owns us */
   char exten[AST_MAX_EXTENSION];      /*!< Extension where to start */
   char refer_to[AST_MAX_EXTENSION];   /*!< Place to store REFER-TO extension */
   char referred_by[AST_MAX_EXTENSION];   /*!< Place to store REFERRED-BY extension */
   char refer_contact[SIP_LEN_CONTACT];   /*!< Place to store Contact info from a REFER extension */
   struct sip_pvt *refer_call;      /*!< Call we are referring */
   struct sip_route *route;      /*!< Head of linked list of routing steps (fm Record-Route) */
   int route_persistant;         /*!< Is this the "real" route? */
   char from[256];            /*!< The From: header */
   char useragent[256];       /*!< User agent in SIP request */
   char context[AST_MAX_CONTEXT];      /*!< Context for this call */
   char subscribecontext[AST_MAX_CONTEXT];   /*!< Subscribecontext */
   char fromdomain[MAXHOSTNAMELEN]; /*!< Domain to show in the from field */
   char fromuser[AST_MAX_EXTENSION];   /*!< User to show in the user field */
   char fromname[AST_MAX_EXTENSION];   /*!< Name to show in the user field */
   char tohost[MAXHOSTNAMELEN];     /*!< Host we should put in the "to" field */
   char language[MAX_LANGUAGE];     /*!< Default language for this call */
   char musicclass[MAX_MUSICCLASS]; /*!< Music on Hold class */
   char rdnis[256];        /*!< Referring DNIS */
   char theirtag[256];        /*!< Their tag */
   char username[256];        /*!< [user] name */
   char peername[256];        /*!< [peer] name, not set if [user] */
   char authname[256];        /*!< Who we use for authentication */
   char uri[256];          /*!< Original requested URI */
   char okcontacturi[SIP_LEN_CONTACT]; /*!< URI from the 200 OK on INVITE */
   char peersecret[256];         /*!< Password */
   char peermd5secret[256];
   struct sip_auth *peerauth;    /*!< Realm authentication */
   char cid_num[256];         /*!< Caller*ID */
   char cid_name[256];        /*!< Caller*ID */
   char via[256];          /*!< Via: header */
   char fullcontact[SIP_LEN_CONTACT];  /*!< The Contact: that the UA registers with us */
   char accountcode[AST_MAX_ACCOUNT_CODE];   /*!< Account code */
   char our_contact[SIP_LEN_CONTACT];  /*!< Our contact header */
   char *rpid;          /*!< Our RPID header */
   char *rpid_from;        /*!< Our RPID From header */
   char realm[MAXHOSTNAMELEN];      /*!< Authorization realm */
   char nonce[256];        /*!< Authorization nonce */
   int noncecount;            /*!< Nonce-count */
   char opaque[256];       /*!< Opaque nonsense */
   char qop[80];           /*!< Quality of Protection, since SIP wasn't complicated enough yet. */
   char domain[MAXHOSTNAMELEN];     /*!< Authorization domain */
   char lastmsg[256];         /*!< Last Message sent/received */
   int amaflags;           /*!< AMA Flags */
   int pendinginvite;         /*!< Any pending invite */
#ifdef OSP_SUPPORT
   int osphandle;          /*!< OSP Handle for call */
   time_t ospstart;        /*!< OSP Start time */
   unsigned int osptimelimit;    /*!< OSP call duration limit */
#endif
   struct sip_request initreq;      /*!< Initial request */
   
   int maxtime;            /*!< Max time for first response */
   int initid;          /*!< Auto-congest ID if appropriate */
   int autokillid;            /*!< Auto-kill ID */
   time_t lastrtprx;       /*!< Last RTP received */
   time_t lastrtptx;       /*!< Last RTP sent */
   int rtptimeout;            /*!< RTP timeout time */
   int rtpholdtimeout;        /*!< RTP timeout when on hold */
   int rtpkeepalive;       /*!< Send RTP packets for keepalive */
   enum subscriptiontype subscribed;   /*!< Is this call a subscription?  */
   int stateid;
   int laststate;                          /*!< Last known extension state */
   int dialogver;
   
   struct ast_dsp *vad;       /*!< Voice Activation Detection dsp */
   
   struct sip_peer *peerpoke;    /*!< If this calls is to poke a peer, which one */
   struct sip_registry *registry;      /*!< If this is a REGISTER call, to which registry */
   struct ast_rtp *rtp;       /*!< RTP Session */
   struct ast_rtp *vrtp;         /*!< Video RTP session */
   struct sip_pkt *packets;      /*!< Packets scheduled for re-transmission */
   struct sip_history *history;     /*!< History of this SIP dialog */