handle improperly formatted initial requests properly (issue #5483)
[asterisk/asterisk.git] / channels / chan_sip.c
index 9097d66..fa0431a 100755 (executable)
  * at the top of the source tree.
  */
 
-/*
- *
- * Implementation of Session Initiation Protocol
+/*!
+ * \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
  */
 
 
@@ -95,6 +101,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 #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 */
@@ -197,7 +204,7 @@ enum sip_auth_type {
 
 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? */
+       int need_rtp;           /*!< when this is the 'primary' use for a pvt structure, does it need RTP? */
        char * const text;
 } sip_methods[] = {
        { SIP_UNKNOWN,   RTP,    "-UNKNOWN-" },
@@ -218,7 +225,7 @@ static const struct  cfsip_methods {
        { SIP_PUBLISH,   NO_RTP, "PUBLISH" }
 };
 
-/* Structure for conversion between compressed SIP and "normal" SIP */
+/*! \brief Structure for conversion between compressed SIP and "normal" SIP */
 static const struct cfalias {
        char * const fullname;
        char * const shortname;
@@ -243,8 +250,8 @@ static const struct cfalias {
        { "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 
+/*!  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
@@ -271,12 +278,12 @@ static const struct cfalias {
 #define SIP_OPT_GRUU           (1 << 12)
 #define SIP_OPT_TARGET_DIALOG  (1 << 13)
 
-/* List of well-known SIP options. If we get this in a require,
+/*! \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 */
+       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" },   
@@ -309,14 +316,14 @@ static const struct cfsip_options {
 };
 
 
-/* SIP Methods we support */
+/*! \brief SIP Methods we support */
 #define ALLOWED_METHODS "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, SUBSCRIBE, NOTIFY"
 
-/* SIP Extensions we support */
+/*! \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 */
+#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;
 
@@ -337,18 +344,18 @@ 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_notifyringing = 1;   /*!< Send notifications on ringing */
 
-static int default_qualify = 0;                /* Default Qualify= setting */
+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 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 srvlookup = 0;              /*!< SRV Lookup on or off. Default is off, RFC behavior is on */
 
-static int pedanticsipchecking = 0;    /* Extra checking ?  Default off */
+static int pedanticsipchecking = 0;    /*!< Extra checking ?  Default off */
 
-static int autocreatepeer = 0;         /* Auto creation of peers at registration? Default off. */
+static int autocreatepeer = 0;         /*!< Auto creation of peers at registration? Default off. */
 
 static int relaxdtmf = 0;
 
@@ -369,31 +376,31 @@ static int rpeerobjs = 0;
 static int apeerobjs = 0;
 static int regobjs = 0;
 
-static int global_allowguest = 1;    /* allow unauthenticated users/peers to connect? */
+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 global_mwitime = DEFAULT_MWITIME;   /*!< Time between MWI checks for peers */
 
 static int usecnt =0;
 AST_MUTEX_DEFINE_STATIC(usecnt_lock);
 
 
-/* Protect the interface list (of sip_pvt's) */
+/*! \brief Protect the interface list (of sip_pvt's) */
 AST_MUTEX_DEFINE_STATIC(iflock);
 
-/* Protect the monitoring thread, so only one process can kill or start it, and not
+/*! \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);
 
-/* This is the thread for the monitor which checks for input on the channels
+/*! \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);
 
-/* Codecs that we support by default: */
+/*! \brief Codecs that we support by default: */
 static int global_capability = AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_GSM | AST_FORMAT_H263;
 static int noncodeccapability = AST_RTP_DTMF;
 
@@ -410,27 +417,24 @@ static int tos = 0;
 
 static int videosupport = 0;
 
-static int compactheaders = 0;                         /* send compact sip headers */
+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 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 */
+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 */
+static char global_realm[MAXHOSTNAMELEN] = DEFAULT_REALM;      /*!< Default realm */
+static char regcontext[AST_MAX_CONTEXT] = "";          /*!< Context for auto-extensions */
 
-/* Expire slowly */
-#define DEFAULT_EXPIRY 900
+#define DEFAULT_EXPIRY 900                             /*!< Expire slowly */
 static int expiry = DEFAULT_EXPIRY;
 
 static struct sched_context *sched;
 static struct io_context *io;
-/* The private structures of the  sip channels are linked for
-   selecting outgoing channels */
-   
-#define SIP_MAX_HEADERS                64
-#define SIP_MAX_LINES          64
+
+#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
@@ -438,32 +442,33 @@ static struct io_context *io;
 static struct ast_codec_pref prefs;
 
 
-/* sip_request: The data grabbed from the UDP socket */
+/*! \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 *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;              /* SDP Content */
+       int lines;              /*!< SDP Content */
        char *line[SIP_MAX_LINES];
        char data[SIP_MAX_PACKET];
-       int debug;              /* Debug flag for this packet */
+       int debug;              /*!< Debug flag for this packet */
+       unsigned int flags;     /*!< SIP_PKT Flags for this packet */
 };
 
 struct sip_pkt;
 
-/* Parameters to the transmit_invite function */
+/*! \brief Parameters to the transmit_invite function */
 struct sip_invite_param {
-       char *distinctive_ring;
-       char *osptoken;
-       int addsipheaders;
-       char *uri_options;
-       char *vxml_url;
-       char *auth;
-       char *authheader;
-       enum sip_auth_type auth_type;
+       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 {
@@ -472,78 +477,78 @@ struct sip_route {
 };
 
 enum domain_mode {
-       SIP_DOMAIN_AUTO,
-       SIP_DOMAIN_CONFIG,
+       SIP_DOMAIN_AUTO,        /*!< This domain is auto-configured */
+       SIP_DOMAIN_CONFIG,      /*!< This domain is from configuration */
 };
 
 struct domain {
-       char domain[MAXHOSTNAMELEN];
-       char context[AST_MAX_EXTENSION];
-       enum domain_mode mode;
-       AST_LIST_ENTRY(domain) list;
+       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);
+static AST_LIST_HEAD_STATIC(domain_list, domain);      /*!< The SIP domain list */
 
-int allow_external_domains;
+int allow_external_domains;            /*!< Accept calls to external SIP domains? */
 
-/* sip_history: Structure for saving transactions within a SIP dialog */
+/*! \brief sip_history: Structure for saving transactions within a SIP dialog */
 struct sip_history {
        char event[80];
        struct sip_history *next;
 };
 
-/* sip_auth: Creadentials for authentication to other SIP services */
+/*! \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 */
+       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_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)       
-#define SIP_DYNAMIC            (1 << 15)       /* Is this a dynamic peer? */
+#define SIP_DYNAMIC            (1 << 15)       /*!< Is this a dynamic peer? */
 /* --- 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 */
+#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                        (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 */
+#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 */
+#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                (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            (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)
@@ -563,222 +568,226 @@ struct sip_auth {
 #define SIP_PAGE2_RTCACHEFRIENDS       (1 << 0)
 #define SIP_PAGE2_RTUPDATE             (1 << 1)
 #define SIP_PAGE2_RTAUTOCLEAR          (1 << 2)
-#define SIP_PAGE2_RTIGNOREREGEXPIRE    (1 << 3)
+#define SIP_PAGE2_IGNOREREGEXPIRE      (1 << 3)
+#define SIP_PAGE2_RT_FROMCONTACT       (1 << 4)
+
+/* 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 = 120;
 
-/* sip_pvt: PVT structures are used for each SIP conversation, ie. a call  */
+/*! \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[80];                        /* 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) */
+       ast_mutex_t lock;                       /*!< Channel private lock */
+       int method;                             /*!< SIP method of this packet */
+       char callid[80];                        /*!< 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 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[AST_MAX_EXTENSION];  /* 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[256];                 /* URI from the 200 OK on INVITE */
-       char peersecret[256];                   /* Password */
+       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[AST_MAX_EXTENSION];  /*!< 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[256];                 /*!< 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[128];                  /* The Contact: that the UA registers with us */
-       char accountcode[AST_MAX_ACCOUNT_CODE]; /* Account code */
-       char our_contact[256];                  /* 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 */
+       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[128];                  /*!< The Contact: that the UA registers with us */
+       char accountcode[AST_MAX_ACCOUNT_CODE]; /*!< Account code */
+       char our_contact[256];                  /*!< 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 */
+       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 */
+       struct sip_request initreq;             /*!< Initial request */
        
-       int maxtime;                            /* Max time for first response */
-       int maxforwards;                        /* keep the max-forwards info */
-       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 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 laststate;                          /*!< Last known extension state */
        int dialogver;
        
-       struct ast_dsp *vad;                    /* Voice Activation Detection dsp */
+       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 */
-       struct ast_variable *chanvars;          /* Channel variables to set for call */
-       struct sip_pvt *next;                   /* Next call in chain */
-       struct sip_invite_param *options;       /* Options for INVITE */
+       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 */
+       struct ast_variable *chanvars;          /*!< Channel variables to set for call */
+       struct sip_pvt *next;                   /*!< Next call in chain */
+       struct sip_invite_param *options;       /*!< Options for INVITE */
 } *iflist = NULL;
 
 #define FLAG_RESPONSE (1 << 0)
 #define FLAG_FATAL (1 << 1)
 
-/* sip packet - read in sipsock_read, transmitted in send_request */
+/*! \brief sip packet - read in sipsock_read, transmitted in send_request */
 struct sip_pkt {
-       struct sip_pkt *next;                   /* Next packet */
-       int retrans;                            /* Retransmission number */
-       int method;                             /* SIP method for this packet */
-       int seqno;                              /* Sequence number */
-       unsigned int flags;                     /* non-zero if this is a response packet (e.g. 200 OK) */
-       struct sip_pvt *owner;                  /* Owner call */
-       int retransid;                          /* Retransmission ID */
-       int timer_a;                            /* SIP timer A, retransmission timer */
-       int timer_t1;                           /* SIP Timer T1, estimated RTT or 500 ms */
-       int packetlen;                          /* Length of packet */
+       struct sip_pkt *next;                   /*!< Next packet */
+       int retrans;                            /*!< Retransmission number */
+       int method;                             /*!< SIP method for this packet */
+       int seqno;                              /*!< Sequence number */
+       unsigned int flags;                     /*!< non-zero if this is a response packet (e.g. 200 OK) */
+       struct sip_pvt *owner;                  /*!< Owner call */
+       int retransid;                          /*!< Retransmission ID */
+       int timer_a;                            /*!< SIP timer A, retransmission timer */
+       int timer_t1;                           /*!< SIP Timer T1, estimated RTT or 500 ms */
+       int packetlen;                          /*!< Length of packet */
        char data[0];
 };     
 
-/* Structure for SIP user data. User's place calls to us */
+/*! \brief Structure for SIP user data. User's place calls to us */
 struct sip_user {
        /* Users who can access various contexts */
        ASTOBJ_COMPONENTS(struct sip_user);
-       char secret[80];                /* Password */
-       char md5secret[80];             /* Password in md5 */
-       char context[AST_MAX_CONTEXT];  /* Default context for incoming calls */
+       char secret[80];                /*!< Password */
+       char md5secret[80];             /*!< Password in md5 */
+       char context[AST_MAX_CONTEXT];  /*!< Default context for incoming calls */
        char subscribecontext[AST_MAX_CONTEXT]; /* Default context for subscriptions */
-       char cid_num[80];               /* Caller ID num */
-       char cid_name[80];              /* Caller ID name */
+       char cid_num[80];               /*!< Caller ID num */
+       char cid_name[80];              /*!< Caller ID name */
        char accountcode[AST_MAX_ACCOUNT_CODE]; /* Account code */
-       char language[MAX_LANGUAGE];    /* Default language for this user */
-       char musicclass[MAX_MUSICCLASS];/* Music on Hold class */
-       char useragent[256];            /* User agent in SIP request */
-       struct ast_codec_pref prefs;    /* codec prefs */
-       ast_group_t callgroup;          /* Call group */
-       ast_group_t pickupgroup;        /* Pickup Group */
-       unsigned int flags;             /* SIP flags */ 
-       unsigned int sipoptions;        /* Supported SIP options */
-       struct ast_flags flags_page2;   /* SIP_PAGE2 flags */
-       int amaflags;                   /* AMA flags for billing */
-       int callingpres;                /* Calling id presentation */
-       int capability;                 /* Codec capability */
-       int inUse;                      /* Number of calls in use */
-       int call_limit;                 /* Limit of concurrent calls */
-       struct ast_ha *ha;              /* ACL setting */
-       struct ast_variable *chanvars;  /* Variables to set for channel created by user */
+       char language[MAX_LANGUAGE];    /*!< Default language for this user */
+       char musicclass[MAX_MUSICCLASS];/*!< Music on Hold class */
+       char useragent[256];            /*!< User agent in SIP request */
+       struct ast_codec_pref prefs;    /*!< codec prefs */
+       ast_group_t callgroup;          /*!< Call group */
+       ast_group_t pickupgroup;        /*!< Pickup Group */
+       unsigned int flags;             /*!< SIP flags */       
+       unsigned int sipoptions;        /*!< Supported SIP options */
+       struct ast_flags flags_page2;   /*!< SIP_PAGE2 flags */
+       int amaflags;                   /*!< AMA flags for billing */
+       int callingpres;                /*!< Calling id presentation */
+       int capability;                 /*!< Codec capability */
+       int inUse;                      /*!< Number of calls in use */
+       int call_limit;                 /*!< Limit of concurrent calls */
+       struct ast_ha *ha;              /*!< ACL setting */
+       struct ast_variable *chanvars;  /*!< Variables to set for channel created by user */
 };
 
 /* Structure for SIP peer data, we place calls to peers if registered  or fixed IP address (host) */
 struct sip_peer {
-       ASTOBJ_COMPONENTS(struct sip_peer);     /* name, refcount, objflags,  object pointers */
-                                       /* peer->name is the unique name of this object */
-       char secret[80];                /* Password */
-       char md5secret[80];             /* Password in MD5 */
-       struct sip_auth *auth;          /* Realm authentication list */
-       char context[AST_MAX_CONTEXT];  /* Default context for incoming calls */
-       char subscribecontext[AST_MAX_CONTEXT]; /* Default context for subscriptions */
-       char username[80];              /* Temporary username until registration */ 
-       char accountcode[AST_MAX_ACCOUNT_CODE]; /* Account code */
-       int amaflags;                   /* AMA Flags (for billing) */
-       char tohost[MAXHOSTNAMELEN];    /* If not dynamic, IP address */
-       char regexten[AST_MAX_EXTENSION]; /* Extension to register (if regcontext is used) */
-       char fromuser[80];              /* From: user when calling this peer */
-       char fromdomain[MAXHOSTNAMELEN];        /* From: domain when calling this peer */
-       char fullcontact[256];          /* Contact registered with us (not in sip.conf) */
-       char cid_num[80];               /* Caller ID num */
-       char cid_name[80];              /* Caller ID name */
-       int callingpres;                /* Calling id presentation */
-       int inUse;                      /* Number of calls in use */
-       int call_limit;                 /* Limit of concurrent calls */
-       char vmexten[AST_MAX_EXTENSION];        /* Dialplan extension for MWI notify message*/
-       char mailbox[AST_MAX_EXTENSION]; /* Mailbox setting for MWI checks */
-       char language[MAX_LANGUAGE];    /* Default language for prompts */
-       char musicclass[MAX_MUSICCLASS];/* Music on Hold class */
-       char useragent[256];            /* User agent in SIP request (saved from registration) */
-       struct ast_codec_pref prefs;    /* codec prefs */
+       ASTOBJ_COMPONENTS(struct sip_peer);     /*!< name, refcount, objflags,  object pointers */
+                                       /*!< peer->name is the unique name of this object */
+       char secret[80];                /*!< Password */
+       char md5secret[80];             /*!< Password in MD5 */
+       struct sip_auth *auth;          /*!< Realm authentication list */
+       char context[AST_MAX_CONTEXT];  /*!< Default context for incoming calls */
+       char subscribecontext[AST_MAX_CONTEXT]; /*!< Default context for subscriptions */
+       char username[80];              /*!< Temporary username until registration */ 
+       char accountcode[AST_MAX_ACCOUNT_CODE]; /*!< Account code */
+       int amaflags;                   /*!< AMA Flags (for billing) */
+       char tohost[MAXHOSTNAMELEN];    /*!< If not dynamic, IP address */
+       char regexten[AST_MAX_EXTENSION]; /*!< Extension to register (if regcontext is used) */
+       char fromuser[80];              /*!< From: user when calling this peer */
+       char fromdomain[MAXHOSTNAMELEN];        /*!< From: domain when calling this peer */
+       char fullcontact[256];          /*!< Contact registered with us (not in sip.conf) */
+       char cid_num[80];               /*!< Caller ID num */
+       char cid_name[80];              /*!< Caller ID name */
+       int callingpres;                /*!< Calling id presentation */
+       int inUse;                      /*!< Number of calls in use */
+       int call_limit;                 /*!< Limit of concurrent calls */
+       char vmexten[AST_MAX_EXTENSION]; /*!< Dialplan extension for MWI notify message*/
+       char mailbox[AST_MAX_EXTENSION]; /*!< Mailbox setting for MWI checks */
+       char language[MAX_LANGUAGE];    /*!<  Default language for prompts */
+       char musicclass[MAX_MUSICCLASS];/*!<  Music on Hold class */
+       char useragent[256];            /*!<  User agent in SIP request (saved from registration) */
+       struct ast_codec_pref prefs;    /*!<  codec prefs */
        int lastmsgssent;
-       time_t  lastmsgcheck;           /* Last time we checked for MWI */
-       unsigned int flags;             /* SIP flags */ 
-       unsigned int sipoptions;        /* Supported SIP options */
-       struct ast_flags flags_page2;   /* SIP_PAGE2 flags */
-       int expire;                     /* When to expire this peer registration */
-       int capability;                 /* Codec capability */
-       int rtptimeout;                 /* RTP timeout */
-       int rtpholdtimeout;             /* RTP Hold Timeout */
-       int rtpkeepalive;               /* Send RTP packets for keepalive */
-       ast_group_t callgroup;          /* Call group */
-       ast_group_t pickupgroup;        /* Pickup group */
-       struct ast_dnsmgr_entry *dnsmgr;/* DNS refresh manager for peer */
-       struct sockaddr_in addr;        /* IP address of peer */
+       time_t  lastmsgcheck;           /*!<  Last time we checked for MWI */
+       unsigned int flags;             /*!<  SIP flags */      
+       unsigned int sipoptions;        /*!<  Supported SIP options */
+       struct ast_flags flags_page2;   /*!<  SIP_PAGE2 flags */
+       int expire;                     /*!<  When to expire this peer registration */
+       int capability;                 /*!<  Codec capability */
+       int rtptimeout;                 /*!<  RTP timeout */
+       int rtpholdtimeout;             /*!<  RTP Hold Timeout */
+       int rtpkeepalive;               /*!<  Send RTP packets for keepalive */
+       ast_group_t callgroup;          /*!<  Call group */
+       ast_group_t pickupgroup;        /*!<  Pickup group */
+       struct ast_dnsmgr_entry *dnsmgr;/*!<  DNS refresh manager for peer */
+       struct sockaddr_in addr;        /*!<  IP address of peer */
 
        /* Qualification */
-       struct sip_pvt *call;           /* Call pointer */
-       int pokeexpire;                 /* When to expire poke (qualify= checking) */
-       int lastms;                     /* How long last response took (in ms), or -1 for no response */
-       int maxms;                      /* Max ms we will accept for the host to be up, 0 to not monitor */
-       struct timeval ps;              /* Ping send time */
+       struct sip_pvt *call;           /*!<  Call pointer */
+       int pokeexpire;                 /*!<  When to expire poke (qualify= checking) */
+       int lastms;                     /*!<  How long last response took (in ms), or -1 for no response */
+       int maxms;                      /*!<  Max ms we will accept for the host to be up, 0 to not monitor */
+       struct timeval ps;              /*!<  Ping send time */
        
-       struct sockaddr_in defaddr;     /* Default IP address, used until registration */
-       struct ast_ha *ha;              /* Access control list */
-       struct ast_variable *chanvars;  /* Variables to set for channel created by user */
+       struct sockaddr_in defaddr;     /*!<  Default IP address, used until registration */
+       struct ast_ha *ha;              /*!<  Access control list */
+       struct ast_variable *chanvars;  /*!<  Variables to set for channel created by user */
        int lastmsg;
 };
 
@@ -796,50 +805,50 @@ static int sip_reloading = 0;
 #define REG_STATE_FAILED               7
 
 
-/* sip_registry: Registrations with other SIP proxies */
+/*! \brief sip_registry: Registrations with other SIP proxies */
 struct sip_registry {
        ASTOBJ_COMPONENTS_FULL(struct sip_registry,1,1);
-       int portno;                     /* Optional port override */
-       char username[80];              /* Who we are registering as */
-       char authuser[80];              /* Who we *authenticate* as */
-       char hostname[MAXHOSTNAMELEN];  /* Domain or host we register to */
-       char secret[80];                /* Password or key name in []'s */      
-       char md5secret[80];
-       char contact[256];              /* Contact extension */
+       int portno;                     /*!<  Optional port override */
+       char username[80];              /*!<  Who we are registering as */
+       char authuser[80];              /*!< Who we *authenticate* as */
+       char hostname[MAXHOSTNAMELEN];  /*!< Domain or host we register to */
+       char secret[80];                /*!< Password in clear text */  
+       char md5secret[80];             /*!< Password in md5 */
+       char contact[256];              /*!< Contact extension */
        char random[80];
-       int expire;                     /* Sched ID of expiration */
-       int regattempts;                /* Number of attempts (since the last success) */
-       int timeout;                    /* sched id of sip_reg_timeout */
-       int refresh;                    /* How often to refresh */
-       struct sip_pvt *call;           /* create a sip_pvt structure for each outbound "registration call" in progress */
-       int regstate;                   /* Registration state (see above) */
-       int callid_valid;               /* 0 means we haven't chosen callid for this registry yet. */
-       char callid[80];                /* Global CallID for this registry */
-       unsigned int ocseq;             /* Sequence number we got to for REGISTERs for this registry */
-       struct sockaddr_in us;          /* Who the server thinks we are */
+       int expire;                     /*!< Sched ID of expiration */
+       int regattempts;                /*!< Number of attempts (since the last success) */
+       int timeout;                    /*!< sched id of sip_reg_timeout */
+       int refresh;                    /*!< How often to refresh */
+       struct sip_pvt *call;           /*!< create a sip_pvt structure for each outbound "registration call" in progress */
+       int regstate;                   /*!< Registration state (see above) */
+       int callid_valid;               /*!< 0 means we haven't chosen callid for this registry yet. */
+       char callid[80];                /*!< Global CallID for this registry */
+       unsigned int ocseq;             /*!< Sequence number we got to for REGISTERs for this registry */
+       struct sockaddr_in us;          /*!< Who the server thinks we are */
        
                                        /* Saved headers */
-       char realm[MAXHOSTNAMELEN];     /* Authorization realm */
-       char nonce[256];                /* Authorization nonce */
-       char domain[MAXHOSTNAMELEN];    /* Authorization domain */
-       char opaque[256];               /* Opaque nonsense */
-       char qop[80];                   /* Quality of Protection. */
-       int noncecount;                         /* Nonce-count */
+       char realm[MAXHOSTNAMELEN];     /*!< Authorization realm */
+       char nonce[256];                /*!< Authorization nonce */
+       char domain[MAXHOSTNAMELEN];    /*!< Authorization domain */
+       char opaque[256];               /*!< Opaque nonsense */
+       char qop[80];                   /*!< Quality of Protection. */
+       int noncecount;                 /*!< Nonce-count */
  
-       char lastmsg[256];              /* Last Message sent/received */
+       char lastmsg[256];              /*!< Last Message sent/received */
 };
 
-/*--- The user list: Users and friends ---*/
+/*! \brief  The user list: Users and friends ---*/
 static struct ast_user_list {
        ASTOBJ_CONTAINER_COMPONENTS(struct sip_user);
 } userl;
 
-/*--- The peer list: Peers and Friends ---*/
+/*! \brief  The peer list: Peers and Friends ---*/
 static struct ast_peer_list {
        ASTOBJ_CONTAINER_COMPONENTS(struct sip_peer);
 } peerl;
 
-/*--- The register list: Other SIP proxys we register with and call ---*/
+/*! \brief  The register list: Other SIP proxys we register with and call ---*/
 static struct ast_register_list {
        ASTOBJ_CONTAINER_COMPONENTS(struct sip_registry);
        int recheck;
@@ -861,7 +870,7 @@ static struct ast_ha *localaddr;
 /* The list of manual NOTIFY types we know how to send */
 struct ast_config *notify_types;
 
-static struct sip_auth *authl;          /* Authentication list */
+static struct sip_auth *authl;          /*!< Authentication list */
 
 
 static struct ast_frame  *sip_read(struct ast_channel *ast);
@@ -910,8 +919,9 @@ static int determine_firstline_parts(struct sip_request *req);
 static void sip_dump_history(struct sip_pvt *dialog);  /* Dump history to LOG_DEBUG at end of dialog, before destroying data */
 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype);
 static int transmit_state_notify(struct sip_pvt *p, int state, int full, int substate);
+static char *gettag(struct sip_request *req, char *header, char *tagbuf, int tagbufsize);
 
-/* Definition of this channel for channel registration */
+/*! \brief Definition of this channel for PBX channel registration */
 static const struct ast_channel_tech sip_tech = {
        .type = channeltype,
        .description = "Session Initiation Protocol (SIP)",
@@ -933,16 +943,16 @@ static const struct ast_channel_tech sip_tech = {
        .send_text = sip_sendtext,
 };
 
-/*--- find_sip_method: Find SIP method from header */
+/*! \brief  find_sip_method: Find SIP method from header
+ * Strictly speaking, SIP methods are case SENSITIVE, but we don't check 
+ * following Jon Postel's rule: Be gentle in what you accept, strict with what you send */
 int find_sip_method(char *msg)
 {
        int i, res = 0;
        
-       if (!msg || ast_strlen_zero(msg))
+       if (ast_strlen_zero(msg))
                return 0;
 
-       /* Strictly speaking, SIP methods are case SENSITIVE, but we don't check */
-       /* following Jon Postel's rule: Be gentle in what you accept, strict with what you send */
        for (i = 1; (i < (sizeof(sip_methods) / sizeof(sip_methods[0]))) && !res; i++) {
                if (!strcasecmp(sip_methods[i].text, msg)) 
                        res = sip_methods[i].id;
@@ -950,7 +960,7 @@ int find_sip_method(char *msg)
        return res;
 }
 
-/*--- parse_sip_options: Parse supported header in incoming packet */
+/*! \brief  parse_sip_options: Parse supported header in incoming packet */
 unsigned int parse_sip_options(struct sip_pvt *pvt, char *supported)
 {
        char *next = NULL;
@@ -959,7 +969,7 @@ unsigned int parse_sip_options(struct sip_pvt *pvt, char *supported)
        int i;
        unsigned int profile = 0;
 
-       if (!supported || ast_strlen_zero(supported) )
+       if (ast_strlen_zero(supported) )
                return 0;
 
        if (option_debug > 2 && sipdebug)
@@ -997,7 +1007,7 @@ unsigned int parse_sip_options(struct sip_pvt *pvt, char *supported)
        return profile;
 }
 
-/*--- sip_debug_test_addr: See if we pass debug IP filter */
+/*! \brief  sip_debug_test_addr: See if we pass debug IP filter */
 static inline int sip_debug_test_addr(struct sockaddr_in *addr) 
 {
        if (sipdebug == 0)
@@ -1011,7 +1021,7 @@ static inline int sip_debug_test_addr(struct sockaddr_in *addr)
        return 1;
 }
 
-/*--- sip_debug_test_pvt: Test PVT for debugging output */
+/*! \brief  sip_debug_test_pvt: Test PVT for debugging output */
 static inline int sip_debug_test_pvt(struct sip_pvt *p) 
 {
        if (sipdebug == 0)
@@ -1020,7 +1030,7 @@ static inline int sip_debug_test_pvt(struct sip_pvt *p)
 }
 
 
-/*--- __sip_xmit: Transmit SIP message ---*/
+/*! \brief  __sip_xmit: Transmit SIP message ---*/
 static int __sip_xmit(struct sip_pvt *p, char *data, int len)
 {
        int res;
@@ -1030,15 +1040,16 @@ static int __sip_xmit(struct sip_pvt *p, char *data, int len)
                res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->recv, sizeof(struct sockaddr_in));
        else
                res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->sa, sizeof(struct sockaddr_in));
+
        if (res != len) {
-               ast_log(LOG_WARNING, "sip_xmit of %p (len %d) to %s returned %d: %s\n", data, len, ast_inet_ntoa(iabuf, sizeof(iabuf), p->sa.sin_addr), res, strerror(errno));
+               ast_log(LOG_WARNING, "sip_xmit of %p (len %d) to %s:%d returned %d: %s\n", data, len, ast_inet_ntoa(iabuf, sizeof(iabuf), p->sa.sin_addr), res, ntohs(p->sa.sin_port), strerror(errno));
        }
        return res;
 }
 
 static void sip_destroy(struct sip_pvt *p);
 
-/*--- build_via: Build a Via header for a request ---*/
+/*! \brief  build_via: Build a Via header for a request ---*/
 static void build_via(struct sip_pvt *p, char *buf, int len)
 {
        char iabuf[INET_ADDRSTRLEN];
@@ -1050,7 +1061,7 @@ static void build_via(struct sip_pvt *p, char *buf, int len)
                snprintf(buf, len, "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ourport, p->branch);
 }
 
-/*--- ast_sip_ouraddrfor: NAT fix - decide which IP address to use for ASterisk server? ---*/
+/*! \brief  ast_sip_ouraddrfor: NAT fix - decide which IP address to use for ASterisk server? ---*/
 /* Only used for outbound registrations */
 static int ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us)
 {
@@ -1085,7 +1096,7 @@ static int ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us)
        return 0;
 }
 
-/*--- append_history: Append to SIP dialog history */
+/*! \brief  append_history: Append to SIP dialog history */
 /*     Always returns 0 */
 static int append_history(struct sip_pvt *p, const char *event, const char *data)
 {
@@ -1121,7 +1132,7 @@ static int append_history(struct sip_pvt *p, const char *event, const char *data
        return 0;
 }
 
-/*--- retrans_pkt: Retransmit SIP message if no answer ---*/
+/*! \brief  retrans_pkt: Retransmit SIP message if no answer ---*/
 static int retrans_pkt(void *data)
 {
        struct sip_pkt *pkt=data, *prev, *cur = NULL;
@@ -1224,7 +1235,7 @@ static int retrans_pkt(void *data)
        return 0;
 }
 
-/*--- __sip_reliable_xmit: transmit packet with retransmits ---*/
+/*! \brief  __sip_reliable_xmit: transmit packet with retransmits ---*/
 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal, int sipmethod)
 {
        struct sip_pkt *pkt;
@@ -1263,7 +1274,7 @@ static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *dat
        return 0;
 }
 
-/*--- __sip_autodestruct: Kill a call (called by scheduler) ---*/
+/*! \brief  __sip_autodestruct: Kill a call (called by scheduler) ---*/
 static int __sip_autodestruct(void *data)
 {
        struct sip_pvt *p = data;
@@ -1289,7 +1300,7 @@ static int __sip_autodestruct(void *data)
        return 0;
 }
 
-/*--- sip_scheddestroy: Schedule destruction of SIP call ---*/
+/*! \brief  sip_scheddestroy: Schedule destruction of SIP call ---*/
 static int sip_scheddestroy(struct sip_pvt *p, int ms)
 {
        char tmp[80];
@@ -1306,7 +1317,7 @@ static int sip_scheddestroy(struct sip_pvt *p, int ms)
        return 0;
 }
 
-/*--- sip_cancel_destroy: Cancel destruction of SIP call ---*/
+/*! \brief  sip_cancel_destroy: Cancel destruction of SIP call ---*/
 static int sip_cancel_destroy(struct sip_pvt *p)
 {
        if (p->autokillid > -1)
@@ -1316,7 +1327,7 @@ static int sip_cancel_destroy(struct sip_pvt *p)
        return 0;
 }
 
-/*--- __sip_ack: Acknowledges receipt of a packet and stops retransmission ---*/
+/*! \brief  __sip_ack: Acknowledges receipt of a packet and stops retransmission ---*/
 static int __sip_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
 {
        struct sip_pkt *cur, *prev = NULL;
@@ -1385,7 +1396,7 @@ static int __sip_pretend_ack(struct sip_pvt *p)
        return 0;
 }
 
-/*--- __sip_semi_ack: Acks receipt of packet, keep it around (used for provisional responses) ---*/
+/*! \brief  __sip_semi_ack: Acks receipt of packet, keep it around (used for provisional responses) ---*/
 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
 {
        struct sip_pkt *cur;
@@ -1417,7 +1428,7 @@ static void parse_request(struct sip_request *req);
 static char *get_header(struct sip_request *req, char *name);
 static void copy_request(struct sip_request *dst,struct sip_request *src);
 
-/*--- parse_copy: Copy SIP request, parse it */
+/*! \brief  parse_copy: Copy SIP request, parse it */
 static void parse_copy(struct sip_request *dst, struct sip_request *src)
 {
        memset(dst, 0, sizeof(*dst));
@@ -1426,7 +1437,7 @@ static void parse_copy(struct sip_request *dst, struct sip_request *src)
        parse_request(dst);
 }
 
-/*--- send_response: Transmit response on SIP request---*/
+/*! \brief  send_response: Transmit response on SIP request---*/
 static int send_response(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
 {
        int res;
@@ -1460,7 +1471,7 @@ static int send_response(struct sip_pvt *p, struct sip_request *req, int reliabl
        return res;
 }
 
-/*--- send_request: Send SIP Request to the other part of the dialogue ---*/
+/*! \brief  send_request: Send SIP Request to the other part of the dialogue ---*/
 static int send_request(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
 {
        int res;
@@ -1492,7 +1503,7 @@ static int send_request(struct sip_pvt *p, struct sip_request *req, int reliable
        return res;
 }
 
-/*--- get_in_brackets: Pick out text in brackets from character string ---*/
+/*! \brief  get_in_brackets: Pick out text in brackets from character string ---*/
 /* returns pointer to terminated stripped string. modifies input string. */
 static char *get_in_brackets(char *tmp)
 {
@@ -1534,7 +1545,7 @@ static char *get_in_brackets(char *tmp)
        }
 }
 
-/*--- sip_sendtext: Send SIP MESSAGE text within a call ---*/
+/*! \brief  sip_sendtext: Send SIP MESSAGE text within a call ---*/
 /*      Called from PBX core text message functions */
 static int sip_sendtext(struct ast_channel *ast, const char *text)
 {
@@ -1545,7 +1556,7 @@ static int sip_sendtext(struct ast_channel *ast, const char *text)
                ast_verbose("Sending text %s on %s\n", text, ast->name);
        if (!p)
                return -1;
-       if (!text || ast_strlen_zero(text))
+       if (ast_strlen_zero(text))
                return 0;
        if (debug)
                ast_verbose("Really sending text %s on %s\n", text, ast->name);
@@ -1553,8 +1564,8 @@ static int sip_sendtext(struct ast_channel *ast, const char *text)
        return 0;       
 }
 
-/*--- realtime_update_peer: Update peer object in realtime storage ---*/
-static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, const char *username, int expirey)
+/*! \brief  realtime_update_peer: Update peer object in realtime storage ---*/
+static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, const char *username, const char *fullcontact, int expirey)
 {
        char port[10];
        char ipaddr[20];
@@ -1568,10 +1579,13 @@ static void realtime_update_peer(const char *peername, struct sockaddr_in *sin,
                ast_inet_ntoa(ipaddr, sizeof(ipaddr), sin->sin_addr);
                snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
        }
-       ast_update_realtime("sippeers", "name", peername, "ipaddr", ipaddr, "port", port, "regseconds", regseconds, "username", username, NULL);
+       if (fullcontact)
+               ast_update_realtime("sippeers", "name", peername, "ipaddr", ipaddr, "port", port, "regseconds", regseconds, "username", username, "fullcontact", fullcontact, NULL);
+       else
+               ast_update_realtime("sippeers", "name", peername, "ipaddr", ipaddr, "port", port, "regseconds", regseconds, "username", username, NULL);
 }
 
-/*--- register_peer_exten: Automatically add peer extension to dial plan ---*/
+/*! \brief  register_peer_exten: Automatically add peer extension to dial plan ---*/
 static void register_peer_exten(struct sip_peer *peer, int onoff)
 {
        char multi[256];
@@ -1588,7 +1602,7 @@ static void register_peer_exten(struct sip_peer *peer, int onoff)
        }
 }
 
-/*--- sip_destroy_peer: Destroy peer object from memory */
+/*! \brief  sip_destroy_peer: Destroy peer object from memory */
 static void sip_destroy_peer(struct sip_peer *peer)
 {
        /* Delete it, it needs to disappear */
@@ -1617,19 +1631,19 @@ static void sip_destroy_peer(struct sip_peer *peer)
        free(peer);
 }
 
-/*--- update_peer: Update peer data in database (if used) ---*/
+/*! \brief  update_peer: Update peer data in database (if used) ---*/
 static void update_peer(struct sip_peer *p, int expiry)
 {
+       int rtcachefriends = ast_test_flag(&(p->flags_page2), SIP_PAGE2_RTCACHEFRIENDS);
        if (ast_test_flag((&global_flags_page2), SIP_PAGE2_RTUPDATE) &&
-               (ast_test_flag(p, SIP_REALTIME) || 
-                ast_test_flag(&(p->flags_page2), SIP_PAGE2_RTCACHEFRIENDS))) {
-               realtime_update_peer(p->name, &p->addr, p->username, expiry);
+               (ast_test_flag(p, SIP_REALTIME) || rtcachefriends)) {
+               realtime_update_peer(p->name, &p->addr, p->username, rtcachefriends ? p->fullcontact : NULL, expiry);
        }
 }
 
 
-/*--- realtime_peer: Get peer from realtime storage ---*/
-/* Checks the "sippeers" realtime family from extconfig.conf */
+/*! \brief  realtime_peer: Get peer from realtime storage
+ * Checks the "sippeers" realtime family from extconfig.conf */
 static struct sip_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
 {
        struct sip_peer *peer=NULL;
@@ -1668,14 +1682,14 @@ static struct sip_peer *realtime_peer(const char *peername, struct sockaddr_in *
                ast_variables_destroy(var);
                return (struct sip_peer *) NULL;
        }
-               
+
        /* Peer found in realtime, now build it in memory */
        peer = build_peer(newpeername, var, !ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS));
-
        if (!peer) {
                ast_variables_destroy(var);
                return (struct sip_peer *) NULL;
        }
+
        if (ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS)) {
                /* Cache peer */
                ast_copy_flags((&peer->flags_page2),(&global_flags_page2), SIP_PAGE2_RTAUTOCLEAR|SIP_PAGE2_RTCACHEFRIENDS);
@@ -1690,10 +1704,11 @@ static struct sip_peer *realtime_peer(const char *peername, struct sockaddr_in *
                ast_set_flag(peer, SIP_REALTIME);
        }
        ast_variables_destroy(var);
+
        return peer;
 }
 
-/*--- sip_addrcmp: Support routine for find_peer ---*/
+/*! \brief  sip_addrcmp: Support routine for find_peer ---*/
 static int sip_addrcmp(char *name, struct sockaddr_in *sin)
 {
        /* We know name is the first field, so we can cast */
@@ -1703,8 +1718,8 @@ static int sip_addrcmp(char *name, struct sockaddr_in *sin)
                                        (p->addr.sin_addr.s_addr == sin->sin_addr.s_addr)));
 }
 
-/*--- find_peer: Locate peer by name or ip address */
-/*     This is used on incoming SIP message to find matching peer on ip
+/*! \brief  find_peer: 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_peer *find_peer(const char *peer, struct sockaddr_in *sin, int realtime)
 {
@@ -1722,7 +1737,7 @@ static struct sip_peer *find_peer(const char *peer, struct sockaddr_in *sin, int
        return p;
 }
 
-/*--- sip_destroy_user: Remove user object from in-memory storage ---*/
+/*! \brief  sip_destroy_user: Remove user object from in-memory storage ---*/
 static void sip_destroy_user(struct sip_user *user)
 {
        ast_free_ha(user->ha);
@@ -1737,9 +1752,9 @@ static void sip_destroy_user(struct sip_user *user)
        free(user);
 }
 
-/*--- realtime_user: 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) */
+/*! \brief  realtime_user: 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 struct sip_user *realtime_user(const char *username)
 {
        struct ast_variable *var;
@@ -1784,10 +1799,10 @@ static struct sip_user *realtime_user(const char *username)
        return user;
 }
 
-/*--- find_user: 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) */
+/*! \brief  find_user: 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 struct sip_user *find_user(const char *name, int realtime)
 {
        struct sip_user *u = NULL;
@@ -1798,7 +1813,7 @@ static struct sip_user *find_user(const char *name, int realtime)
        return u;
 }
 
-/*--- create_addr_from_peer: create address structure from peer reference ---*/
+/*! \brief  create_addr_from_peer: create address structure from peer reference ---*/
 static int create_addr_from_peer(struct sip_pvt *r, struct sip_peer *peer)
 {
        char *callhost;
@@ -1872,9 +1887,9 @@ static int create_addr_from_peer(struct sip_pvt *r, struct sip_peer *peer)
        return 0;
 }
 
-/*--- create_addr: 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 */
+/*! \brief  create_addr: 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(struct sip_pvt *dialog, char *opeer)
 {
        struct hostent *hp;
@@ -1938,7 +1953,7 @@ static int create_addr(struct sip_pvt *dialog, char *opeer)
        }
 }
 
-/*--- auto_congest: Scheduled congestion on a call ---*/
+/*! \brief  auto_congest: Scheduled congestion on a call ---*/
 static int auto_congest(void *nothing)
 {
        struct sip_pvt *p = nothing;
@@ -1958,8 +1973,8 @@ static int auto_congest(void *nothing)
 
 
 
-/*--- sip_call: Initiate SIP call from PBX ---*/
-/*      used from the dial() application      */
+/*! \brief  sip_call: Initiate SIP call from PBX 
+ *      used from the dial() application      */
 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
 {
        int res;
@@ -2031,7 +2046,7 @@ static int sip_call(struct ast_channel *ast, char *dest, int timeout)
        return res;
 }
 
-/*--- sip_registry_destroy: Destroy registry object ---*/
+/*! \brief  sip_registry_destroy: Destroy registry object ---*/
 /*     Objects created with the register= statement in static configuration */
 static void sip_registry_destroy(struct sip_registry *reg)
 {
@@ -2051,7 +2066,7 @@ static void sip_registry_destroy(struct sip_registry *reg)
        
 }
 
-/*---  __sip_destroy: Execute destrucion of call structure, release memory---*/
+/*! \brief   __sip_destroy: Execute destrucion of call structure, release memory---*/
 static void __sip_destroy(struct sip_pvt *p, int lockowner)
 {
        struct sip_pvt *cur, *prev = NULL;
@@ -2146,9 +2161,9 @@ static void __sip_destroy(struct sip_pvt *p, int lockowner)
        free(p);
 }
 
-/*--- update_call_counter: Handle call_limit for SIP users ---*/
-/* Note: This is going to be replaced by app_groupcount */
-/* Thought: For realtime, we should propably update storage with inuse counter... */
+/*! \brief  update_call_counter: Handle call_limit for SIP users 
+ * Note: This is going to be replaced by app_groupcount 
+ * Thought: For realtime, we should propably update storage with inuse counter... */
 static int update_call_counter(struct sip_pvt *fup, int event)
 {
        char name[256];
@@ -2202,10 +2217,6 @@ static int update_call_counter(struct sip_pvt *fup, int event)
                        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);
-                                       /* inc inUse as well */
-                                       if ( event == INC_CALL_LIMIT ) {
-                                               (*inuse)++;
-                                       }
                                        if (u)
                                                ASTOBJ_UNREF(u,sip_destroy_user);
                                        else
@@ -2228,7 +2239,7 @@ static int update_call_counter(struct sip_pvt *fup, int event)
        return 0;
 }
 
-/*--- sip_destroy: Destroy SIP call structure ---*/
+/*! \brief  sip_destroy: Destroy SIP call structure ---*/
 static void sip_destroy(struct sip_pvt *p)
 {
        ast_mutex_lock(&iflock);
@@ -2239,7 +2250,7 @@ static void sip_destroy(struct sip_pvt *p)
 
 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal);
 
-/*--- hangup_sip2cause: Convert SIP hangup causes to Asterisk hangup causes ---*/
+/*! \brief  hangup_sip2cause: Convert SIP hangup causes to Asterisk hangup causes ---*/
 static int hangup_sip2cause(int cause)
 {
 /* Possible values taken from causes.h */
@@ -2275,8 +2286,9 @@ static int hangup_sip2cause(int cause)
 }
 
 
-/*--- hangup_cause2sip: Convert Asterisk hangup causes to SIP codes ---*/
-/* Possible values from causes.h
+/*! \brief  hangup_cause2sip: Convert Asterisk hangup causes to SIP codes 
+\verbatim
+ Possible values from causes.h
         AST_CAUSE_NOTDEFINED    AST_CAUSE_NORMAL        AST_CAUSE_BUSY
         AST_CAUSE_FAILURE       AST_CAUSE_CONGESTION    AST_CAUSE_UNALLOCATED
 
@@ -2304,6 +2316,7 @@ static int hangup_sip2cause(int cause)
    28 address incomplete                   484 Address incomplete
    29 facility rejected                    501 Not implemented
    31 normal unspecified                   480 Temporarily unavailable
+\endverbatim
 */
 static char *hangup_cause2sip(int cause)
 {
@@ -2353,8 +2366,8 @@ static char *hangup_cause2sip(int cause)
 }
 
 
-/*--- sip_hangup: Hangup SIP call ---*/
-/* Part of PBX interface */
+/*! \brief  sip_hangup: Hangup SIP call 
+ * Part of PBX interface, called from ast_hangup */
 static int sip_hangup(struct ast_channel *ast)
 {
        struct sip_pvt *p = ast->tech_pvt;
@@ -2441,8 +2454,8 @@ static int sip_hangup(struct ast_channel *ast)
        return 0;
 }
 
-/*--- sip_answer: Answer SIP call , send 200 OK on Invite ---*/
-/* Part of PBX interface */
+/*! \brief  sip_answer: Answer SIP call , send 200 OK on Invite 
+ * Part of PBX interface */
 static int sip_answer(struct ast_channel *ast)
 {
        int res = 0,fmt;
@@ -2477,7 +2490,7 @@ static int sip_answer(struct ast_channel *ast)
        return res;
 }
 
-/*--- sip_write: Send frame to media channel (rtp) ---*/
+/*! \brief  sip_write: Send frame to media channel (rtp) ---*/
 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
 {
        struct sip_pvt *p = ast->tech_pvt;
@@ -2529,7 +2542,7 @@ static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
        return res;
 }
 
-/*--- sip_fixup: Fix up a channel:  If a channel is consumed, this is called.
+/*! \brief  sip_fixup: Fix up a channel:  If a channel is consumed, this is called.
         Basically update any ->owner links ----*/
 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
 {
@@ -2545,7 +2558,7 @@ static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
        return 0;
 }
 
-/*--- sip_senddigit: Send DTMF character on SIP channel */
+/*! \brief  sip_senddigit: Send DTMF character on SIP channel */
 /*    within one call, we're able to transmit in many methods simultaneously */
 static int sip_senddigit(struct ast_channel *ast, char digit)
 {
@@ -2568,10 +2581,9 @@ static int sip_senddigit(struct ast_channel *ast, char digit)
        return res;
 }
 
-#define DEFAULT_MAX_FORWARDS   70
 
 
-/*--- sip_transfer: Transfer SIP call */
+/*! \brief  sip_transfer: Transfer SIP call */
 static int sip_transfer(struct ast_channel *ast, const char *dest)
 {
        struct sip_pvt *p = ast->tech_pvt;
@@ -2586,8 +2598,8 @@ static int sip_transfer(struct ast_channel *ast, const char *dest)
        return res;
 }
 
-/*--- sip_indicate: Play indication to user */
-/* With SIP a lot of indications is sent as messages, letting the device play
+/*! \brief  sip_indicate: 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 int sip_indicate(struct ast_channel *ast, int condition)
 {
@@ -2675,7 +2687,7 @@ static int sip_indicate(struct ast_channel *ast, int condition)
 
 
 
-/*--- sip_new: Initiate a call in the SIP channel */
+/*! \brief  sip_new: Initiate a call in the SIP channel */
 /*      called from sip_request_call (calls from the pbx ) */
 static struct ast_channel *sip_new(struct sip_pvt *i, int state, char *title)
 {
@@ -2796,7 +2808,7 @@ static struct ast_channel *sip_new(struct sip_pvt *i, int state, char *title)
        return tmp;
 }
 
-/*--- get_sdp_by_line: Reads one line of SIP message body */
+/*! \brief  get_sdp_by_line: Reads one line of SIP message body */
 static char* get_sdp_by_line(char* line, char *name, int nameLen)
 {
        if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
@@ -2805,7 +2817,7 @@ static char* get_sdp_by_line(char* line, char *name, int nameLen)
        return "";
 }
 
-/*--- get_sdp: Gets all kind of SIP message bodies, including SDP,
+/*! \brief  get_sdp: Gets all kind of SIP message bodies, including SDP,
    but the name wrongly applies _only_ sdp */
 static char *get_sdp(struct sip_request *req, char *name) 
 {
@@ -2885,14 +2897,14 @@ static char *__get_header(struct sip_request *req, char *name, int *start)
        return "";
 }
 
-/*--- get_header: Get header from SIP request ---*/
+/*! \brief  get_header: Get header from SIP request ---*/
 static char *get_header(struct sip_request *req, char *name)
 {
        int start = 0;
        return __get_header(req, name, &start);
 }
 
-/*--- sip_rtp_read: Read RTP from network ---*/
+/*! \brief  sip_rtp_read: Read RTP from network ---*/
 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p)
 {
        /* Retrieve audio/etc from channel.  Assumes p->lock is already held. */
@@ -2942,7 +2954,7 @@ static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p
        return f;
 }
 
-/*--- sip_read: Read SIP RTP from channel */
+/*! \brief  sip_read: Read SIP RTP from channel */
 static struct ast_frame *sip_read(struct ast_channel *ast)
 {
        struct ast_frame *fr;
@@ -2954,7 +2966,7 @@ static struct ast_frame *sip_read(struct ast_channel *ast)
        return fr;
 }
 
-/*--- build_callid: Build SIP CALLID header ---*/
+/*! \brief  build_callid: Build SIP CALLID header ---*/
 static void build_callid(char *callid, int len, struct in_addr ourip, char *fromdomain)
 {
        int res;
@@ -2979,7 +2991,7 @@ static void make_our_tag(char *tagbuf, size_t len)
        snprintf(tagbuf, len, "as%08x", rand());
 }
 
-/*--- sip_alloc: Allocate SIP_PVT structure and set defaults ---*/
+/*! \brief  sip_alloc: Allocate SIP_PVT structure and set defaults ---*/
 static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useglobal_nat, const int intended_method)
 {
        struct sip_pvt *p;
@@ -3071,14 +3083,15 @@ static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useg
        return p;
 }
 
-/*--- find_call: Connect incoming SIP message to current dialog or create new dialog structure */
-/*               Called by handle_request ,sipsock_read */
+/*! \brief  find_call: Connect incoming SIP message to current dialog or create new dialog structure */
+/*               Called by handle_request, sipsock_read */
 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin, const int intended_method)
 {
        struct sip_pvt *p;
        char *callid;
-       char tmp[256];
-       char *tag = "", *c;
+       char *tag = "";
+       char totag[128];
+       char fromtag[128];
 
        callid = get_header(req, "Call-ID");
 
@@ -3086,32 +3099,51 @@ static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *si
                /* 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
+                  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));
+
                if (req->method == SIP_RESPONSE)
-                       ast_copy_string(tmp, get_header(req, "To"), sizeof(tmp));
+                       tag = totag;
                else
-                       ast_copy_string(tmp, get_header(req, "From"), sizeof(tmp));
-               tag = strcasestr(tmp, "tag=");
-               if (tag) {
-                       tag += 4;
-                       c = strchr(tag, ';');
-                       if (c)
-                               *c = '\0';
-               }
+                       tag = 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);
        p = iflist;
-       while(p) {
+       while(p) {      /* In pedantic, we do not want packets with bad syntax to be connected to a PVT */
                int found = 0;
                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 = 0;
+                       } else if (totag[0]) {                  /* Both have tags, compare them */
+                               if (strcmp(totag, p->tag)) {
+                                       found = 0;              /* 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_lock(&p->lock);
@@ -3127,7 +3159,7 @@ static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *si
        return p;
 }
 
-/*--- sip_register: Parse register=> line in sip.conf and add to registry */
+/*! \brief  sip_register: Parse register=> line in sip.conf and add to registry */
 static int sip_register(char *value, int lineno)
 {
        struct sip_registry *reg;
@@ -3147,7 +3179,7 @@ static int sip_register(char *value, int lineno)
                *hostname = '\0';
                hostname++;
        }
-       if (!username || ast_strlen_zero(username) || !hostname || ast_strlen_zero(hostname)) {
+       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;
        }
@@ -3162,7 +3194,7 @@ static int sip_register(char *value, int lineno)
        hostname = strsep(&stringp, "/");
        if (hostname) 
                contact = strsep(&stringp, "/");
-       if (!contact || ast_strlen_zero(contact))
+       if (ast_strlen_zero(contact))
                contact = "s";
        stringp=hostname;
        hostname = strsep(&stringp, ":");
@@ -3200,7 +3232,7 @@ static int sip_register(char *value, int lineno)
        return 0;
 }
 
-/*--- lws2sws: Parse multiline SIP headers into one header */
+/*! \brief  lws2sws: Parse multiline SIP headers into one header */
 /* This is enabled if pedanticsipchecking is enabled */
 static int lws2sws(char *msgbuf, int len) 
 { 
@@ -3246,7 +3278,7 @@ static int lws2sws(char *msgbuf, int len)
        return t; 
 }
 
-/*--- parse_request: Parse a SIP message ----*/
+/*! \brief  parse_request: Parse a SIP message ----*/
 static void parse_request(struct sip_request *req)
 {
        /* Divide fields by NULL's */
@@ -3263,7 +3295,7 @@ static void parse_request(struct sip_request *req)
                        *c = 0;
 
                        if (sipdebug && option_debug > 3)
-                               ast_log(LOG_DEBUG, "Header: %s (%d)\n", req->header[f], (int) strlen(req->header[f]));
+                               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++;
@@ -3281,8 +3313,11 @@ static void parse_request(struct sip_request *req)
                c++;
        }
        /* Check for last header */
-       if (!ast_strlen_zero(req->header[f])) 
+       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;
@@ -3314,7 +3349,7 @@ static void parse_request(struct sip_request *req)
        determine_firstline_parts(req);
 }
 
-/*--- process_sdp: Process SIP SDP and activate RTP channels---*/
+/*! \brief  process_sdp: Process SIP SDP and activate RTP channels---*/
 static int process_sdp(struct sip_pvt *p, struct sip_request *req)
 {
        char *m;
@@ -3374,8 +3409,8 @@ static int process_sdp(struct sip_pvt *p, struct sip_request *req)
        ast_set_flag(p, SIP_NOVIDEO);   
        while ((m = get_sdp_iterate(&iterator, req, "m"))[0] != '\0') {
                int found = 0;
-               if ((sscanf(m, "audio %d RTP/AVP %n", &x, &len) == 1) ||
-                   (sscanf(m, "audio %d/%d RTP/AVP %n", &x, &y, &len) == 2)) {
+               if ((sscanf(m, "audio %d/%d RTP/AVP %n", &x, &y, &len) == 2) ||
+                   (sscanf(m, "audio %d RTP/AVP %n", &x, &len) == 1)) {
                        found = 1;
                        portno = x;
                        /* Scan through the RTP payload types specified in a "m=" line: */
@@ -3598,7 +3633,7 @@ static int process_sdp(struct sip_pvt *p, struct sip_request *req)
        return 0;
 }
 
-/*--- add_header: Add header to SIP message */
+/*! \brief  add_header: Add header to SIP message */
 static int add_header(struct sip_request *req, const char *var, const char *value)
 {
        int x = 0;
@@ -3633,7 +3668,7 @@ static int add_header(struct sip_request *req, const char *var, const char *valu
        return 0;       
 }
 
-/*--- add_header_contentLen: Add 'Content-Length' header to SIP message */
+/*! \brief  add_header_contentLen: Add 'Content-Length' header to SIP message */
 static int add_header_contentLength(struct sip_request *req, int len)
 {
        char clen[10];
@@ -3642,7 +3677,7 @@ static int add_header_contentLength(struct sip_request *req, int len)
        return add_header(req, "Content-Length", clen);
 }
 
-/*--- add_blank_header: Add blank header to SIP message */
+/*! \brief  add_blank_header: Add blank header to SIP message */
 static int add_blank_header(struct sip_request *req)
 {
        if (req->headers == SIP_MAX_HEADERS)  {
@@ -3664,7 +3699,7 @@ static int add_blank_header(struct sip_request *req)
        return 0;       
 }
 
-/*--- add_line: Add content (not header) to SIP message */
+/*! \brief  add_line: Add content (not header) to SIP message */
 static int add_line(struct sip_request *req, const char *line)
 {
        if (req->lines == SIP_MAX_LINES)  {
@@ -3687,7 +3722,7 @@ static int add_line(struct sip_request *req, const char *line)
        return 0;       
 }
 
-/*--- copy_header: Copy one header field from one request to another */
+/*! \brief  copy_header: Copy one header field from one request to another */
 static int copy_header(struct sip_request *req, struct sip_request *orig, char *field)
 {
        char *tmp;
@@ -3700,7 +3735,7 @@ static int copy_header(struct sip_request *req, struct sip_request *orig, char *
        return -1;
 }
 
-/*--- copy_all_header: Copy all headers from one request to another ---*/
+/*! \brief  copy_all_header: Copy all headers from one request to another ---*/
 static int copy_all_header(struct sip_request *req, struct sip_request *orig, char *field)
 {
        char *tmp;
@@ -3718,7 +3753,7 @@ static int copy_all_header(struct sip_request *req, struct sip_request *orig, ch
        return copied ? 0 : -1;
 }
 
-/*--- copy_via_headers: Copy SIP VIA Headers from the request to the response ---*/
+/*! \brief  copy_via_headers: Copy SIP VIA Headers from the request to the response ---*/
 /*     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.
@@ -3782,7 +3817,7 @@ static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, struct s
        return 0;
 }
 
-/*--- add_route: Add route header into request per learned route ---*/
+/*! \brief  add_route: Add route header into request per learned route ---*/
 static void add_route(struct sip_request *req, struct sip_route *route)
 {
        char r[256], *p;
@@ -3808,7 +3843,7 @@ static void add_route(struct sip_request *req, struct sip_route *route)
        add_header(req, "Route", r);
 }
 
-/*--- set_destination: Set destination from SIP URI ---*/
+/*! \brief  set_destination: Set destination from SIP URI ---*/
 static void set_destination(struct sip_pvt *p, char *uri)
 {
        char *h, *maddr, hostname[256];
@@ -3871,7 +3906,7 @@ static void set_destination(struct sip_pvt *p, char *uri)
                ast_verbose("set_destination: set destination to %s, port %d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), p->sa.sin_addr), port);
 }
 
-/*--- init_resp: Initialize SIP response, based on SIP request ---*/
+/*! \brief  init_resp: Initialize SIP response, based on SIP request ---*/
 static int init_resp(struct sip_request *req, char *resp, struct sip_request *orig)
 {
        /* Initialize a response */
@@ -3887,7 +3922,7 @@ static int init_resp(struct sip_request *req, char *resp, struct sip_request *or
        return 0;
 }
 
-/*--- init_req: Initialize SIP request ---*/
+/*! \brief  init_req: Initialize SIP request ---*/
 static int init_req(struct sip_request *req, int sipmethod, char *recip)
 {
        /* Initialize a response */
@@ -3904,7 +3939,7 @@ static int init_req(struct sip_request *req, int sipmethod, char *recip)
 }
 
 
-/*--- respprep: Prepare SIP response packet ---*/
+/*! \brief  respprep: Prepare SIP response packet ---*/
 static int respprep(struct sip_request *resp, struct sip_pvt *p, char *msg, struct sip_request *req)
 {
        char newto[256], *ot;
@@ -3934,6 +3969,7 @@ static int respprep(struct sip_request *resp, struct sip_pvt *p, char *msg, stru
        copy_header(resp, req, "CSeq");
        add_header(resp, "User-Agent", default_useragent);
        add_header(resp, "Allow", ALLOWED_METHODS);
+       add_header(resp, "Max-Forwards", DEFAULT_MAX_FORWARDS);
        if (msg[0] == '2' && (p->method == SIP_SUBSCRIBE || p->method == SIP_REGISTER)) {
                /* For registration responses, we also need expiry and
                   contact info */
@@ -3949,15 +3985,10 @@ static int respprep(struct sip_request *resp, struct sip_pvt *p, char *msg, stru
        } else if (p->our_contact[0]) {
                add_header(resp, "Contact", p->our_contact);
        }
-       if (p->maxforwards) {
-               char tmp[256];
-               snprintf(tmp, sizeof(tmp), "%d", p->maxforwards);
-               add_header(resp, "Max-Forwards", tmp);
-       }
        return 0;
 }
 
-/*--- reqprep: Initialize a SIP request response packet ---*/
+/*! \brief  reqprep: Initialize a SIP request response packet ---*/
 static int reqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod, int seqno, int newbranch)
 {
        struct sip_request *orig = &p->initreq;
@@ -4050,6 +4081,7 @@ static int reqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod, in
        add_header(req, "CSeq", tmp);
 
        add_header(req, "User-Agent", default_useragent);
+       add_header(req, "Max-Forwards", DEFAULT_MAX_FORWARDS);
 
        if (p->rpid)
                add_header(req, "Remote-Party-ID", p->rpid);
@@ -4057,7 +4089,7 @@ static int reqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod, in
        return 0;
 }
 
-/*--- __transmit_response: Base transmit response function */
+/*! \brief  __transmit_response: Base transmit response function */
 static int __transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req, int reliable)
 {
        struct sip_request resp;
@@ -4078,13 +4110,13 @@ static int __transmit_response(struct sip_pvt *p, char *msg, struct sip_request
        return send_response(p, &resp, reliable, seqno);
 }
 
-/*--- transmit_response: Transmit response, no retransmits */
+/*! \brief  transmit_response: Transmit response, no retransmits */
 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req) 
 {
        return __transmit_response(p, msg, req, 0);
 }
 
-/*--- transmit_response_with_unsupported: Transmit response, no retransmits */
+/*! \brief  transmit_response_with_unsupported: Transmit response, no retransmits */
 static int transmit_response_with_unsupported(struct sip_pvt *p, char *msg, struct sip_request *req, char *unsupported) 
 {
        struct sip_request resp;
@@ -4094,13 +4126,13 @@ static int transmit_response_with_unsupported(struct sip_pvt *p, char *msg, stru
        return send_response(p, &resp, 0, 0);
 }
 
-/*--- transmit_response_reliable: Transmit response, Make sure you get a reply */
+/*! \brief  transmit_response_reliable: Transmit response, Make sure you get a reply */
 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal)
 {
        return __transmit_response(p, msg, req, fatal ? 2 : 1);
 }
 
-/*--- append_date: Append date to SIP message ---*/
+/*! \brief  append_date: Append date to SIP message ---*/
 static void append_date(struct sip_request *req)
 {
        char tmpdat[256];
@@ -4113,7 +4145,7 @@ static void append_date(struct sip_request *req)
        add_header(req, "Date", tmpdat);
 }
 
-/*--- transmit_response_with_date: Append date and content length before transmitting response ---*/
+/*! \brief  transmit_response_with_date: Append date and content length before transmitting response ---*/
 static int transmit_response_with_date(struct sip_pvt *p, char *msg, struct sip_request *req)
 {
        struct sip_request resp;
@@ -4124,7 +4156,7 @@ static int transmit_response_with_date(struct sip_pvt *p, char *msg, struct sip_
        return send_response(p, &resp, 0, 0);
 }
 
-/*--- transmit_response_with_allow: Append Accept header, content length before transmitting response ---*/
+/*! \brief  transmit_response_with_allow: Append Accept header, content length before transmitting response ---*/
 static int transmit_response_with_allow(struct sip_pvt *p, char *msg, struct sip_request *req, int reliable)
 {
        struct sip_request resp;
@@ -4156,7 +4188,7 @@ static int transmit_response_with_auth(struct sip_pvt *p, char *msg, struct sip_
        return send_response(p, &resp, reliable, seqno);
 }
 
-/*--- add_text: Add text body to SIP message ---*/
+/*! \brief  add_text: Add text body to SIP message ---*/
 static int add_text(struct sip_request *req, const char *text)
 {
        /* XXX Convert \n's to \r\n's XXX */
@@ -4166,7 +4198,7 @@ static int add_text(struct sip_request *req, const char *text)
        return 0;
 }
 
-/*--- add_digit: add DTMF INFO tone to sip message ---*/
+/*! \brief  add_digit: add DTMF INFO tone to sip message ---*/
 /* Always adds default duration 250 ms, regardless of what came in over the line */
 static int add_digit(struct sip_request *req, char digit)
 {
@@ -4179,7 +4211,7 @@ static int add_digit(struct sip_request *req, char digit)
        return 0;
 }
 
-/*--- add_vidupdate: add XML encoded media control with update ---*/
+/*! \brief  add_vidupdate: add XML encoded media control with update ---*/
 /* XML: The only way to turn 0 bits of information into a few hundred. */
 static int add_vidupdate(struct sip_request *req)
 {
@@ -4236,7 +4268,7 @@ static void add_noncodec_to_sdp(const struct sip_pvt *p, int format, int sample_
                ast_build_string(a_buf, a_size, "a=fmtp:%d 0-16\r\n", rtp_code);
 }
 
-/*--- add_sdp: Add Session Description Protocol message ---*/
+/*! \brief  add_sdp: Add Session Description Protocol message ---*/
 static int add_sdp(struct sip_request *resp, struct sip_pvt *p)
 {
        int len = 0;
@@ -4426,7 +4458,7 @@ static int add_sdp(struct sip_request *resp, struct sip_pvt *p)
        return 0;
 }
 
-/*--- copy_request: copy SIP request (mostly used to save request for responses) ---*/
+/*! \brief  copy_request: copy SIP request (mostly used to save request for responses) ---*/
 static void copy_request(struct sip_request *dst, struct sip_request *src)
 {
        long offset;
@@ -4441,7 +4473,7 @@ static void copy_request(struct sip_request *dst, struct sip_request *src)
                dst->line[x] += offset;
 }
 
-/*--- transmit_response_with_sdp: Used for 200 OK and 183 early media ---*/
+/*! \brief  transmit_response_with_sdp: Used for 200 OK and 183 early media ---*/
 static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans)
 {
        struct sip_request resp;
@@ -4460,7 +4492,7 @@ static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_r
        return send_response(p, &resp, retrans, seqno);
 }
 
-/*--- determine_firstline_parts: parse first line of incoming SIP request */
+/*! \brief  determine_firstline_parts: parse first line of incoming SIP request */
 static int determine_firstline_parts( struct sip_request *req ) 
 {
        char *e, *cmd;
@@ -4509,7 +4541,7 @@ static int determine_firstline_parts( struct sip_request *req )
        return 1;
 }
 
-/*--- transmit_reinvite_with_sdp: Transmit reinvite with SDP :-) ---*/
+/*! \brief  transmit_reinvite_with_sdp: Transmit reinvite with SDP :-) ---*/
 /*     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
@@ -4538,7 +4570,7 @@ static int transmit_reinvite_with_sdp(struct sip_pvt *p)
        return send_request(p, &req, 1, p->ocseq);
 }
 
-/*--- extract_uri: Check Contact: URI of SIP message ---*/
+/*! \brief  extract_uri: Check Contact: URI of SIP message ---*/
 static void extract_uri(struct sip_pvt *p, struct sip_request *req)
 {
        char stripped[256];
@@ -4548,11 +4580,11 @@ static void extract_uri(struct sip_pvt *p, struct sip_request *req)
        n = strchr(c, ';');
        if (n)
                *n = '\0';
-       if (c && !ast_strlen_zero(c))
+       if (!ast_strlen_zero(c))
                ast_copy_string(p->uri, c, sizeof(p->uri));
 }
 
-/*--- build_contact: Build contact header - the contact header we send out ---*/
+/*! \brief  build_contact: Build contact header - the contact header we send out ---*/
 static void build_contact(struct sip_pvt *p)
 {
        char iabuf[INET_ADDRSTRLEN];
@@ -4564,7 +4596,7 @@ static void build_contact(struct sip_pvt *p)
                snprintf(p->our_contact, sizeof(p->our_contact), "<sip:%s%s%s>", p->exten, ast_strlen_zero(p->exten) ? "" : "@", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip));
 }
 
-/*--- build_rpid: Build the Remote Party-ID & From using callingpres options ---*/
+/*! \brief  build_rpid: Build the Remote Party-ID & From using callingpres options ---*/
 static void build_rpid(struct sip_pvt *p)
 {
        int send_pres_tags = 1;
@@ -4586,7 +4618,7 @@ static void build_rpid(struct sip_pvt *p)
        if (p->owner && p->owner->cid.cid_name) {
                clin = strdup(p->owner->cid.cid_name);
        }
-       if (!clin || ast_strlen_zero(clin))
+       if (ast_strlen_zero(clin))
                clin = clid;
 
        switch (p->callingpres) {
@@ -4648,7 +4680,7 @@ static void build_rpid(struct sip_pvt *p)
        p->rpid_from = strdup(buf);
 }
 
-/*--- initreqprep: Initiate new SIP request to peer/user ---*/
+/*! \brief  initreqprep: Initiate new SIP request to peer/user ---*/
 static void initreqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod)
 {
        char invite_buf[256] = "";
@@ -4659,7 +4691,7 @@ static void initreqprep(struct sip_request *req, struct sip_pvt *p, int sipmetho
        char tmp[BUFSIZ/2];
        char tmp2[BUFSIZ/2];
        char iabuf[INET_ADDRSTRLEN];
-       char *l = default_callerid, *n = NULL;
+       char *l = NULL, *n = NULL;
        int x;
        char urioptions[256]="";
 
@@ -4694,14 +4726,14 @@ static void initreqprep(struct sip_request *req, struct sip_pvt *p, int sipmetho
                l = p->owner->cid.cid_num;
                n = p->owner->cid.cid_name;
        }
-       if (!l || (!ast_isphonenumber(l) && default_callerid[0]))
-                       l = default_callerid;
        /* if we are not sending RPID and user wants his callerid restricted */
        if (!ast_test_flag(p, SIP_SENDRPID) && ((p->callingpres & AST_PRES_RESTRICTION) != AST_PRES_ALLOWED)) {
                l = CALLERID_UNKNOWN;
                n = l;
        }
-       if (!n || ast_strlen_zero(n))
+       if (!l)
+               l = default_callerid;
+       if (ast_strlen_zero(n))
                n = l;
        /* Allow user to be overridden */
        if (!ast_strlen_zero(p->fromuser))
@@ -4748,7 +4780,7 @@ static void initreqprep(struct sip_request *req, struct sip_pvt *p, int sipmetho
                ast_build_string(&invite, &invite_max, "%s", urioptions);
        }
 
-       /* If custom URI options have been provided, append them */
+       /* 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);
 
@@ -4781,11 +4813,12 @@ static void initreqprep(struct sip_request *req, struct sip_pvt *p, int sipmetho
        add_header(req, "Call-ID", p->callid);
        add_header(req, "CSeq", tmp);
        add_header(req, "User-Agent", default_useragent);
+       add_header(req, "Max-Forwards", DEFAULT_MAX_FORWARDS);
        if (p->rpid)
                add_header(req, "Remote-Party-ID", p->rpid);
 }
 
-/*--- transmit_invite: Build REFER/INVITE/OPTIONS message and transmit it ---*/
+/*! \brief  transmit_invite: Build REFER/INVITE/OPTIONS message and transmit it ---*/
 static int transmit_invite(struct sip_pvt *p, int sipmethod, int sdp, int init)
 {
        struct sip_request req;
@@ -4886,7 +4919,7 @@ static int transmit_invite(struct sip_pvt *p, int sipmethod, int sdp, int init)
        return send_request(p, &req, init ? 2 : 1, p->ocseq);
 }
 
-/*--- transmit_state_notify: Used in the SUBSCRIBE notification subsystem ----*/
+/*! \brief  transmit_state_notify: Used in the SUBSCRIBE notification subsystem ----*/
 static int transmit_state_notify(struct sip_pvt *p, int state, int full, int substate)
 {
        char tmp[4000], from[256], to[256];
@@ -5053,7 +5086,7 @@ static int transmit_state_notify(struct sip_pvt *p, int state, int full, int sub
        return send_request(p, &req, 1, p->ocseq);
 }
 
-/*--- transmit_notify_with_mwi: Notify user of messages waiting in voicemail ---*/
+/*! \brief  transmit_notify_with_mwi: Notify user of messages waiting in voicemail ---*/
 /*      Notification only works for registered peers with mailbox= definitions
  *      in sip.conf
  *      We use the SIP Event package message-summary
@@ -5071,7 +5104,7 @@ static int transmit_notify_with_mwi(struct sip_pvt *p, int newmsgs, int oldmsgs,
        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", (vmexten && !ast_strlen_zero(vmexten)) ? vmexten : global_vmexten, p->fromdomain);
+       ast_build_string(&t, &maxbytes, "Message-Account: sip:%s@%s\r\n", !ast_strlen_zero(vmexten) ? vmexten : global_vmexten, p->fromdomain);
        ast_build_string(&t, &maxbytes, "Voice-Message: %d/%d (0/0)\r\n", newmsgs, oldmsgs);
 
        if (t > tmp + sizeof(tmp))
@@ -5091,7 +5124,7 @@ static int transmit_notify_with_mwi(struct sip_pvt *p, int newmsgs, int oldmsgs,
        return send_request(p, &req, 1, p->ocseq);
 }
 
-/*--- transmit_sip_request: Transmit SIP request */
+/*! \brief  transmit_sip_request: Transmit SIP request */
 static int transmit_sip_request(struct sip_pvt *p,struct sip_request *req)
 {
        if (!p->initreq.headers) {
@@ -5106,7 +5139,7 @@ static int transmit_sip_request(struct sip_pvt *p,struct sip_request *req)
        return send_request(p, req, 0, p->ocseq);
 }
 
-/*--- transmit_notify_with_sipfrag: Notify a transferring party of the status of trasnfer ---*/
+/*! \brief  transmit_notify_with_sipfrag: Notify a transferring party of the status of trasnfer ---*/
 /*      Apparently the draft SIP REFER structure was too simple, so it was decided that the
  *      status of transfers also needed to be sent via NOTIFY instead of just the 202 Accepted
  *      that had worked heretofore.
@@ -5163,7 +5196,7 @@ static char *regstate2str(int regstate)
 
 static int transmit_register(struct sip_registry *r, int sipmethod, char *auth, char *authheader);
 
-/*--- sip_reregister: Update registration with SIP Proxy---*/
+/*! \brief  sip_reregister: Update registration with SIP Proxy---*/
 static int sip_reregister(void *data) 
 {
        /* if we are here, we know that we need to reregister. */
@@ -5189,7 +5222,7 @@ static int sip_reregister(void *data)
        return 0;
 }
 
-/*--- __sip_do_register: Register with SIP proxy ---*/
+/*! \brief  __sip_do_register: Register with SIP proxy ---*/
 static int __sip_do_register(struct sip_registry *r)
 {
        int res;
@@ -5198,7 +5231,7 @@ static int __sip_do_register(struct sip_registry *r)
        return res;
 }
 
-/*--- sip_reg_timeout: Registration timeout, register again */
+/*! \brief  sip_reg_timeout: Registration timeout, register again */
 static int sip_reg_timeout(void *data)
 {
 
@@ -5240,7 +5273,7 @@ static int sip_reg_timeout(void *data)
        return 0;
 }
 
-/*--- transmit_register: Transmit register to SIP proxy or UA ---*/
+/*! \brief  transmit_register: Transmit register to SIP proxy or UA ---*/
 static int transmit_register(struct sip_registry *r, int sipmethod, char *auth, char *authheader)
 {
        struct sip_request req;
@@ -5363,7 +5396,7 @@ static int transmit_register(struct sip_registry *r, int sipmethod, char *auth,
        
        /* Fromdomain is what we are registering to, regardless of actual
           host name from SRV */
-       if (p->fromdomain && !ast_strlen_zero(p->fromdomain))
+       if (!ast_strlen_zero(p->fromdomain))
                snprintf(addr, sizeof(addr), "sip:%s", p->fromdomain);
        else
                snprintf(addr, sizeof(addr), "sip:%s", r->hostname);
@@ -5385,11 +5418,12 @@ static int transmit_register(struct sip_registry *r, int sipmethod, char *auth,
        add_header(&req, "Call-ID", p->callid);
        add_header(&req, "CSeq", tmp);
        add_header(&req, "User-Agent", default_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) ) {
+       else if (!ast_strlen_zero(r->nonce)) {
                char digest[1024];
 
                /* We have auth data to reuse, build a digest header! */
@@ -5429,7 +5463,7 @@ static int transmit_register(struct sip_registry *r, int sipmethod, char *auth,
        return send_request(p, &req, 2, p->ocseq);
 }
 
-/*--- transmit_message_with_text: Transmit text with SIP MESSAGE method ---*/
+/*! \brief  transmit_message_with_text: Transmit text with SIP MESSAGE method ---*/
 static int transmit_message_with_text(struct sip_pvt *p, const char *text)
 {
        struct sip_request req;
@@ -5438,14 +5472,13 @@ static int transmit_message_with_text(struct sip_pvt *p, const char *text)
        return send_request(p, &req, 1, p->ocseq);
 }
 
-/*--- transmit_refer: Transmit SIP REFER message ---*/
+/*! \brief  transmit_refer: Transmit SIP REFER message ---*/
 static int transmit_refer(struct sip_pvt *p, const char *dest)
 {
        struct sip_request req;
        char from[256];
        char *of, *c;
        char referto[256];
-       char tmp[80];
 
        if (ast_test_flag(p, SIP_OUTGOING)) 
                of = get_header(&p->initreq, "To");
@@ -5471,29 +5504,19 @@ static int transmit_refer(struct sip_pvt *p, const char *dest)
                snprintf(referto, sizeof(referto), "<sip:%s>", dest);
        }
 
-       ast_copy_string(tmp, get_header(&p->initreq, "Max-Forwards"), sizeof(tmp));
-       if (strlen(tmp) && atoi(tmp)) {
-               p->maxforwards = atoi(tmp) - 1;
-       } else {
-               p->maxforwards = DEFAULT_MAX_FORWARDS - 1;
-       }
-       if (p->maxforwards > -1) {
-               /* save in case we get 407 challenge */
-               ast_copy_string(p->refer_to, referto, sizeof(p->refer_to));
-               ast_copy_string(p->referred_by, p->our_contact, sizeof(p->referred_by));
+       /* save in case we get 407 challenge */
+       ast_copy_string(p->refer_to, referto, sizeof(p->refer_to));
+       ast_copy_string(p->referred_by, p->our_contact, sizeof(p->referred_by));
 
-               reqprep(&req, p, SIP_REFER, 0, 1);
-               add_header(&req, "Refer-To", referto);
-               if (!ast_strlen_zero(p->our_contact))
-                       add_header(&req, "Referred-By", p->our_contact);
-               add_blank_header(&req);
-               return send_request(p, &req, 1, p->ocseq);
-       } else {
-               return -1;
-       }
+       reqprep(&req, p, SIP_REFER, 0, 1);
+       add_header(&req, "Refer-To", referto);
+       if (!ast_strlen_zero(p->our_contact))
+               add_header(&req, "Referred-By", p->our_contact);
+       add_blank_header(&req);
+       return send_request(p, &req, 1, p->ocseq);
 }
 
-/*--- transmit_info_with_digit: Send SIP INFO dtmf message, see Cisco documentation on cisco.co
+/*! \brief  transmit_info_with_digit: Send SIP INFO dtmf message, see Cisco documentation on cisco.co
 m ---*/
 static int transmit_info_with_digit(struct sip_pvt *p, char digit)
 {
@@ -5503,7 +5526,7 @@ static int transmit_info_with_digit(struct sip_pvt *p, char digit)
        return send_request(p, &req, 1, p->ocseq);
 }
 
-/*--- transmit_info_with_vidupdate: Send SIP INFO with video update request ---*/
+/*! \brief  transmit_info_with_vidupdate: Send SIP INFO with video update request ---*/
 static int transmit_info_with_vidupdate(struct sip_pvt *p)
 {
        struct sip_request req;
@@ -5512,7 +5535,7 @@ static int transmit_info_with_vidupdate(struct sip_pvt *p)
        return send_request(p, &req, 1, p->ocseq);
 }
 
-/*--- transmit_request: transmit generic SIP request ---*/
+/*! \brief  transmit_request: transmit generic SIP request ---*/
 static int transmit_request(struct sip_pvt *p, int sipmethod, int seqno, int reliable, int newbranch)
 {
        struct sip_request resp;
@@ -5522,7 +5545,7 @@ static int transmit_request(struct sip_pvt *p, int sipmethod, int seqno, int rel
        return send_request(p, &resp, reliable, seqno ? seqno : p->ocseq);
 }
 
-/*--- transmit_request_with_auth: Transmit SIP request, auth added ---*/
+/*! \brief  transmit_request_with_auth: Transmit SIP request, auth added ---*/
 static int transmit_request_with_auth(struct sip_pvt *p, int sipmethod, int seqno, int reliable, int newbranch)
 {
        struct sip_request resp;
@@ -5555,13 +5578,26 @@ static int transmit_request_with_auth(struct sip_pvt *p, int sipmethod, int seqn
        return send_request(p, &resp, reliable, seqno ? seqno : p->ocseq);      
 }
 
-/*--- expire_register: Expire registration of SIP peer ---*/
+static void destroy_association(struct sip_peer *peer)
+{
+       if (!ast_test_flag((&global_flags_page2), SIP_PAGE2_IGNOREREGEXPIRE)) {
+               if (ast_test_flag(&(peer->flags_page2), SIP_PAGE2_RT_FROMCONTACT)) {
+                       ast_update_realtime("sippeers", "name", peer->name, "fullcontact", "", "ipaddr", "", "port", "", "regseconds", "0", "username", "", NULL);
+               } else {
+                       ast_db_del("SIP/Registry", peer->name);
+               }
+       }
+}
+
+/*! \brief  expire_register: Expire registration of SIP peer ---*/
 static int expire_register(void *data)
 {
        struct sip_peer *peer = data;
 
        memset(&peer->addr, 0, sizeof(peer->addr));
-       ast_db_del("SIP/Registry", peer->name);
+
+       destroy_association(peer);
+       
        manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "Peer: SIP/%s\r\nPeerStatus: Unregistered\r\nCause: Expired\r\n", peer->name);
        register_peer_exten(peer, 0);
        peer->expire = -1;
@@ -5584,7 +5620,7 @@ static int sip_poke_peer_s(void *data)
        return 0;
 }
 
-/*--- reg_source_db: Get registration details from Asterisk DB ---*/
+/*! \brief  reg_source_db: Get registration details from Asterisk DB ---*/
 static void reg_source_db(struct sip_peer *peer)
 {
        char data[256];
@@ -5594,6 +5630,8 @@ static void reg_source_db(struct sip_peer *peer)
        int port;
        char *scan, *addr, *port_str, *expiry_str, *username, *contact;
 
+       if (ast_test_flag(&(peer->flags_page2), SIP_PAGE2_RT_FROMCONTACT)) 
+               return;
        if (ast_db_get("SIP/Registry", peer->name, data, sizeof(data)))
                return;
 
@@ -5643,7 +5681,7 @@ static void reg_source_db(struct sip_peer *peer)
        register_peer_exten(peer, 1);
 }
 
-/*--- parse_ok_contact: Parse contact header for 200 OK on INVITE ---*/
+/*! \brief  parse_ok_contact: Parse contact header for 200 OK on INVITE ---*/
 static int parse_ok_contact(struct sip_pvt *pvt, struct sip_request *req)
 {
        char contact[250]; 
@@ -5719,7 +5757,7 @@ enum parse_register_result {
        PARSE_REGISTER_QUERY,
 };
 
-/*--- parse_register_contact: Parse contact header and save registration ---*/
+/*! \brief  parse_register_contact: Parse contact header and save registration ---*/
 static enum parse_register_result parse_register_contact(struct sip_pvt *pvt, struct sip_peer *p, struct sip_request *req)
 {
        char contact[80]; 
@@ -5760,7 +5798,7 @@ static enum parse_register_result parse_register_contact(struct sip_pvt *pvt, st
           what we currently have stored as their contact address, so return
           it
        */
-       if (ast_strlen_zero(c) && (!expires || ast_strlen_zero(expires))) {
+       if (ast_strlen_zero(c) && ast_strlen_zero(expires)) {
                if ((p->expire > -1) && !ast_strlen_zero(p->fullcontact)) {
                        /* tell them when the registration is going to expire */
                        pvt->expiry = ast_sched_when(sched, p->expire);
@@ -5774,7 +5812,9 @@ static enum parse_register_result parse_register_contact(struct sip_pvt *pvt, st
                if (p->expire > -1)
                        ast_sched_del(sched, p->expire);
                p->expire = -1;
-               ast_db_del("SIP/Registry", p->name);
+
+               destroy_association(p);
+               
                register_peer_exten(p, 0);
                p->fullcontact[0] = '\0';
                p->useragent[0] = '\0';
@@ -5847,7 +5887,7 @@ static enum parse_register_result parse_register_contact(struct sip_pvt *pvt, st
                p->expire = -1;
        pvt->expiry = expiry;
        snprintf(data, sizeof(data), "%s:%d:%d:%s:%s", ast_inet_ntoa(iabuf, sizeof(iabuf), p->addr.sin_addr), ntohs(p->addr.sin_port), expiry, p->username, p->fullcontact);
-       if (!(ast_test_flag(p, SIP_REALTIME) && ast_test_flag((&p->flags_page2), SIP_PAGE2_RTCACHEFRIENDS)))
+       if (!ast_test_flag((&p->flags_page2), SIP_PAGE2_RT_FROMCONTACT)) 
                ast_db_put("SIP/Registry", p->name, data);
        manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "Peer: SIP/%s\r\nPeerStatus: Registered\r\n", p->name);
        if (inaddrcmp(&p->addr, &oldsin)) {
@@ -5871,7 +5911,7 @@ static enum parse_register_result parse_register_contact(struct sip_pvt *pvt, st
        return PARSE_REGISTER_UPDATE;
 }
 
-/*--- free_old_route: Remove route from route list ---*/
+/*! \brief  free_old_route: Remove route from route list ---*/
 static void free_old_route(struct sip_route *route)
 {
        struct sip_route *next;
@@ -5882,7 +5922,7 @@ static void free_old_route(struct sip_route *route)
        }
 }
 
-/*--- list_route: List all routes - mostly for debugging ---*/
+/*! \brief  list_route: List all routes - mostly for debugging ---*/
 static void list_route(struct sip_route *route)
 {
        if (!route) {
@@ -5895,7 +5935,7 @@ static void list_route(struct sip_route *route)
        }
 }
 
-/*--- build_route: Build route list from Record-Route header ---*/
+/*! \brief  build_route: Build route list from Record-Route header ---*/
 static void build_route(struct sip_pvt *p, struct sip_request *req, int backwards)
 {
        struct sip_route *thishop, *head, *tail;
@@ -5996,7 +6036,7 @@ static void build_route(struct sip_pvt *p, struct sip_request *req, int backward
 }
 
 #ifdef OSP_SUPPORT
-/*--- check_osptoken: Validate OSP token for user authrroization ---*/
+/*! \brief  check_osptoken: Validate OSP token for user authrroization ---*/
 static int check_osptoken (struct sip_pvt *p, char *token)
 {
        char tmp[80];
@@ -6011,7 +6051,7 @@ static int check_osptoken (struct sip_pvt *p, char *token)
 }
 #endif
 
-/*--- check_auth: Check user authorization from peer definition ---*/
+/*! \brief  check_auth: Check user authorization from peer definition ---*/
 /*      Some actions, like REGISTER and INVITEs from peers require
         authentication (if peer have secret set) */
 static int check_auth(struct sip_pvt *p, struct sip_request *req, char *randdata, int randlen, char *username, char *secret, char *md5secret, int sipmethod, char *uri, int reliable, int ignore)
@@ -6236,7 +6276,7 @@ static int check_auth(struct sip_pvt *p, struct sip_request *req, char *randdata
        return res;
 }
 
-/*--- cb_extensionstate: Callback for the devicestate notification (SUBSCRIBE) support subsystem ---*/
+/*! \brief  cb_extensionstate: Callback for the devicestate notification (SUBSCRIBE) support subsystem ---*/
 /*    If you add an "hint" priority to the extension in the dial plan,
       you will get notifications on device state changes */
 static int cb_extensionstate(char *context, char* exten, int state, void *data)
@@ -6265,7 +6305,7 @@ static int cb_extensionstate(char *context, char* exten, int state, void *data)
        return 0;
 }
 
-/*--- register_verify: Verify registration of user */
+/*! \brief  register_verify: Verify registration of user */
 static int register_verify(struct sip_pvt *p, struct sockaddr_in *sin, struct sip_request *req, char *uri, int ignore)
 {
        int res = -3;
@@ -6409,7 +6449,7 @@ static int register_verify(struct sip_pvt *p, struct sockaddr_in *sin, struct si
        return res;
 }
 
-/*--- get_rdnis: get referring dnis ---*/
+/*! \brief  get_rdnis: get referring dnis ---*/
 static int get_rdnis(struct sip_pvt *p, struct sip_request *oreq)
 {
        char tmp[256], *c, *a;
@@ -6437,7 +6477,7 @@ static int get_rdnis(struct sip_pvt *p, struct sip_request *oreq)
        return 0;
 }
 
-/*--- get_destination: Find out who the call is for --*/
+/*! \brief  get_destination: Find out who the call is for --*/
 static int get_destination(struct sip_pvt *p, struct sip_request *oreq)
 {
        char tmp[256] = "", *uri, *a;
@@ -6533,7 +6573,7 @@ static int get_destination(struct sip_pvt *p, struct sip_request *oreq)
        return -1;
 }
 
-/*--- get_sip_pvt_byid_locked: Lock interface lock and find matching pvt lock  ---*/
+/*! \brief  get_sip_pvt_byid_locked: Lock interface lock and find matching pvt lock  ---*/
 static struct sip_pvt *get_sip_pvt_byid_locked(char *callid) 
 {
        struct sip_pvt *sip_pvt_ptr = NULL;
@@ -6562,7 +6602,7 @@ static struct sip_pvt *get_sip_pvt_byid_locked(char *callid)
        return sip_pvt_ptr;
 }
 
-/*--- get_refer_info: Call transfer support (the REFER method) ---*/
+/*! \brief  get_refer_info: Call transfer support (the REFER method) ---*/
 static int get_refer_info(struct sip_pvt *sip_pvt, struct sip_request *outgoing_req)
 {
 
@@ -6699,7 +6739,7 @@ static int get_refer_info(struct sip_pvt *sip_pvt, struct sip_request *outgoing_
        return -1;
 }
 
-/*--- get_also_info: Call transfer support (old way, depreciated)--*/
+/*! \brief  get_also_info: Call transfer support (old way, depreciated)--*/
 static int get_also_info(struct sip_pvt *p, struct sip_request *oreq)
 {
        char tmp[256], *c, *a;
@@ -6741,7 +6781,7 @@ static int get_also_info(struct sip_pvt *p, struct sip_request *oreq)
        return -1;
 }
 
-/*--- check_via: check Via: headers ---*/
+/*! \brief  check_via: check Via: headers ---*/
 static int check_via(struct sip_pvt *p, struct sip_request *req)
 {
        char via[256];
@@ -6785,7 +6825,7 @@ static int check_via(struct sip_pvt *p, struct sip_request *req)
        return 0;
 }
 
-/*--- get_calleridname: Get caller id name from SIP headers ---*/
+/*! \brief  get_calleridname: Get caller id name from SIP headers ---*/
 static char *get_calleridname(char *input, char *output, size_t outputsize)
 {
        char *end = strchr(input,'<');
@@ -6826,7 +6866,7 @@ static char *get_calleridname(char *input, char *output, size_t outputsize)
        return output;
 }
 
-/*--- get_rpid_num: Get caller id number from Remote-Party-ID header field 
+/*! \brief  get_rpid_num: 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
  */
@@ -6858,7 +6898,7 @@ static int get_rpid_num(char *input,char *output, int maxlen)
 }
 
 
-/*--- check_user_full: Check if matching user or peer is defined ---*/
+/*! \brief  check_user_full: 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 int check_user_full(struct sip_pvt *p, struct sip_request *req, int sipmethod, char *uri, int reliable, struct sockaddr_in *sin, int ignore, char *mailbox, int mailboxlen)
@@ -7123,13 +7163,13 @@ static int check_user_full(struct sip_pvt *p, struct sip_request *req, int sipme
        return res;
 }
 
-/*--- check_user: Find user ---*/
+/*! \brief  check_user: Find user ---*/
 static int check_user(struct sip_pvt *p, struct sip_request *req, int sipmethod, char *uri, int reliable, struct sockaddr_in *sin, int ignore)
 {
        return check_user_full(p, req, sipmethod, uri, reliable, sin, ignore, NULL, 0);
 }
 
-/*--- get_msg_text: Get text out of a SIP MESSAGE packet ---*/
+/*! \brief  get_msg_text: Get text out of a SIP MESSAGE packet ---*/
 static int get_msg_text(char *buf, int len, struct sip_request *req)
 {
        int x;
@@ -7151,7 +7191,7 @@ static int get_msg_text(char *buf, int len, struct sip_request *req)
 }
 
                 
-/*--- receive_message: Receive SIP MESSAGE method messages ---*/
+/*! \brief  receive_message: Receive SIP MESSAGE method messages ---*/
 /*     We only handle messages within current calls currently */
 /*     Reference: RFC 3428 */
 static void receive_message(struct sip_pvt *p, struct sip_request *req)
@@ -7193,7 +7233,7 @@ static void receive_message(struct sip_pvt *p, struct sip_request *req)
        return;
 }
 
-/*--- sip_show_inuse: CLI Command to show calls within limits set by 
+/*! \brief  sip_show_inuse: CLI Command to show calls within limits set by 
       call_limit ---*/
 static int sip_show_inuse(int fd, int argc, char *argv[]) {
 #define FORMAT  "%-25.25s %-15.15s %-15.15s \n"
@@ -7240,7 +7280,7 @@ static int sip_show_inuse(int fd, int argc, char *argv[]) {
 #undef FORMAT2
 }
 
-/*--- nat2str: Convert NAT setting to text string */
+/*! \brief  nat2str: Convert NAT setting to text string */
 static char *nat2str(int nat)
 {
        switch(nat) {
@@ -7257,7 +7297,7 @@ static char *nat2str(int nat)
        }
 }
 
-/*--- peer_status: Report Peer status in character string */
+/*! \brief  peer_status: Report Peer status in character string */
 /*     returns 1 if peer is online, -1 if unmonitored */
 static int peer_status(struct sip_peer *peer, char *status, int statuslen)
 {
@@ -7282,7 +7322,7 @@ static int peer_status(struct sip_peer *peer, char *status, int statuslen)
        return res;
 }
                            
-/*--- sip_show_users: CLI Command 'SIP Show Users' ---*/
+/*! \brief  sip_show_users: CLI Command 'SIP Show Users' ---*/
 static int sip_show_users(int fd, int argc, char *argv[])
 {
        regex_t regexbuf;
@@ -7337,7 +7377,7 @@ static char mandescr_show_peers[] =
 
 static int _sip_show_peers(int fd, int *total, struct mansession *s, struct message *m, int argc, char *argv[]);
 
-/*--- manager_sip_show_peers: Show SIP peers in the manager API ---*/
+/*! \brief  manager_sip_show_peers: Show SIP peers in the manager API ---*/
 /*    Inspired from chan_iax2 */
 static int manager_sip_show_peers( struct mansession *s, struct message *m )
 {
@@ -7346,7 +7386,7 @@ static int manager_sip_show_peers( struct mansession *s, struct message *m )
        char idtext[256] = "";
        int total = 0;
 
-       if (id && !ast_strlen_zero(id))
+       if (!ast_strlen_zero(id))
                snprintf(idtext,256,"ActionID: %s\r\n",id);
 
        astman_send_ack(s, m, "Peer status list will follow");
@@ -7361,13 +7401,13 @@ static int manager_sip_show_peers( struct mansession *s, struct message *m )
        return 0;
 }
 
-/*--- sip_show_peers: CLI Show Peers command */
+/*! \brief  sip_show_peers: CLI Show Peers command */
 static int sip_show_peers(int fd, int argc, char *argv[])
 {
        return _sip_show_peers(fd, NULL, NULL, NULL, argc, argv);
 }
 
-/*--- _sip_show_peers: Execute sip show peers command */
+/*! \brief  _sip_show_peers: Execute sip show peers command */
 static int _sip_show_peers(int fd, int *total, struct mansession *s, struct message *m, int argc, char *argv[])
 {
        regex_t regexbuf;
@@ -7386,7 +7426,7 @@ static int _sip_show_peers(int fd, int *total, struct mansession *s, struct mess
 
        if (s) {        /* Manager - get ActionID */
                id = astman_get_header(m,"ActionID");
-               if (id && !ast_strlen_zero(id))
+               if (!ast_strlen_zero(id))
                        snprintf(idtext,256,"ActionID: %s\r\n",id);
        }
 
@@ -7500,7 +7540,7 @@ static int _sip_show_peers(int fd, int *total, struct mansession *s, struct mess
 #undef FORMAT2
 }
 
-/*--- sip_show_objects: List all allocated SIP Objects ---*/
+/*! \brief  sip_show_objects: List all allocated SIP Objects ---*/
 static int sip_show_objects(int fd, int argc, char *argv[])
 {
        char tmp[256];
@@ -7514,14 +7554,14 @@ static int sip_show_objects(int fd, int argc, char *argv[])
        ASTOBJ_CONTAINER_DUMP(fd, tmp, sizeof(tmp), &regl);
        return RESULT_SUCCESS;
 }
-/*--- print_group: Print call group and pickup group ---*/
-static void  print_group(int fd, unsigned int group) 
+/*! \brief  print_group: Print call group and pickup group ---*/
+static void  print_group(int fd, unsigned int group, int crlf) 
 {
        char buf[256];
-       ast_cli(fd, "%s\n", ast_print_group(buf, sizeof(buf), group) );
+       ast_cli(fd, crlf ? "%s\r\n" : "%s\n", ast_print_group(buf, sizeof(buf), group) );
 }
 
-/*--- dtmfmode2str: Convert DTMF mode to printable string ---*/
+/*! \brief  dtmfmode2str: Convert DTMF mode to printable string ---*/
 static const char *dtmfmode2str(int mode)
 {
        switch (mode) {
@@ -7537,7 +7577,7 @@ static const char *dtmfmode2str(int mode)
        return "<error>";
 }
 
-/*--- insecure2str: Convert Insecure setting to printable string ---*/
+/*! \brief  insecure2str: Convert Insecure setting to printable string ---*/
 static const char *insecure2str(int port, int invite)
 {
        if (port && invite)
@@ -7550,7 +7590,7 @@ static const char *insecure2str(int port, int invite)
                return "no";
 }
 
-/*--- sip_prune_realtime: Remove temporary realtime objects from memory (CLI) ---*/
+/*! \brief  sip_prune_realtime: Remove temporary realtime objects from memory (CLI) ---*/
 static int sip_prune_realtime(int fd, int argc, char *argv[])
 {
        struct sip_peer *peer;
@@ -7697,7 +7737,7 @@ static int sip_prune_realtime(int fd, int argc, char *argv[])
        return RESULT_SUCCESS;
 }
 
-/*--- print_codec_to_cli: Print codec list from preference to CLI/manager */
+/*! \brief  print_codec_to_cli: Print codec list from preference to CLI/manager */
 static void print_codec_to_cli(int fd, struct ast_codec_pref *pref) 
 {
        int x, codec;
@@ -7726,7 +7766,7 @@ static const char *domain_mode_to_text(const enum domain_mode mode)
        return "";
 }
 
-/*--- sip_show_domains: CLI command to list local domains */
+/*! \brief  sip_show_domains: CLI command to list local domains */
 #define FORMAT "%-40.40s %-20.20s %-16.16s\n"
 static int sip_show_domains(int fd, int argc, char *argv[])
 {
@@ -7757,7 +7797,7 @@ static char mandescr_show_peer[] =
 
 static int _sip_show_peer(int type, int fd, struct mansession *s, struct message *m, int argc, char *argv[]);
 
-/*--- manager_sip_show_peer: Show SIP peers in the manager API  ---*/
+/*! \brief  manager_sip_show_peer: Show SIP peers in the manager API  ---*/
 static int manager_sip_show_peer( struct mansession *s, struct message *m )
 {
        char *id = astman_get_header(m,"ActionID");
@@ -7766,7 +7806,7 @@ static int manager_sip_show_peer( struct mansession *s, struct message *m )
        int ret;
 
        peer = astman_get_header(m,"Peer");
-       if (!peer || ast_strlen_zero(peer)) {
+       if (ast_strlen_zero(peer)) {
                astman_send_error(s, m, "Peer: <name> missing.\n");
                return 0;
        }
@@ -7775,7 +7815,7 @@ static int manager_sip_show_peer( struct mansession *s, struct message *m )
        a[2] = "peer";
        a[3] = peer;
 
-       if (id && !ast_strlen_zero(id))
+       if (!ast_strlen_zero(id))
                ast_cli(s->fd, "ActionID: %s\r\n",id);
        ret = _sip_show_peer(1, s->fd, s, m, 4, a );
        ast_cli( s->fd, "\r\n\r\n" );
@@ -7784,7 +7824,7 @@ static int manager_sip_show_peer( struct mansession *s, struct message *m )
 
 
 
-/*--- sip_show_peer: Show one peer in detail ---*/
+/*! \brief  sip_show_peer: Show one peer in detail ---*/
 static int sip_show_peer(int fd, int argc, char *argv[])
 {
        return _sip_show_peer(0, fd, NULL, NULL, argc, argv);
@@ -7839,9 +7879,9 @@ static int _sip_show_peer(int type, int fd, struct mansession *s, struct message
                if (!ast_strlen_zero(peer->fromdomain))
                        ast_cli(fd, "  FromDomain   : %s\n", peer->fromdomain);
                ast_cli(fd, "  Callgroup    : ");
-               print_group(fd, peer->callgroup);
+               print_group(fd, peer->callgroup, 0);
                ast_cli(fd, "  Pickupgroup  : ");
-               print_group(fd, peer->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\n", peer->lastmsgssent);
@@ -7916,9 +7956,9 @@ static int _sip_show_peer(int type, int fd, struct mansession *s, struct message
                if (!ast_strlen_zero(peer->fromdomain))
                        ast_cli(fd, "SIP-FromDomain: %s\r\n", peer->fromdomain);
                ast_cli(fd, "Callgroup: ");
-               print_group(fd, peer->callgroup);
+               print_group(fd, peer->callgroup, 1);
                ast_cli(fd, "Pickupgroup: ");
-               print_group(fd, peer->pickupgroup);
+               print_group(fd, peer->pickupgroup, 1);
                ast_cli(fd, "VoiceMailbox: %s\r\n", peer->mailbox);
                ast_cli(fd, "LastMsgsSent: %d\r\n", peer->lastmsgssent);
                ast_cli(fd, "Call limit: %d\r\n", peer->call_limit);
@@ -7976,7 +8016,7 @@ static int _sip_show_peer(int type, int fd, struct mansession *s, struct message
        return RESULT_SUCCESS;
 }
 
-/*--- sip_show_user: Show one user in detail ---*/
+/*! \brief  sip_show_user: Show one user in detail ---*/
 static int sip_show_user(int fd, int argc, char *argv[])
 {
        char cbuf[256];
@@ -8005,9 +8045,9 @@ static int sip_show_user(int fd, int argc, char *argv[])
                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);
+               print_group(fd, user->callgroup, 0);
                ast_cli(fd, "  Pickupgroup  : ");
-               print_group(fd, user->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  : (");
@@ -8040,7 +8080,7 @@ static int sip_show_user(int fd, int argc, char *argv[])
        return RESULT_SUCCESS;
 }
 
-/*--- sip_show_registry: Show SIP Registry (registrations with other SIP proxies ---*/
+/*! \brief  sip_show_registry: Show SIP Registry (registrations with other SIP proxies ---*/
 static int sip_show_registry(int fd, int argc, char *argv[])
 {
 #define FORMAT2 "%-30.30s  %-12.12s  %8.8s %-20.20s\n"
@@ -8061,7 +8101,7 @@ static int sip_show_registry(int fd, int argc, char *argv[])
 #undef FORMAT2
 }
 
-/*--- sip_show_settings: List global settings for the SIP channel ---*/
+/*! \brief  sip_show_settings: List global settings for the SIP channel ---*/
 static int sip_show_settings(int fd, int argc, char *argv[])
 {
        char tmp[BUFSIZ];
@@ -8141,14 +8181,14 @@ static int sip_show_settings(int fd, int argc, char *argv[])
                ast_cli(fd, "  Realtime Users:         %s\n", realtimeusers ? "Yes" : "No");
                ast_cli(fd, "  Cache Friends:          %s\n", ast_test_flag(&global_flags_page2, SIP_PAGE2_RTCACHEFRIENDS) ? "Yes" : "No");
                ast_cli(fd, "  Update:                 %s\n", ast_test_flag(&global_flags_page2, SIP_PAGE2_RTUPDATE) ? "Yes" : "No");
-               ast_cli(fd, "  Ignore Reg. Expire:     %s\n", ast_test_flag(&global_flags_page2, SIP_PAGE2_RTIGNOREREGEXPIRE) ? "Yes" : "No");
+               ast_cli(fd, "  Ignore Reg. Expire:     %s\n", ast_test_flag(&global_flags_page2, SIP_PAGE2_IGNOREREGEXPIRE) ? "Yes" : "No");
                ast_cli(fd, "  Auto Clear:             %d\n", global_rtautoclear);
        }
        ast_cli(fd, "\n----\n");
        return RESULT_SUCCESS;
 }
 
-/*--- subscription_type2str: Show subscription type in string format */
+/*! \brief  subscription_type2str: Show subscription type in string format */
 static const char *subscription_type2str(enum subscriptiontype subtype) {
        int i;
 
@@ -8160,7 +8200,7 @@ static const char *subscription_type2str(enum subscriptiontype subtype) {
        return subscription_types[0].text;
 }
 
-/*--- find_subscription_type: Find subscription type in array */
+/*! \brief  find_subscription_type: Find subscription type in array */
 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype) {
        int i;
 
@@ -8175,13 +8215,13 @@ static const struct cfsubscription_types *find_subscription_type(enum subscripti
 /* Forward declaration */
 static int __sip_show_channels(int fd, int argc, char *argv[], int subscriptions);
 
-/*--- sip_show_channels: Show active SIP channels ---*/
+/*! \brief  sip_show_channels: Show active SIP channels ---*/
 static int sip_show_channels(int fd, int argc, char *argv[])  
 {
         return __sip_show_channels(fd, argc, argv, 0);
 }
  
-/*--- sip_show_subscriptions: Show active SIP subscriptions ---*/
+/*! \brief  sip_show_subscriptions: Show active SIP subscriptions ---*/
 static int sip_show_subscriptions(int fd, int argc, char *argv[])
 {
         return __sip_show_channels(fd, argc, argv, 1);
@@ -8235,7 +8275,7 @@ static int __sip_show_channels(int fd, int argc, char *argv[], int subscriptions
 #undef FORMAT3
 }
 
-/*--- complete_sipch: Support routine for 'sip show channel' CLI ---*/
+/*! \brief  complete_sipch: Support routine for 'sip show channel' CLI ---*/
 static char *complete_sipch(char *line, char *word, int pos, int state)
 {
        int which=0;
@@ -8257,7 +8297,7 @@ static char *complete_sipch(char *line, char *word, int pos, int state)
        return c;
 }
 
-/*--- complete_sip_peer: Do completion on peer name ---*/
+/*! \brief  complete_sip_peer: Do completion on peer name ---*/
 static char *complete_sip_peer(char *word, int state, int flags2)
 {
        char *result = NULL;
@@ -8277,7 +8317,7 @@ static char *complete_sip_peer(char *word, int state, int flags2)
        return result;
 }
 
-/*--- complete_sip_show_peer: Support routine for 'sip show peer' CLI ---*/
+/*! \brief  complete_sip_show_peer: Support routine for 'sip show peer' CLI ---*/
 static char *complete_sip_show_peer(char *line, char *word, int pos, int state)
 {
        if (pos == 3)
@@ -8286,7 +8326,7 @@ static char *complete_sip_show_peer(char *line, char *word, int pos, int state)
        return NULL;
 }
 
-/*--- complete_sip_debug_peer: Support routine for 'sip debug peer' CLI ---*/
+/*! \brief  complete_sip_debug_peer: Support routine for 'sip debug peer' CLI ---*/
 static char *complete_sip_debug_peer(char *line, char *word, int pos, int state)
 {
        if (pos == 3)
@@ -8295,7 +8335,7 @@ static char *complete_sip_debug_peer(char *line, char *word, int pos, int state)
        return NULL;
 }
 
-/*--- complete_sip_user: Do completion on user name ---*/
+/*! \brief  complete_sip_user: Do completion on user name ---*/
 static char *complete_sip_user(char *word, int state, int flags2)
 {
        char *result = NULL;
@@ -8315,7 +8355,7 @@ static char *complete_sip_user(char *word, int state, int flags2)
        return result;
 }
 
-/*--- complete_sip_show_user: Support routine for 'sip show user' CLI ---*/
+/*! \brief  complete_sip_show_user: Support routine for 'sip show user' CLI ---*/
 static char *complete_sip_show_user(char *line, char *word, int pos, int state)
 {
        if (pos == 3)
@@ -8324,7 +8364,7 @@ static char *complete_sip_show_user(char *line, char *word, int pos, int state)
        return NULL;
 }
 
-/*--- complete_sipnotify: Support routine for 'sip notify' CLI ---*/
+/*! \brief  complete_sipnotify: Support routine for 'sip notify' CLI ---*/
 static char *complete_sipnotify(char *line, char *word, int pos, int state)
 {
        char *c = NULL;
@@ -8357,7 +8397,7 @@ static char *complete_sipnotify(char *line, char *word, int pos, int state)
        return NULL;
 }
 
-/*--- complete_sip_prune_realtime_peer: Support routine for 'sip prune realtime peer' CLI ---*/
+/*! \brief  complete_sip_prune_realtime_peer: Support routine for 'sip prune realtime peer' CLI ---*/
 static char *complete_sip_prune_realtime_peer(char *line, char *word, int pos, int state)
 {
        if (pos == 4)
@@ -8365,7 +8405,7 @@ static char *complete_sip_prune_realtime_peer(char *line, char *word, int pos, i
        return NULL;
 }
 
-/*--- complete_sip_prune_realtime_user: Support routine for 'sip prune realtime user' CLI ---*/
+/*! \brief  complete_sip_prune_realtime_user: Support routine for 'sip prune realtime user' CLI ---*/
 static char *complete_sip_prune_realtime_user(char *line, char *word, int pos, int state)
 {
        if (pos == 4)
@@ -8374,7 +8414,7 @@ static char *complete_sip_prune_realtime_user(char *line, char *word, int pos, i
        return NULL;
 }
 
-/*--- sip_show_channel: Show details of one call ---*/
+/*! \brief  sip_show_channel: Show details of one call ---*/
 static int sip_show_channel(int fd, int argc, char *argv[])
 {
        struct sip_pvt *cur;
@@ -8441,7 +8481,7 @@ static int sip_show_channel(int fd, int argc, char *argv[])
        return RESULT_SUCCESS;
 }
 
-/*--- sip_show_history: Show history details of one call ---*/
+/*! \brief  sip_show_history: Show history details of one call ---*/
 static int sip_show_history(int fd, int argc, char *argv[])
 {
        struct sip_pvt *cur;
@@ -8483,7 +8523,7 @@ static int sip_show_history(int fd, int argc, char *argv[])
        return RESULT_SUCCESS;
 }
 
-/*--- dump_history: Dump SIP history to debug log file at end of 
+/*! \brief  dump_history: Dump SIP history to debug log file at end of 
   lifespan for SIP dialog */
 void sip_dump_history(struct sip_pvt *dialog)
 {
@@ -8512,7 +8552,7 @@ void sip_dump_history(struct sip_pvt *dialog)
 }
 
 
-/*--- handle_request_info: Receive SIP INFO Message ---*/
+/*! \brief  handle_request_info: Receive SIP INFO Message ---*/
 /*    Doesn't read the duration of the DTMF signal */
 static void handle_request_info(struct sip_pvt *p, struct sip_request *req)
 {
@@ -8599,7 +8639,7 @@ static void handle_request_info(struct sip_pvt *p, struct sip_request *req)
        return;
 }
 
-/*--- sip_do_debug: Enable SIP Debugging in CLI ---*/
+/*! \brief  sip_do_debug: Enable SIP Debugging in CLI ---*/
 static int sip_do_debug_ip(int fd, int argc, char *argv[])
 {
        struct hostent *hp;
@@ -8632,7 +8672,7 @@ static int sip_do_debug_ip(int fd, int argc, char *argv[])
        return RESULT_SUCCESS;
 }
 
-/*--- sip_do_debug_peer: Turn on SIP debugging with peer mask */
+/*! \brief  sip_do_debug_peer: Turn on SIP debugging with peer mask */
 static int sip_do_debug_peer(int fd, int argc, char *argv[])
 {
        struct sip_peer *peer;
@@ -8655,7 +8695,7 @@ static int sip_do_debug_peer(int fd, int argc, char *argv[])
        return RESULT_SUCCESS;
 }
 
-/*--- sip_do_debug: Turn on SIP debugging (CLI command) */
+/*! \brief  sip_do_debug: Turn on SIP debugging (CLI command) */
 static int sip_do_debug(int fd, int argc, char *argv[])
 {
        int oldsipdebug = sipdebug & SIP_DEBUG_CONSOLE;
@@ -8677,7 +8717,7 @@ static int sip_do_debug(int fd, int argc, char *argv[])
        return RESULT_SUCCESS;
 }
 
-/*--- sip_notify: Send SIP notify to peer */
+/*! \brief  sip_notify: Send SIP notify to peer */
 static int sip_notify(int fd, int argc, char *argv[])
 {
        struct ast_variable *varlist;
@@ -8734,7 +8774,7 @@ static int sip_notify(int fd, int argc, char *argv[])
 
        return RESULT_SUCCESS;
 }
-/*--- sip_do_history: Enable SIP History logging (CLI) ---*/
+/*! \brief  sip_do_history: Enable SIP History logging (CLI) ---*/
 static int sip_do_history(int fd, int argc, char *argv[])
 {
        if (argc != 2) {
@@ -8745,7 +8785,7 @@ static int sip_do_history(int fd, int argc, char *argv[])
        return RESULT_SUCCESS;
 }
 
-/*--- sip_no_history: Disable SIP History logging (CLI) ---*/
+/*! \brief  sip_no_history: Disable SIP History logging (CLI) ---*/
 static int sip_no_history(int fd, int argc, char *argv[])
 {
        if (argc != 3) {
@@ -8756,7 +8796,7 @@ static int sip_no_history(int fd, int argc, char *argv[])
        return RESULT_SUCCESS;
 }
 
-/*--- sip_no_debug: Disable SIP Debugging in CLI ---*/
+/*! \brief  sip_no_debug: Disable SIP Debugging in CLI ---*/
 static int sip_no_debug(int fd, int argc, char *argv[])
 
 {
@@ -8769,7 +8809,7 @@ static int sip_no_debug(int fd, int argc, char *argv[])
 
 static int reply_digest(struct sip_pvt *p, struct sip_request *req, char *header, int sipmethod, char *digest, int digest_len);
 
-/*--- do_register_auth: Authenticate for outbound registration ---*/
+/*! \brief  do_register_auth: Authenticate for outbound registration ---*/
 static int do_register_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader) 
 {
        char digest[1024];
@@ -8793,7 +8833,7 @@ static int do_register_auth(struct sip_pvt *p, struct sip_request *req, char *he
        return transmit_register(p->registry, SIP_REGISTER, digest, respheader); 
 }
 
-/*--- do_proxy_auth: Add authentication on outbound SIP packet ---*/
+/*! \brief  do_proxy_auth: Add authentication on outbound SIP packet ---*/
 static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader, int sipmethod, int init) 
 {
        char digest[1024];
@@ -8820,7 +8860,7 @@ static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, char *heade
        return transmit_invite(p, sipmethod, sipmethod == SIP_INVITE, init); 
 }
 
-/*--- reply_digest: reply to authentication for outbound registrations ---*/
+/*! \brief  reply_digest: reply to authentication for outbound registrations ---*/
 /*      This is used for register= servers in sip.conf, SIP proxies we register
         with  for receiving calls from.  */
 /*     Returns -1 if we have no auth */
@@ -8897,7 +8937,7 @@ static int reply_digest(struct sip_pvt *p, struct sip_request *req,
        return build_reply_digest(p, sipmethod, digest, digest_len); 
 }
 
-/*--- build_reply_digest:  Build reply digest ---*/
+/*! \brief  build_reply_digest:  Build reply digest ---*/
 /*      Build digest challenge for authentication of peers (for registration) 
        and users (for calls). Also used for authentication of CANCEL and BYE */
 /*     Returns -1 if we have no auth */
@@ -9063,7 +9103,7 @@ static char show_settings_usage[] =
 
 
 
-/*--- func_header_read: Read SIP header (dialplan function) */
+/*! \brief  func_header_read: Read SIP header (dialplan function) */
 static char *func_header_read(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len) 
 {
        struct sip_pvt *p;
@@ -9110,10 +9150,10 @@ static struct ast_custom_function sip_header_function = {
        .read = func_header_read,
 };
 
-/*--- function_check_sipdomain: Dial plan function to check if domain is local */
+/*! \brief  function_check_sipdomain: Dial plan function to check if domain is local */
 static char *func_check_sipdomain(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
 {
-       if (!data || ast_strlen_zero(data)) {
+       if (ast_strlen_zero(data)) {
                ast_log(LOG_WARNING, "CHECKSIPDOMAIN requires an argument - A domain name\n");
                return buf;
        }
@@ -9136,7 +9176,7 @@ static struct ast_custom_function checksipdomain_function = {
 };
 
 
-/*--- function_sippeer: ${SIPPEER()} Dialplan function - reads peer data */
+/*! \brief  function_sippeer: ${SIPPEER()} Dialplan function - reads peer data */
 static char *function_sippeer(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
 {
        char *ret = NULL;
@@ -9234,7 +9274,7 @@ struct ast_custom_function sippeer_function = {
        "\n"
 };
 
-/*--- function_sipchaninfo_read: ${SIPCHANINFO()} Dialplan function - reads sip channel data */
+/*! \brief  function_sipchaninfo_read: ${SIPCHANINFO()} Dialplan function - reads sip channel data */
 static char *function_sipchaninfo_read(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len) 
 {
        struct sip_pvt *p;
@@ -9301,7 +9341,7 @@ static struct ast_custom_function sipchaninfo_function = {
 
 
 
-/*--- parse_moved_contact: Parse 302 Moved temporalily response */
+/*! \brief  parse_moved_contact: Parse 302 Moved temporalily response */
 static void parse_moved_contact(struct sip_pvt *p, struct sip_request *req)
 {
        char tmp[256];
@@ -9335,7 +9375,7 @@ static void parse_moved_contact(struct sip_pvt *p, struct sip_request *req)
        }
 }
 
-/*--- check_pendings: Check pending actions on SIP call ---*/
+/*! \brief  check_pendings: Check pending actions on SIP call ---*/
 static void check_pendings(struct sip_pvt *p)
 {
        /* Go ahead and send bye at this point */
@@ -9351,7 +9391,7 @@ static void check_pendings(struct sip_pvt *p)
        }
 }
 
-/*--- handle_response_invite: Handle SIP response in dialogue ---*/
+/*! \brief  handle_response_invite: Handle SIP response in dialogue ---*/
 static void handle_response_invite(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int ignore, int seqno)
 {
        int outgoing = ast_test_flag(p, SIP_OUTGOING);
@@ -9484,7 +9524,7 @@ static void handle_response_invite(struct sip_pvt *p, int resp, char *rest, stru
        }
 }
 
-/*--- handle_response_register: Handle responses on REGISTER to services ---*/
+/*! \brief  handle_response_register: Handle responses on REGISTER to services ---*/
 static int handle_response_register(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int ignore, int seqno)
 {
        int expires, expires_ms;
@@ -9600,7 +9640,7 @@ static int handle_response_register(struct sip_pvt *p, int resp, char *rest, str
        return 1;
 }
 
-/*--- handle_response_peerpoke: Handle qualification responses (OPTIONS) */
+/*! \brief  handle_response_peerpoke: Handle qualification responses (OPTIONS) */
 static int handle_response_peerpoke(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int ignore, int seqno, int sipmethod)
 {
        struct sip_peer *peer;
@@ -9656,10 +9696,9 @@ static int handle_response_peerpoke(struct sip_pvt *p, int resp, char *rest, str
        return 1;
 }
 
-/*--- handle_response: Handle SIP response in dialogue ---*/
+/*! \brief  handle_response: Handle SIP response in dialogue ---*/
 static void handle_response(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int ignore, int seqno)
 {
-       char *to;
        char *msg, *c;
        struct ast_channel *owner;
        char iabuf[INET_ADDRSTRLEN];
@@ -9686,15 +9725,7 @@ static void handle_response(struct sip_pvt *p, int resp, char *rest, struct sip_
 
        /* Get their tag if we haven't already */
        if (ast_strlen_zero(p->theirtag) || (resp >= 200)) {
-               to = get_header(req, "To");
-               to = strcasestr(to, "tag=");
-               if (to) {
-                       to += 4;
-                       ast_copy_string(p->theirtag, to, sizeof(p->theirtag));
-                       to = strchr(p->theirtag, ';');
-                       if (to)
-                               *to = '\0';
-               }
+               gettag(req, "To", p->theirtag, sizeof(p->theirtag));
        }
        if (p->peerpoke) {
                /* We don't really care what the response is, just that it replied back. 
@@ -9877,6 +9908,12 @@ static void handle_response(struct sip_pvt *p, int resp, char *rest, struct sip_
                   get handled here. As well as out-of-call message responses */
                if (req->debug)
                        ast_verbose("SIP Response message for INCOMING dialog %s arrived\n", msg);
+               if (resp == 200) {
+                       /* Tags in early session is replaced by the tag in 200 OK, which is 
+                       the final reply to our INVITE */
+                       gettag(req, "To", p->theirtag, sizeof(p->theirtag));
+               }
+
                switch(resp) {
                case 200:
                        if (sipmethod == SIP_INVITE) {
@@ -9945,7 +9982,7 @@ struct sip_dual {
        struct sip_request req;
 };
 
-/*--- sip_park_thread: Park SIP call support function */
+/*! \brief  sip_park_thread: Park SIP call support function */
 static void *sip_park_thread(void *stuff)
 {
        struct ast_channel *chan1, *chan2;
@@ -9968,7 +10005,7 @@ static void *sip_park_thread(void *stuff)
        return NULL;
 }
 
-/*--- sip_park: Park a call ---*/
+/*! \brief  sip_park: Park a call ---*/
 static int sip_park(struct ast_channel *chan1, struct ast_channel *chan2, struct sip_request *req)
 {
        struct sip_dual *d;
@@ -10026,7 +10063,7 @@ static int sip_park(struct ast_channel *chan1, struct ast_channel *chan2, struct
        return -1;
 }
 
-/*--- ast_quiet_chan: Turn off generator data */
+/*! \brief  ast_quiet_chan: Turn off generator data */
 static void ast_quiet_chan(struct ast_channel *chan) 
 {
        if (chan && chan->_state == AST_STATE_UP) {
@@ -10035,7 +10072,7 @@ static void ast_quiet_chan(struct ast_channel *chan)
        }
 }
 
-/*--- attempt_transfer: Attempt transfer of SIP call ---*/
+/*! \brief  attempt_transfer: Attempt transfer of SIP call ---*/
 static int attempt_transfer(struct sip_pvt *p1, struct sip_pvt *p2)
 {
        int res = 0;
@@ -10106,7 +10143,29 @@ static int attempt_transfer(struct sip_pvt *p1, struct sip_pvt *p2)
        return 0;
 }
 
-/*--- handle_request_options: Handle incoming OPTIONS request */
+/*! \brief  gettag: Get tag from packet */
+static char *gettag(struct sip_request *req, char *header, char *tagbuf, int tagbufsize) 
+{
+
+       char *thetag, *sep;
+       
+
+       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);
+               sep = strchr(tagbuf, ';');
+               if (sep)
+                       *sep = '\0';
+       }
+       return thetag;
+}
+
+/*! \brief  handle_request_options: Handle incoming OPTIONS request */
 static int handle_request_options(struct sip_pvt *p, struct sip_request *req, int debug)
 {
        int res;
@@ -10130,7 +10189,7 @@ static int handle_request_options(struct sip_pvt *p, struct sip_request *req, in
        return res;
 }
 
-/*--- handle_request_invite: Handle incoming INVITE request */
+/*! \brief  handle_request_invite: Handle incoming INVITE request */
 static int handle_request_invite(struct sip_pvt *p, struct sip_request *req, int debug, int ignore, int seqno, struct sockaddr_in *sin, int *recount, char *e)
 {
        int res = 1;
@@ -10148,7 +10207,7 @@ static int handle_request_invite(struct sip_pvt *p, struct sip_request *req, int
                        parse_sip_options(p, supported);
        }
        required = get_header(req, "Required");
-       if (required && !ast_strlen_zero(required)) {
+       if (!ast_strlen_zero(required)) {
                required_profile = parse_sip_options(NULL, required);
                if (required_profile) {         /* They require something */
                        /* At this point we support no extensions, so fail */
@@ -10209,6 +10268,7 @@ static int handle_request_invite(struct sip_pvt *p, struct sip_request *req, int
                                else
                                        transmit_response_reliable(p, "403 Forbidden", req, 1);
                                ast_set_flag(p, SIP_NEEDDESTROY);       
+                               p->theirtag[0] = '\0'; /* Forget their to-tag, we'll get a new one */
                        }
                        return 0;
                }
@@ -10298,17 +10358,37 @@ static int handle_request_invite(struct sip_pvt *p, struct sip_request *req, int
                        transmit_response(p, "100 Trying", req);
                        ast_setstate(c, AST_STATE_RING);
                        if (strcmp(p->exten, ast_pickup_ext())) {
-                               if (ast_pbx_start(c)) {
+                               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");
+                                       if (ignore)
+                                               transmit_response(p, "503 Unavailable", req);
+                                       else
+                                               transmit_response_reliable(p, "503 Unavailable", req, 1);
+                                       break;
+                               case AST_PBX_CALL_LIMIT:
+                                       ast_log(LOG_WARNING, "Failed to start PBX (call limit reached) \n");
+                                       if (ignore)
+                                               transmit_response(p, "480 Temporarily Unavailable", req);
+                                       else
+                                               transmit_response_reliable(p, "480 Temporarily Unavailable", req, 1);
+                                       break;
+                               case AST_PBX_SUCCESS:
+                                       /* nothing to do */
+                                       break;
+                               }
+
+                               if (res) {
                                        ast_log(LOG_WARNING, "Failed to start PBX :(\n");
                                        /* 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);
-                                       if (ignore)
-                                               transmit_response(p, "503 Unavailable", req);
-                                       else
-                                               transmit_response_reliable(p, "503 Unavailable", req, 1);
                                        c = NULL;
                                }
                        } else {
@@ -10368,7 +10448,7 @@ static int handle_request_invite(struct sip_pvt *p, struct sip_request *req, int
        return res;
 }
 
-/*--- handle_request_refer: Handle incoming REFER request ---*/
+/*! \brief  handle_request_refer: Handle incoming REFER request ---*/
 static int handle_request_refer(struct sip_pvt *p, struct sip_request *req, int debug, int ignore, int seqno, int *nounlock)
 {
        struct ast_channel *c=NULL;
@@ -10435,7 +10515,7 @@ static int handle_request_refer(struct sip_pvt *p, struct sip_request *req, int
        }
        return res;
 }
-/*--- handle_request_cancel: Handle incoming CANCEL request ---*/
+/*! \brief  handle_request_cancel: Handle incoming CANCEL request ---*/
 static int handle_request_cancel(struct sip_pvt *p, struct sip_request *req, int debug, int ignore)
 {
                
@@ -10464,7 +10544,7 @@ static int handle_request_cancel(struct sip_pvt *p, struct sip_request *req, int
        }
 }
 
-/*--- handle_request_bye: Handle incoming BYE request ---*/
+/*! \brief  handle_request_bye: Handle incoming BYE request ---*/
 static int handle_request_bye(struct sip_pvt *p, struct sip_request *req, int debug, int ignore)
 {
        struct ast_channel *c=NULL;
@@ -10516,7 +10596,7 @@ static int handle_request_bye(struct sip_pvt *p, struct sip_request *req, int de
        return 1;
 }
 
-/*--- handle_request_message: Handle incoming MESSAGE request ---*/
+/*! \brief  handle_request_message: Handle incoming MESSAGE request ---*/
 static int handle_request_message(struct sip_pvt *p, struct sip_request *req, int debug, int ignore)
 {
        if (!ignore) {
@@ -10528,7 +10608,7 @@ static int handle_request_message(struct sip_pvt *p, struct sip_request *req, in
        }
        return 1;
 }
-/*--- handle_request_subscribe: Handle incoming SUBSCRIBE request ---*/
+/*! \brief  handle_request_subscribe: Handle incoming SUBSCRIBE request ---*/
 static int handle_request_subscribe(struct sip_pvt *p, struct sip_request *req, int debug, int ignore, struct sockaddr_in *sin, int seqno, char *e)
 {
        int gotdest;
@@ -10583,7 +10663,7 @@ static int handle_request_subscribe(struct sip_pvt *p, struct sip_request *req,
                        return 0;
                }
                /* Initialize the context if it hasn't been already */
-               if (p->subscribecontext && !ast_strlen_zero(p->subscribecontext))
+               if (!ast_strlen_zero(p->subscribecontext))
                        ast_copy_string(p->context, p->subscribecontext, sizeof(p->context));
                else if (ast_strlen_zero(p->context))
                        strcpy(p->context, default_context);
@@ -10693,7 +10773,7 @@ static int handle_request_subscribe(struct sip_pvt *p, struct sip_request *req,
        return 1;
 }
 
-/*--- handle_request_register: Handle incoming REGISTER request ---*/
+/*! \brief  handle_request_register: Handle incoming REGISTER request ---*/
 static int handle_request_register(struct sip_pvt *p, struct sip_request *req, int debug, int ignore, struct sockaddr_in *sin, char *e)
 {
        int res = 0;
@@ -10714,7 +10794,7 @@ static int handle_request_register(struct sip_pvt *p, struct sip_request *req, i
        return res;
 }
 
-/*--- handle_request: Handle SIP requests (methods) ---*/
+/*! \brief  handle_request: Handle SIP requests (methods) ---*/
 /*      this is where all incoming requests go first   */
 static int handle_request(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int *recount, int *nounlock)
 {
@@ -10723,7 +10803,6 @@ static int handle_request(struct sip_pvt *p, struct sip_request *req, struct soc
        struct sip_request resp;
        char *cmd;
        char *cseq;
-       char *from;
        char *useragent;
        int seqno;
        int len;
@@ -10733,6 +10812,7 @@ static int handle_request(struct sip_pvt *p, struct sip_request *req, struct soc
        char iabuf[INET_ADDRSTRLEN];
        int debug = sip_debug_test_pvt(p);
        char *e;
+       int error = 0;
 
        /* Clear out potential response */
        memset(&resp, 0, sizeof(resp));
@@ -10742,10 +10822,17 @@ static int handle_request(struct sip_pvt *p, struct sip_request *req, struct soc
        cmd = req->header[0];
 
        /* Must have Cseq */
-       if (ast_strlen_zero(cmd) || ast_strlen_zero(cseq))
-               return -1;
-       if (sscanf(cseq, "%d%n", &seqno, &len) != 1) {
-               ast_log(LOG_DEBUG, "No seqno in '%s'\n", cmd);
+       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.header) /* New call */
+                       ast_set_flag(p, SIP_NEEDDESTROY);       /* Make sure we destroy this dialog */
                return -1;
        }
        /* Get the command XXX */
@@ -10789,12 +10876,14 @@ static int handle_request(struct sip_pvt *p, struct sip_request *req, struct soc
        /* 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 > 2)
                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)) {
                ast_log(LOG_DEBUG, "Ignoring too old SIP packet packet %d (expecting >= %d)\n", seqno, p->icseq);
+               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, SIP_ALREADYGONE))) {
                /* ignore means "don't do anything with it" but still have to 
@@ -10813,18 +10902,28 @@ static int handle_request(struct sip_pvt *p, struct sip_request *req, struct soc
 
        /* Find their tag if we haven't got it */
        if (ast_strlen_zero(p->theirtag)) {
-               from = get_header(req, "From");
-               from = strcasestr(from, "tag=");
-               if (from) {
-                       from += 4;
-                       ast_copy_string(p->theirtag, from, sizeof(p->theirtag));
-                       from = strchr(p->theirtag, ';');
-                       if (from)
-                               *from = '\0';
-               }
+               gettag(req, "From", p->theirtag, sizeof(p->theirtag));
        }
        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 (!ignore && req->method == SIP_INVITE) {
+                               transmit_response_reliable(p, "481 Call/Transaction Does Not Exist", req, 1);
+                               /* Will cease to exist after ACK */
+                       } else {
+                               transmit_response(p, "481 Call/Transaction Does Not Exist", req);
+                               ast_set_flag(p, SIP_NEEDDESTROY);
+                       }
+                       return res;
+               }
+       }
+
        /* Handle various incoming SIP methods in requests */
        switch (p->method) {
        case SIP_OPTIONS:
@@ -10893,7 +10992,7 @@ static int handle_request(struct sip_pvt *p, struct sip_request *req, struct soc
        return res;
 }
 
-/*--- sipsock_read: Read data from SIP socket ---*/
+/*! \brief  sipsock_read: Read data from SIP socket ---*/
 /*    Successful messages is connected to SIP call and forwarded to handle_request() */
 static int sipsock_read(int *id, int fd, short events, void *ignore)
 {
@@ -10919,16 +11018,21 @@ static int sipsock_read(int *id, int fd, short events, void *ignore)
                        ast_log(LOG_WARNING, "Recv error: %s\n", strerror(errno));
                return 1;
        }
+       if (res == sizeof(req.data)) {
+               ast_log(LOG_DEBUG, "Received packet exceeds buffer. Data is possibly lost\n");
+       }
        req.data[res] = '\0';
        req.len = res;
-       req.debug = sip_debug_test_addr(&sin);
+       if(sip_debug_test_addr(&sin))
+               ast_set_flag(&req, SIP_PKT_DEBUG);
        if (pedanticsipchecking)
                req.len = lws2sws(req.data, req.len);   /* Fix multiline headers */
-       if (req.debug)
+       if (ast_test_flag(&req, SIP_PKT_DEBUG)) {
                ast_verbose("\n<-- SIP read from %s:%d: \n%s\n", ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port), req.data);
+       }
        parse_request(&req);
        req.method = find_sip_method(req.rlPart1);
-       if (req.debug) {
+       if (ast_test_flag(&req, SIP_PKT_DEBUG)) {
                ast_verbose("--- (%d headers %d lines)", req.headers, req.lines);
                if (req.headers + req.lines == 0) 
                        ast_verbose(" Nat keepalive ");
@@ -10963,7 +11067,11 @@ retrylock:
                        append_history(p, "Rx", tmp);
                }
                nounlock = 0;
-               handle_request(p, &req, &sin, &recount, &nounlock);
+               if (handle_request(p, &req, &sin, &recount, &nounlock) == -1) {
+                       /* Request failed */
+                       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_mutex_unlock(&p->owner->lock);
                ast_mutex_unlock(&p->lock);
@@ -10975,7 +11083,7 @@ retrylock:
        return 1;
 }
 
-/*--- sip_send_mwi_to_peer: Send message waiting indication ---*/
+/*! \brief  sip_send_mwi_to_peer: Send message waiting indication ---*/
 static int sip_send_mwi_to_peer(struct sip_peer *peer)
 {
        /* Called with peerl lock, but releases it */
@@ -11015,7 +11123,7 @@ static int sip_send_mwi_to_peer(struct sip_peer *peer)
        return 0;
 }
 
-/*--- do_monitor: The SIP monitoring thread ---*/
+/*! \brief  do_monitor: The SIP monitoring thread ---*/
 static void *do_monitor(void *data)
 {
        int res;
@@ -11109,9 +11217,14 @@ restartsearch:
                if (fastrestart)
                        res = 1;
                res = ast_io_wait(io, res);
+               if (res > 20)
+                       ast_log(LOG_WARNING, "chan_sip: ast_io_wait ran %d all at once\n", res);
                ast_mutex_lock(&monlock);
-               if (res >= 0) 
-                       ast_sched_runq(sched);
+               if (res >= 0)  {
+                       res = ast_sched_runq(sched);
+                       if (res >= 20)
+                               ast_log(LOG_WARNING, "chan_sip: ast_sched_runq ran %d all at once\n", res);
+               }
 
                /* needs work to send mwi to realtime peers */
                time(&t);
@@ -11143,7 +11256,7 @@ restartsearch:
        
 }
 
-/*--- restart_monitor: Start the channel monitor thread ---*/
+/*! \brief  restart_monitor: Start the channel monitor thread ---*/
 static int restart_monitor(void)
 {
        pthread_attr_t attr;
@@ -11176,7 +11289,7 @@ static int restart_monitor(void)
        return 0;
 }
 
-/*--- sip_poke_noanswer: No answer to Qualify poke ---*/
+/*! \brief  sip_poke_noanswer: No answer to Qualify poke ---*/
 static int sip_poke_noanswer(void *data)
 {
        struct sip_peer *peer = data;
@@ -11196,7 +11309,7 @@ static int sip_poke_noanswer(void *data)
        return 0;
 }
 
-/*--- sip_poke_peer: Check availability of peer, also keep NAT open ---*/
+/*! \brief  sip_poke_peer: Check availability of peer, also keep NAT open ---*/
 /*     This is done with the interval in qualify= option in sip.conf */
 /*     Default is 2 seconds */
 static int sip_poke_peer(struct sip_peer *peer)
@@ -11257,7 +11370,7 @@ static int sip_poke_peer(struct sip_peer *peer)
        return 0;
 }
 
-/*--- sip_devicestate: Part of PBX channel interface ---*/
+/*! \brief  sip_devicestate: Part of PBX channel interface ---*/
 
 /* Return values:---
        If we have qualify on and the device is not reachable, regardless of registration
@@ -11322,7 +11435,7 @@ static int sip_devicestate(void *data)
        return res;
 }
 
-/*--- sip_request: PBX interface function -build SIP pvt structure ---*/
+/*! \brief  sip_request: PBX interface function -build SIP pvt structure ---*/
 /* SIP calls initiated by the PBX arrive here */
 static struct ast_channel *sip_request_call(const char *type, int format, void *data, int *cause)
 {
@@ -11404,7 +11517,7 @@ static struct ast_channel *sip_request_call(const char *type, int format, void *
        return tmpc;
 }
 
-/*--- handle_common_options: Handle flag-type options common to users and peers ---*/
+/*! \brief  handle_common_options: Handle flag-type options common to users and peers ---*/
 static int handle_common_options(struct ast_flags *flags, struct ast_flags *mask, struct ast_variable *v)
 {
        int res = 0;
@@ -11513,12 +11626,12 @@ static int handle_common_options(struct ast_flags *flags, struct ast_flags *mask
        return res;
 }
 
-/*--- add_sip_domain: Add SIP domain to list of domains we are responsible for */
+/*! \brief  add_sip_domain: Add SIP domain to list of domains we are responsible for */
 static int add_sip_domain(const char *domain, const enum domain_mode mode, const char *context)
 {
        struct domain *d;
 
-       if (!domain || ast_strlen_zero(domain)) {
+       if (ast_strlen_zero(domain)) {
                ast_log(LOG_WARNING, "Zero length domain.\n");
                return 1;
        }
@@ -11531,7 +11644,7 @@ static int add_sip_domain(const char *domain, const enum domain_mode mode, const
 
        ast_copy_string(d->domain, domain, sizeof(d->domain));
 
-       if (context && !ast_strlen_zero(context))
+       if (!ast_strlen_zero(context))
                ast_copy_string(d->context, context, sizeof(d->context));
 
        d->mode = mode;
@@ -11546,7 +11659,7 @@ static int add_sip_domain(const char *domain, const enum domain_mode mode, const
        return 1;
 }
 
-/*--- check_sip_domain: Check if domain part of uri is local to our server */
+/*! \brief  check_sip_domain: Check if domain part of uri is local to our server */
 static int check_sip_domain(const char *domain, char *context, size_t len)
 {
        struct domain *d;
@@ -11568,7 +11681,7 @@ static int check_sip_domain(const char *domain, char *context, size_t len)
        return result;
 }
 
-/*--- clear_sip_domains: Clear our domain list (at reload) */
+/*! \brief  clear_sip_domains: Clear our domain list (at reload) */
 static void clear_sip_domains(void)
 {
        struct domain *d;
@@ -11580,7 +11693,7 @@ static void clear_sip_domains(void)
 }
 
 
-/*--- add_realm_authentication: Add realm authentication in list ---*/
+/*! \brief  add_realm_authentication: Add realm authentication in list ---*/
 static struct sip_auth *add_realm_authentication(struct sip_auth *authlist, char *configuration, int lineno)
 {
        char authcopy[256];
@@ -11589,7 +11702,7 @@ static struct sip_auth *add_realm_authentication(struct sip_auth *authlist, char
        struct sip_auth *auth;
        struct sip_auth *b = NULL, *a = authlist;
 
-       if (!configuration || ast_strlen_zero(configuration))
+       if (ast_strlen_zero(configuration))
                return authlist;
 
        ast_log(LOG_DEBUG, "Auth config ::  %s\n", configuration);
@@ -11603,7 +11716,7 @@ static struct sip_auth *add_realm_authentication(struct sip_auth *authlist, char
                *realm = '\0';
                realm++;
        }
-       if (!username || ast_strlen_zero(username) || !realm || ast_strlen_zero(realm)) {
+       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;
        }
@@ -11647,7 +11760,7 @@ static struct sip_auth *add_realm_authentication(struct sip_auth *authlist, char
 
 }
 
-/*--- clear_realm_authentication: Clear realm authentication list (at reload) ---*/
+/*! \brief  clear_realm_authentication: Clear realm authentication list (at reload) ---*/
 static int clear_realm_authentication(struct sip_auth *authlist)
 {
        struct sip_auth *a = authlist;
@@ -11662,7 +11775,7 @@ static int clear_realm_authentication(struct sip_auth *authlist)
        return 1;
 }
 
-/*--- find_realm_authentication: Find authentication for a specific realm ---*/
+/*! \brief  find_realm_authentication: Find authentication for a specific realm ---*/
 static struct sip_auth *find_realm_authentication(struct sip_auth *authlist, char *realm)
 {
        struct sip_auth *a = authlist;  /* First entry in auth list */
@@ -11677,7 +11790,7 @@ static struct sip_auth *find_realm_authentication(struct sip_auth *authlist, cha
        return a;
 }
 
-/*--- build_user: Initiate a SIP user structure from sip.conf ---*/
+/*! \brief  build_user: Initiate a SIP user structure from sip.conf ---*/
 static struct sip_user *build_user(const char *name, struct ast_variable *v, int realtime)
 {
        struct sip_user *user;
@@ -11741,7 +11854,7 @@ static struct sip_user *build_user(const char *name, struct ast_variable *v, int
                        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, "musiconhold")) {
+               } else if (!strcasecmp(v->name, "musicclass") || !strcasecmp(v->name, "musiconhold")) {
                        ast_copy_string(user->musicclass, v->value, sizeof(user->musicclass));
                } else if (!strcasecmp(v->name, "accountcode")) {
                        ast_copy_string(user->accountcode, v->value, sizeof(user->accountcode));
@@ -11775,7 +11888,7 @@ static struct sip_user *build_user(const char *name, struct ast_variable *v, int
        return user;
 }
 
-/*--- temp_peer: Create temporary peer (used in autocreatepeer mode) ---*/
+/*! \brief  temp_peer: Create temporary peer (used in autocreatepeer mode) ---*/
 static struct sip_peer *temp_peer(const char *name)
 {
        struct sip_peer *peer;
@@ -11810,7 +11923,7 @@ static struct sip_peer *temp_peer(const char *name)
        return peer;
 }
 
-/*--- build_peer: Build peer from config file ---*/
+/*! \brief  build_peer: Build peer from config file ---*/
 static struct sip_peer *build_peer(const char *name, struct ast_variable *v, int realtime)
 {
        struct sip_peer *peer = NULL;
@@ -11903,7 +12016,10 @@ static struct sip_peer *build_peer(const char *name, struct ast_variable *v, int
                        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 (!strcasecmp(v->name, "secret")) 
+               else if (realtime && !strcasecmp(v->name, "fullcontact")) {
+                       ast_copy_string(peer->fullcontact, v->value, sizeof(peer->fullcontact));
+                       ast_set_flag((&peer->flags_page2), 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));
@@ -12046,11 +12162,12 @@ static struct sip_peer *build_peer(const char *name, struct ast_variable *v, int
                 */
                v=v->next;
        }
-       if (realtime && !ast_test_flag((&global_flags_page2), SIP_PAGE2_RTIGNOREREGEXPIRE) && ast_test_flag(peer, SIP_DYNAMIC)) {
+       if (!ast_test_flag((&global_flags_page2), SIP_PAGE2_IGNOREREGEXPIRE) && ast_test_flag(peer, SIP_DYNAMIC)) {
                time_t nowtime;
 
                time(&nowtime);
                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 (%ld/%ld/%ld)!\n", nowtime - regseconds, regseconds, nowtime);
@@ -12064,7 +12181,7 @@ static struct sip_peer *build_peer(const char *name, struct ast_variable *v, int
        return peer;
 }
 
-/*--- reload_config: Re-read SIP.conf config file ---*/
+/*! \brief  reload_config: Re-read SIP.conf config file ---*/
 /*     This function reloads all config data, except for
        active peers (with registrations). They will only
        change configuration data at restart, not at reload.
@@ -12168,8 +12285,8 @@ static int reload_config(void)
                        ast_set2_flag((&global_flags_page2), ast_true(v->value), SIP_PAGE2_RTCACHEFRIENDS);     
                } else if (!strcasecmp(v->name, "rtupdate")) {
                        ast_set2_flag((&global_flags_page2), ast_true(v->value), SIP_PAGE2_RTUPDATE);   
-               } else if (!strcasecmp(v->name, "rtignoreregexpire")) {
-                       ast_set2_flag((&global_flags_page2), ast_true(v->value), SIP_PAGE2_RTIGNOREREGEXPIRE);  
+               } else if (!strcasecmp(v->name, "ignoreregexpire")) {
+                       ast_set2_flag((&global_flags_page2), ast_true(v->value), SIP_PAGE2_IGNOREREGEXPIRE);    
                } else if (!strcasecmp(v->name, "rtautoclear")) {
                        int i = atoi(v->value);
                        if (i > 0)
@@ -12307,7 +12424,7 @@ static int reload_config(void)
 
                        if (ast_strlen_zero(domain))
                                ast_log(LOG_WARNING, "Empty domain specified at line %d\n", v->lineno);
-                       else if (context && ast_strlen_zero(context))
+                       else if (ast_strlen_zero(context))
                                ast_log(LOG_WARNING, "Empty context specified at line %d for domain '%s'\n", v->lineno, domain);
                        else
                                add_sip_domain(ast_strip(domain), SIP_DOMAIN_CONFIG, context ? ast_strip(context) : "");
@@ -12465,7 +12582,7 @@ static int reload_config(void)
        return 0;
 }
 
-/*--- sip_get_rtp_peer: Returns null if we can't reinvite (part of RTP interface) */
+/*! \brief  sip_get_rtp_peer: Returns null if we can't reinvite (part of RTP interface) */
 static struct ast_rtp *sip_get_rtp_peer(struct ast_channel *chan)
 {
        struct sip_pvt *p;
@@ -12480,7 +12597,7 @@ static struct ast_rtp *sip_get_rtp_peer(struct ast_channel *chan)
        return rtp;
 }
 
-/*--- sip_get_vrtp_peer: Returns null if we can't reinvite video (part of RTP interface) */
+/*! \brief  sip_get_vrtp_peer: Returns null if we can't reinvite video (part of RTP interface) */
 static struct ast_rtp *sip_get_vrtp_peer(struct ast_channel *chan)
 {
        struct sip_pvt *p;
@@ -12496,7 +12613,7 @@ static struct ast_rtp *sip_get_vrtp_peer(struct ast_channel *chan)
        return rtp;
 }
 
-/*--- sip_set_rtp_peer: Set the RTP peer for this call ---*/
+/*! \brief  sip_set_rtp_peer: Set the RTP peer for this call ---*/
 static int sip_set_rtp_peer(struct ast_channel *chan, struct ast_rtp *rtp, struct ast_rtp *vrtp, int codecs, int nat_active)
 {
        struct sip_pvt *p;
@@ -12561,7 +12678,7 @@ static char *descrip_sipgetheader = ""
 "Skips to priority+101 if header does not exist\n"
 "Otherwise returns 0\n";
 
-/*--- sip_dtmfmode: change the DTMFmode for a SIP call (application) ---*/
+/*! \brief  sip_dtmfmode: change the DTMFmode for a SIP call (application) ---*/
 static int sip_dtmfmode(struct ast_channel *chan, void *data)
 {
        struct sip_pvt *p;
@@ -12611,7 +12728,7 @@ static int sip_dtmfmode(struct ast_channel *chan, void *data)
        return 0;
 }
 
-/*--- sip_addheader: Add a SIP header ---*/
+/*! \brief  sip_addheader: Add a SIP header ---*/
 static int sip_addheader(struct ast_channel *chan, void *data)
 {
        int arglen;
@@ -12647,7 +12764,7 @@ static int sip_addheader(struct ast_channel *chan, void *data)
        return 0;
 }
 
-/*--- sip_getheader: Get a SIP header (dialplan app) ---*/
+/*! \brief  sip_getheader: Get a SIP header (dialplan app) ---*/
 static int sip_getheader(struct ast_channel *chan, void *data)
 {
        static int dep_warning = 0;
@@ -12695,7 +12812,7 @@ static int sip_getheader(struct ast_channel *chan, void *data)
        return 0;
 }
 
-/*--- sip_sipredirect: Transfer call before connect with a 302 redirect ---*/
+/*! \brief  sip_sipredirect: Transfer call before connect with a 302 redirect ---*/
 /* Called by the transfer() dialplan application through the sip_transfer() */
 /* pbx interface function if the call is in ringing state */
 /* coded by Martin Pycko (m78pl@yahoo.com) */
@@ -12752,21 +12869,9 @@ static int sip_sipredirect(struct sip_pvt *p, const char *dest)
                }
        }
 
-       /* make sure the forwarding won't be forever */
-       ast_copy_string(tmp, get_header(&p->initreq, "Max-Forwards"), sizeof(tmp));
-       if (strlen(tmp) && atoi(tmp)) {
-               /* we found Max-Forwards in the original SIP request */
-               p->maxforwards = atoi(tmp) - 1;
-       } else {
-               /* just send our 302 Moved Temporarily */
-               p->maxforwards = DEFAULT_MAX_FORWARDS - 1;
-       }
-       if (p->maxforwards > -1) {
-               snprintf(p->our_contact, sizeof(p->our_contact), "Transfer <sip:%s@%s%s%s>", extension, host, port ? ":" : "", port ? port : "");
-               transmit_response_reliable(p, "302 Moved Temporarily", &p->initreq, 1);
-       } else {
-               transmit_response(p, "483 Too Many Hops", &p->initreq);
-       }
+       snprintf(p->our_contact, sizeof(p->our_contact), "Transfer <sip:%s@%s%s%s>", extension, host, port ? ":" : "", port ? port : "");
+       transmit_response_reliable(p, "302 Moved Temporarily", &p->initreq, 1);
+
        /* this is all that we want to send to that SIP device */
        ast_set_flag(p, SIP_ALREADYGONE);
 
@@ -12774,14 +12879,14 @@ static int sip_sipredirect(struct sip_pvt *p, const char *dest)
        return -1;
 }
 
-/*--- sip_get_codec: Return SIP UA's codec (part of the RTP interface) ---*/
+/*! \brief  sip_get_codec: Return SIP UA's codec (part of the RTP interface) ---*/
 static int sip_get_codec(struct ast_channel *chan)
 {
        struct sip_pvt *p = chan->tech_pvt;
        return p->peercapability;       
 }
 
-/*--- sip_rtp: Interface structure with callbacks used to connect to rtp module --*/
+/*! \brief  sip_rtp: Interface structure with callbacks used to connect to rtp module --*/
 static struct ast_rtp_protocol sip_rtp = {
        type: channeltype,
        get_rtp_info: sip_get_rtp_peer,
@@ -12790,7 +12895,7 @@ static struct ast_rtp_protocol sip_rtp = {
        get_codec: sip_get_codec,
 };
 
-/*--- sip_poke_all_peers: Send a poke to all known peers */
+/*! \brief  sip_poke_all_peers: Send a poke to all known peers */
 static void sip_poke_all_peers(void)
 {
        ASTOBJ_CONTAINER_TRAVERSE(&peerl, 1, do {
@@ -12801,23 +12906,29 @@ static void sip_poke_all_peers(void)
        );
 }
 
-/*--- sip_send_all_registers: Send all known registrations */
+/*! \brief  sip_send_all_registers: Send all known registrations */
 static void sip_send_all_registers(void)
 {
        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 = (rand() >> 12) & 0x1fff;
+               ms += regspacing;
                iterator->expire = ast_sched_add(sched, ms, sip_reregister, iterator);
                ASTOBJ_UNLOCK(iterator);
        } while (0)
        );
 }
 
-/*--- sip_do_reload: Reload module */
+/*! \brief  sip_do_reload: Reload module */
 static int sip_do_reload(void)
 {
        clear_realm_authentication(authl);
@@ -12837,7 +12948,7 @@ static int sip_do_reload(void)
        return 0;
 }
 
-/*--- sip_reload: Force reload of module from cli ---*/
+/*! \brief  sip_reload: Force reload of module from cli ---*/
 static int sip_reload(int fd, int argc, char *argv[])
 {
 
@@ -12852,7 +12963,7 @@ static int sip_reload(int fd, int argc, char *argv[])
        return 0;
 }
 
-/*--- reload: Part of Asterisk module interface ---*/
+/*! \brief  reload: Part of Asterisk module interface ---*/
 int reload(void)
 {
        return sip_reload(0, 0, NULL);
@@ -12888,7 +12999,7 @@ static struct ast_cli_entry  my_clis[] = {
        { { "sip", "reload", NULL }, sip_reload, "Reload SIP configuration", sip_reload_usage },
 };
 
-/*--- load_module: PBX load module - initialization ---*/
+/*! \brief  load_module: PBX load module - initialization ---*/
 int load_module()
 {
        ASTOBJ_CONTAINER_INIT(&userl);  /* User object list */