channels/chan_sip.c

   1 /*
   2  * Asterisk -- A telephony toolkit for Linux.
   3  *
   4  * Implementation of Session Initiation Protocol
   5  *
   6  * Copyright (C) 2004 - 2005, Digium, Inc.
   7  *
   8  * Mark Spencer <markster@digium.com>
   9  *
  10  * This program is free software, distributed under the terms of
  11  * the GNU General Public License
  12  */
  13
  14
  15 #include <stdio.h>
  16 #include <ctype.h>
  17 #include <string.h>
  18 #include <asterisk/lock.h>
  19 #include <asterisk/channel.h>
  20 #include <asterisk/config.h>
  21 #include <asterisk/logger.h>
  22 #include <asterisk/module.h>
  23 #include <asterisk/pbx.h>
  24 #include <asterisk/options.h>
  25 #include <asterisk/lock.h>
  26 #include <asterisk/sched.h>
  27 #include <asterisk/io.h>
  28 #include <asterisk/rtp.h>
  29 #include <asterisk/acl.h>
  30 #include <asterisk/manager.h>
  31 #include <asterisk/callerid.h>
  32 #include <asterisk/cli.h>
  33 #include <asterisk/app.h>
  34 #include <asterisk/musiconhold.h>
  35 #include <asterisk/dsp.h>
  36 #include <asterisk/features.h>
  37 #include <asterisk/acl.h>
  38 #include <asterisk/srv.h>
  39 #include <asterisk/astdb.h>
  40 #include <asterisk/causes.h>
  41 #include <asterisk/utils.h>
  42 #include <asterisk/file.h>
  43 #include <asterisk/astobj.h>
  44 #ifdef OSP_SUPPORT
  45 #include <asterisk/astosp.h>
  46 #endif
  47 #include <sys/socket.h>
  48 #include <sys/ioctl.h>
  49 #include <net/if.h>
  50 #include <errno.h>
  51 #include <unistd.h>
  52 #include <stdlib.h>
  53 #include <fcntl.h>
  54 #include <netdb.h>
  55 #include <arpa/inet.h>
  56 #include <signal.h>
  57 #include <sys/signal.h>
  58 #include <netinet/in_systm.h>
  59 #include <netinet/ip.h>
  60 #include <regex.h>
  61
  62 #ifndef DEFAULT_USERAGENT
  63 #define DEFAULT_USERAGENT "Asterisk PBX"
  64 #endif
  65
  66 #define VIDEO_CODEC_MASK        0x1fc0000 /* Video codecs from H.261 thru AST_FORMAT_MAX_VIDEO */
  67 #ifndef IPTOS_MINCOST
  68 #define IPTOS_MINCOST 0x02
  69 #endif
  70
  71 /* #define VOCAL_DATA_HACK */
  72
  73 #define SIPDUMPER
  74 #define DEFAULT_DEFAULT_EXPIRY  120
  75 #define DEFAULT_MAX_EXPIRY      3600
  76 #define DEFAULT_REGISTRATION_TIMEOUT    20
  77
  78 /* guard limit must be larger than guard secs */
  79 /* guard min must be < 1000, and should be >= 250 */
  80 #define EXPIRY_GUARD_SECS       15      /* How long before expiry do we reregister */
  81 #define EXPIRY_GUARD_LIMIT      30      /* Below here, we use EXPIRY_GUARD_PCT instead of
  82                                            EXPIRY_GUARD_SECS */
  83 #define EXPIRY_GUARD_MIN        500     /* This is the minimum guard time applied. If
  84                                            GUARD_PCT turns out to be lower than this, it
  85                                            will use this time instead.
  86                                            This is in milliseconds. */
  87 #define EXPIRY_GUARD_PCT        0.20    /* Percentage of expires timeout to use when
  88                                            below EXPIRY_GUARD_LIMIT */
  89
  90 static int max_expiry = DEFAULT_MAX_EXPIRY;
  91 static int default_expiry = DEFAULT_DEFAULT_EXPIRY;
  92
  93 #ifndef MAX
  94 #define MAX(a,b) ((a) > (b) ? (a) : (b))
  95 #endif
  96
  97 #define CALLERID_UNKNOWN        "Unknown"
  98
  99
 100
 101 #define DEFAULT_MAXMS           2000            /* Must be faster than 2 seconds by default */
 102 #define DEFAULT_FREQ_OK         60 * 1000       /* How often to check for the host to be up */
 103 #define DEFAULT_FREQ_NOTOK      10 * 1000       /* How often to check, if the host is down... */
 104
 105 #define DEFAULT_RETRANS         1000            /* How frequently to retransmit */
 106 #define MAX_RETRANS             5               /* Try only 5 times for retransmissions */
 107
 108
 109 #define DEBUG_READ      0                       /* Recieved data        */
 110 #define DEBUG_SEND      1                       /* Transmit data        */
 111
 112 static const char desc[] = "Session Initiation Protocol (SIP)";
 113 static const char channeltype[] = "SIP";
 114 static const char config[] = "sip.conf";
 115 static const char notify_config[] = "sip_notify.conf";
 116
 117 #define DEFAULT_SIP_PORT        5060    /* From RFC 2543 */
 118 #define SIP_MAX_PACKET          4096    /* Also from RFC 2543, should sub headers tho */
 119
 120 #define ALLOWED_METHODS "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER"
 121
 122 static char default_useragent[AST_MAX_EXTENSION] = DEFAULT_USERAGENT;
 123
 124 #define DEFAULT_CONTEXT "default"
 125 static char default_context[AST_MAX_EXTENSION] = DEFAULT_CONTEXT;
 126
 127 static char default_language[MAX_LANGUAGE] = "";
 128
 129 #define DEFAULT_CALLERID "asterisk"
 130 static char default_callerid[AST_MAX_EXTENSION] = DEFAULT_CALLERID;
 131
 132 static char default_fromdomain[AST_MAX_EXTENSION] = "";
 133
 134 #define DEFAULT_NOTIFYMIME "application/simple-message-summary"
 135 static char default_notifymime[AST_MAX_EXTENSION] = DEFAULT_NOTIFYMIME;
 136
 137
 138 static int default_qualify = 0;         /* Default Qualify= setting */
 139
 140 static struct ast_flags global_flags = {0};             /* global SIP_ flags */
 141 static struct ast_flags global_flags_page2 = {0};       /* more global SIP_ flags */
 142
 143 static int srvlookup = 0;               /* SRV Lookup on or off. Default is off, RFC behavior is on */
 144
 145 static int pedanticsipchecking = 0;     /* Extra checking ?  Default off */
 146
 147 static int autocreatepeer = 0;          /* Auto creation of peers at registration? Default off. */
 148
 149 static int relaxdtmf = 0;
 150
 151 static int global_rtptimeout = 0;
 152
 153 static int global_rtpholdtimeout = 0;
 154
 155 static int global_rtpkeepalive = 0;
 156
 157 static int global_reg_timeout = DEFAULT_REGISTRATION_TIMEOUT;
 158
 159 /* Object counters */
 160 static int suserobjs = 0;
 161 static int ruserobjs = 0;
 162 static int speerobjs = 0;
 163 static int rpeerobjs = 0;
 164 static int apeerobjs = 0;
 165 static int regobjs = 0;
 166
 167 static int global_allowguest = 1;    /* allow unauthenticated users/peers to connect? */
 168
 169 #define DEFAULT_MWITIME 10
 170 static int global_mwitime = DEFAULT_MWITIME;    /* Time between MWI checks for peers */
 171
 172 static int usecnt =0;
 173 AST_MUTEX_DEFINE_STATIC(usecnt_lock);
 174
 175
 176 /* Protect the interface list (of sip_pvt's) */
 177 AST_MUTEX_DEFINE_STATIC(iflock);
 178
 179 /* Protect the monitoring thread, so only one process can kill or start it, and not
 180    when it's doing something critical. */
 181 AST_MUTEX_DEFINE_STATIC(netlock);
 182
 183 AST_MUTEX_DEFINE_STATIC(monlock);
 184
 185 /* This is the thread for the monitor which checks for input on the channels
 186    which are not currently in use.  */
 187 static pthread_t monitor_thread = AST_PTHREADT_NULL;
 188
 189 static int restart_monitor(void);
 190
 191 /* Codecs that we support by default: */
 192 static int global_capability = AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_GSM | AST_FORMAT_H263;
 193 static int noncodeccapability = AST_RTP_DTMF;
 194
 195 static struct in_addr __ourip;
 196 static struct sockaddr_in outboundproxyip;
 197 static int ourport;
 198
 199 static int sipdebug = 0;
 200 static struct sockaddr_in debugaddr;
 201
 202 static int tos = 0;
 203
 204 static int videosupport = 0;
 205
 206 static int compactheaders = 0;                          /* send compact sip headers */
 207
 208 static int recordhistory = 0;                           /* Record SIP history. Off by default */
 209
 210 static char global_musicclass[MAX_LANGUAGE] = "";       /* Global music on hold class */
 211 #define DEFAULT_REALM   "asterisk"
 212 static char global_realm[AST_MAX_EXTENSION] = DEFAULT_REALM;    /* Default realm */
 213 static char regcontext[AST_MAX_EXTENSION] = "";         /* Context for auto-extensions */
 214
 215 /* Expire slowly */
 216 #define DEFAULT_EXPIRY 900
 217 static int expiry = DEFAULT_EXPIRY;
 218
 219 static struct sched_context *sched;
 220 static struct io_context *io;
 221 /* The private structures of the  sip channels are linked for
 222    selecting outgoing channels */
 223
 224 #define SIP_MAX_HEADERS         64
 225 #define SIP_MAX_LINES           64
 226
 227 #define DEC_IN_USE      0
 228 #define INC_IN_USE      1
 229 #define DEC_OUT_USE     2
 230 #define INC_OUT_USE     3
 231
 232 static struct ast_codec_pref prefs;
 233
 234
 235 /* sip_request: The data grabbed from the UDP socket */
 236 struct sip_request {
 237         char *rlPart1;          /* SIP Method Name or "SIP/2.0" protocol version */
 238         char *rlPart2;          /* The Request URI or Response Status */
 239         int len;                /* Length */
 240         int headers;            /* # of SIP Headers */
 241         char *header[SIP_MAX_HEADERS];
 242         int lines;                                              /* SDP Content */
 243         char *line[SIP_MAX_LINES];
 244         char data[SIP_MAX_PACKET];
 245 };
 246
 247 struct sip_pkt;
 248
 249 struct sip_route {
 250         struct sip_route *next;
 251         char hop[0];
 252 };
 253
 254 struct sip_history {
 255         char event[80];
 256         struct sip_history *next;
 257 };
 258
 259 #define SIP_ALREADYGONE         (1 << 0)        /* Whether or not we've already been destroyed by our peer */
 260 #define SIP_NEEDDESTROY         (1 << 1)        /* if we need to be destroyed */
 261 #define SIP_NOVIDEO             (1 << 2)        /* Didn't get video in invite, don't offer */
 262 #define SIP_RINGING             (1 << 3)        /* Have sent 180 ringing */
 263 #define SIP_PROGRESS_SENT       (1 << 4)        /* Have sent 183 message progress */
 264 #define SIP_NEEDREINVITE        (1 << 5)        /* Do we need to send another reinvite? */
 265 #define SIP_PENDINGBYE          (1 << 6)        /* Need to send bye after we ack? */
 266 #define SIP_GOTREFER            (1 << 7)        /* Got a refer? */
 267 #define SIP_PROMISCREDIR        (1 << 8)        /* Promiscuous redirection */
 268 #define SIP_TRUSTRPID           (1 << 9)        /* Trust RPID headers? */
 269 #define SIP_USEREQPHONE         (1 << 10)       /* Add user=phone to numeric URI. Default off */
 270 #define SIP_REALTIME            (1 << 11)       /* Flag for realtime users */
 271 #define SIP_USECLIENTCODE       (1 << 12)       /* Trust X-ClientCode info message */
 272 #define SIP_OUTGOING            (1 << 13)       /* Is this an outgoing call? */
 273 #define SIP_SELFDESTRUCT        (1 << 14)
 274 #define SIP_DYNAMIC             (1 << 15)       /* Is this a dynamic peer? */
 275 /* --- Choices for DTMF support in SIP channel */
 276 #define SIP_DTMF                (3 << 16)       /* three settings, uses two bits */
 277 #define SIP_DTMF_RFC2833        (0 << 16)       /* RTP DTMF */
 278 #define SIP_DTMF_INBAND         (1 << 16)       /* Inband audio, only for ULAW/ALAW */
 279 #define SIP_DTMF_INFO           (2 << 16)       /* SIP Info messages */
 280 /* NAT settings */
 281 #define SIP_NAT                 (3 << 18)       /* four settings, uses two bits */
 282 #define SIP_NAT_NEVER           (0 << 18)       /* No nat support */
 283 #define SIP_NAT_RFC3581         (1 << 18)
 284 #define SIP_NAT_ROUTE           (2 << 18)
 285 #define SIP_NAT_ALWAYS          (3 << 18)
 286 /* re-INVITE related settings */
 287 #define SIP_REINVITE            (3 << 20)       /* two bits used */
 288 #define SIP_CAN_REINVITE        (1 << 20)       /* allow peers to be reinvited to send media directly p2p */
 289 #define SIP_REINVITE_UPDATE     (2 << 20)       /* use UPDATE (RFC3311) when reinviting this peer */
 290 /* "insecure" settings */
 291 #define SIP_INSECURE            (3 << 22)       /* three settings, uses two bits */
 292 #define SIP_SECURE              (0 << 22)
 293 #define SIP_INSECURE_NORMAL     (1 << 22)
 294 #define SIP_INSECURE_VERY       (2 << 22)
 295 /* Sending PROGRESS in-band settings */
 296 #define SIP_PROG_INBAND         (3 << 24)       /* three settings, uses two bits */
 297 #define SIP_PROG_INBAND_NEVER   (0 << 24)
 298 #define SIP_PROG_INBAND_NO      (1 << 24)
 299 #define SIP_PROG_INBAND_YES     (2 << 24)
 300 /* Open Settlement Protocol authentication */
 301 #define SIP_OSPAUTH             (3 << 26)       /* three settings, uses two bits */
 302 #define SIP_OSPAUTH_NO          (0 << 26)
 303 #define SIP_OSPAUTH_YES         (1 << 26)
 304 #define SIP_OSPAUTH_EXCLUSIVE   (2 << 26)
 305 /* Call states */
 306 #define SIP_CALL_ONHOLD         (1 << 28)
 307 #define SIP_CALL_LIMIT          (1 << 29)
 308
 309 /* a new page of flags for peer */
 310 #define SIP_PAGE2_RTCACHEFRIENDS        (1 << 0)
 311 #define SIP_PAGE2_RTNOUPDATE            (1 << 1)
 312 #define SIP_PAGE2_RTAUTOCLEAR           (1 << 2)
 313
 314 static int global_rtautoclear = 120;
 315
 316 /* sip_pvt: PVT structures are used for each SIP conversation, ie. a call  */
 317 static struct sip_pvt {
 318         ast_mutex_t lock;                       /* Channel private lock */
 319         char callid[80];                        /* Global CallID */
 320         char randdata[80];                      /* Random data */
 321         struct ast_codec_pref prefs;            /* codec prefs */
 322         unsigned int ocseq;                     /* Current outgoing seqno */
 323         unsigned int icseq;                     /* Current incoming seqno */
 324         ast_group_t callgroup;                  /* Call group */
 325         ast_group_t pickupgroup;                /* Pickup group */
 326         int lastinvite;                         /* Last Cseq of invite */
 327         unsigned int flags;                     /* SIP_ flags */
 328         int capability;                         /* Special capability (codec) */
 329         int jointcapability;                    /* Supported capability at both ends (codecs ) */
 330         int peercapability;                     /* Supported peer capability */
 331         int prefcodec;                          /* Preferred codec (outbound only) */
 332         int noncodeccapability;
 333         int callingpres;                        /* Calling presentation */
 334         int authtries;                          /* Times we've tried to authenticate */
 335         int expiry;                             /* How long we take to expire */
 336         int branch;                             /* One random number */
 337         int tag;                                /* Another random number */
 338         int sessionid;                          /* SDP Session ID */
 339         int sessionversion;                     /* SDP Session Version */
 340         struct sockaddr_in sa;                  /* Our peer */
 341         struct sockaddr_in redirip;             /* Where our RTP should be going if not to us */
 342         struct sockaddr_in vredirip;            /* Where our Video RTP should be going if not to us */
 343         int redircodecs;                        /* Redirect codecs */
 344         struct sockaddr_in recv;                /* Received as */
 345         struct in_addr ourip;                   /* Our IP */
 346         struct ast_channel *owner;              /* Who owns us */
 347         char exten[AST_MAX_EXTENSION];          /* Extension where to start */
 348         char refer_to[AST_MAX_EXTENSION];       /* Place to store REFER-TO extension */
 349         char referred_by[AST_MAX_EXTENSION];    /* Place to store REFERRED-BY extension */
 350         char refer_contact[AST_MAX_EXTENSION];  /* Place to store Contact info from a REFER extension */
 351         struct sip_pvt *refer_call;             /* Call we are referring */
 352         struct sip_route *route;                /* Head of linked list of routing steps (fm Record-Route) */
 353         int route_persistant;                   /* Is this the "real" route? */
 354         char from[256];                         /* The From: header */
 355         char useragent[256];                    /* User agent in SIP request */
 356         char context[AST_MAX_EXTENSION];        /* Context for this call */
 357         char fromdomain[AST_MAX_EXTENSION];     /* Domain to show in the from field */
 358         char fromuser[AST_MAX_EXTENSION];       /* User to show in the user field */
 359         char fromname[AST_MAX_EXTENSION];       /* Name to show in the user field */
 360         char tohost[AST_MAX_EXTENSION];         /* Host we should put in the "to" field */
 361         char language[MAX_LANGUAGE];            /* Default language for this call */
 362         char musicclass[MAX_LANGUAGE];          /* Music on Hold class */
 363         char rdnis[256];                        /* Referring DNIS */
 364         char theirtag[256];                     /* Their tag */
 365         char username[256];                     /* [user] name */
 366         char peername[256];                     /* [peer] name, not set if [user] */
 367         char authname[256];                     /* Who we use for authentication */
 368         char uri[256];                          /* Original requested URI */
 369         char okcontacturi[256];                 /* URI from the 200 OK on INVITE */
 370         char peersecret[256];                   /* Password */
 371         char peermd5secret[256];
 372         char cid_num[256];                      /* Caller*ID */
 373         char cid_name[256];                     /* Caller*ID */
 374         char via[256];                          /* Via: header */
 375         char fullcontact[128];                  /* The Contact: that the UA registers with us */
 376         char accountcode[20];                   /* Account code */
 377         char our_contact[256];                  /* Our contact header */
 378         char realm[256];                        /* Authorization realm */
 379         char nonce[256];                        /* Authorization nonce */
 380         char opaque[256];                       /* Opaque nonsense */
 381         char qop[80];                           /* Quality of Protection, since SIP wasn't complicated enough yet. */
 382         char domain[256];                       /* Authorization domain */
 383         char lastmsg[256];                      /* Last Message sent/received */
 384         int amaflags;                           /* AMA Flags */
 385         int pendinginvite;                      /* Any pending invite */
 386 #ifdef OSP_SUPPORT
 387         int osphandle;                          /* OSP Handle for call */
 388         time_t ospstart;                        /* OSP Start time */
 389 #endif
 390         struct sip_request initreq;             /* Initial request */
 391
 392         int maxtime;                            /* Max time for first response */
 393         int maxforwards;                        /* keep the max-forwards info */
 394         int initid;                             /* Auto-congest ID if appropriate */
 395         int autokillid;                         /* Auto-kill ID */
 396         time_t lastrtprx;                       /* Last RTP received */
 397         time_t lastrtptx;                       /* Last RTP sent */
 398         int rtptimeout;                         /* RTP timeout time */
 399         int rtpholdtimeout;                     /* RTP timeout when on hold */
 400         int rtpkeepalive;                       /* Send RTP packets for keepalive */
 401
 402         int subscribed;                         /* Is this call a subscription?  */
 403         int stateid;
 404         int dialogver;
 405
 406         struct ast_dsp *vad;                    /* Voice Activation Detection dsp */
 407
 408         struct sip_peer *peerpoke;              /* If this calls is to poke a peer, which one */
 409         struct sip_registry *registry;          /* If this is a REGISTER call, to which registry */
 410         struct ast_rtp *rtp;                    /* RTP Session */
 411         struct ast_rtp *vrtp;                   /* Video RTP session */
 412         struct sip_pkt *packets;                /* Packets scheduled for re-transmission */
 413         struct sip_history *history;            /* History of this SIP dialog */
 414         struct ast_variable *chanvars;          /* Channel variables to set for call */
 415         struct sip_pvt *next;                   /* Next call in chain */
 416 } *iflist = NULL;
 417
 418 #define FLAG_RESPONSE (1 << 0)
 419 #define FLAG_FATAL (1 << 1)
 420
 421 /* sip packet - read in sipsock_read, transmitted in send_request */
 422 struct sip_pkt {
 423         struct sip_pkt *next;                   /* Next packet */
 424         int retrans;                            /* Retransmission number */
 425         int seqno;                              /* Sequence number */
 426         unsigned int flags;                     /* non-zero if this is a response packet (e.g. 200 OK) */
 427         struct sip_pvt *owner;                  /* Owner call */
 428         int retransid;                          /* Retransmission ID */
 429         int packetlen;                          /* Length of packet */
 430         char data[0];
 431 };
 432
 433 /* Structure for SIP user data. User's place calls to us */
 434 struct sip_user {
 435         /* Users who can access various contexts */
 436         ASTOBJ_COMPONENTS(struct sip_user);
 437         char secret[80];                /* Password */
 438         char md5secret[80];             /* Password in md5 */
 439         char context[80];               /* Default context for incoming calls */
 440         char cid_num[80];               /* Caller ID num */
 441         char cid_name[80];              /* Caller ID name */
 442         char accountcode[20];           /* Account code */
 443         char language[MAX_LANGUAGE];    /* Default language for this user */
 444         char musicclass[MAX_LANGUAGE];  /* Music on Hold class */
 445         char useragent[256];            /* User agent in SIP request */
 446         struct ast_codec_pref prefs;    /* codec prefs */
 447         ast_group_t callgroup;          /* Call group */
 448         ast_group_t pickupgroup;        /* Pickup Group */
 449         unsigned int flags;             /* SIP_ flags */
 450         int amaflags;                   /* AMA flags for billing */
 451         int callingpres;                /* Calling id presentation */
 452         int capability;                 /* Codec capability */
 453         int inUse;                      /* Number of calls in use */
 454         int incominglimit;              /* Limit of incoming calls */
 455         int outUse;                     /* disabled */
 456         int outgoinglimit;              /* disabled */
 457         struct ast_ha *ha;              /* ACL setting */
 458         struct ast_variable *chanvars;  /* Variables to set for channel created by user */
 459 };
 460
 461 /* Structure for SIP peer data, we place calls to peers if registred  or fixed IP address (host) */
 462 struct sip_peer {
 463         ASTOBJ_COMPONENTS(struct sip_peer);     /* name, refcount, objflags,  object pointers */
 464                                         /* peer->name is the unique name of this object */
 465         char secret[80];                /* Password */
 466         char md5secret[80];             /* Password in MD5 */
 467         char context[80];               /* Default context for incoming calls */
 468         char username[80];              /* Temporary username until registration */
 469         char accountcode[20];           /* Account code */
 470         int amaflags;                   /* AMA Flags (for billing) */
 471         char tohost[80];                /* If not dynamic, IP address */
 472         char regexten[AST_MAX_EXTENSION]; /* Extension to register (if regcontext is used) */
 473         char fromuser[80];              /* From: user when calling this peer */
 474         char fromdomain[80];            /* From: domain when calling this peer */
 475         char fullcontact[128];          /* Contact registred with us (not in sip.conf) */
 476         char cid_num[80];               /* Caller ID num */
 477         char cid_name[80];              /* Caller ID name */
 478         int callingpres;                /* Calling id presentation */
 479         int inUse;                      /* Number of calls in use */
 480         int incominglimit;              /* Limit of incoming calls */
 481         int outUse;                     /* disabled */
 482         int outgoinglimit;              /* disabled */
 483         char mailbox[AST_MAX_EXTENSION]; /* Mailbox setting for MWI checks */
 484         char language[MAX_LANGUAGE];    /* Default language for prompts */
 485         char musicclass[MAX_LANGUAGE];  /* Music on Hold class */
 486         char useragent[256];            /* User agent in SIP request (saved from registration) */
 487         struct ast_codec_pref prefs;    /* codec prefs */
 488         int lastmsgssent;
 489         time_t  lastmsgcheck;           /* Last time we checked for MWI */
 490         unsigned int flags;             /* SIP_ flags */
 491         struct ast_flags flags_page2;   /* SIP_PAGE2 flags */
 492         int expire;                     /* When to expire this peer registration */
 493         int expiry;                     /* Duration of registration */
 494         int capability;                 /* Codec capability */
 495         int rtptimeout;                 /* RTP timeout */
 496         int rtpholdtimeout;             /* RTP Hold Timeout */
 497         int rtpkeepalive;               /* Send RTP packets for keepalive */
 498         ast_group_t callgroup;          /* Call group */
 499         ast_group_t pickupgroup;        /* Pickup group */
 500         struct sockaddr_in addr;        /* IP address of peer */
 501         struct in_addr mask;
 502
 503         /* Qualification */
 504         struct sip_pvt *call;           /* Call pointer */
 505         int pokeexpire;                 /* When to expire poke (qualify= checking) */
 506         int lastms;                     /* How long last response took (in ms), or -1 for no response */
 507         int maxms;                      /* Max ms we will accept for the host to be up, 0 to not monitor */
 508         struct timeval ps;              /* Ping send time */
 509
 510         struct sockaddr_in defaddr;     /* Default IP address, used until registration */
 511         struct ast_ha *ha;              /* Access control list */
 512         struct ast_variable *chanvars;  /* Variables to set for channel created by user */
 513         int lastmsg;
 514 };
 515
 516 AST_MUTEX_DEFINE_STATIC(sip_reload_lock);
 517 static int sip_reloading = 0;
 518
 519 /* States for outbound registrations (with register= lines in sip.conf */
 520 #define REG_STATE_UNREGISTERED          0
 521 #define REG_STATE_REGSENT               1
 522 #define REG_STATE_AUTHSENT              2
 523 #define REG_STATE_REGISTERED            3
 524 #define REG_STATE_REJECTED              4
 525 #define REG_STATE_TIMEOUT               5
 526 #define REG_STATE_NOAUTH                6
 527
 528
 529 /* sip_registry: Registrations with other SIP proxies */
 530 struct sip_registry {
 531         ASTOBJ_COMPONENTS_FULL(struct sip_registry,1,1);
 532         int portno;                     /* Optional port override */
 533         char username[80];              /* Who we are registering as */
 534         char authuser[80];              /* Who we *authenticate* as */
 535         char hostname[80];              /* Domain or host we register to */
 536         char secret[80];                /* Password or key name in []'s */
 537         char md5secret[80];
 538         char contact[80];               /* Contact extension */
 539         char random[80];
 540         int expire;                     /* Sched ID of expiration */
 541         int timeout;                    /* sched id of sip_reg_timeout */
 542         int refresh;                    /* How often to refresh */
 543         struct sip_pvt *call;           /* create a sip_pvt structure for each outbound "registration call" in progress */
 544         int regstate;                   /* Registration state (see above) */
 545         int callid_valid;               /* 0 means we haven't chosen callid for this registry yet. */
 546         char callid[80];                /* Global CallID for this registry */
 547         unsigned int ocseq;             /* Sequence number we got to for REGISTERs for this registry */
 548         struct sockaddr_in us;          /* Who the server thinks we are */
 549
 550                                         /* Saved headers */
 551         char realm[256];                /* Authorization realm */
 552         char nonce[256];                /* Authorization nonce */
 553         char domain[256];               /* Authorization domain */
 554         char opaque[256];               /* Opaque nonsense */
 555         char qop[80];                   /* Quality of Protection. */
 556
 557         char lastmsg[256];              /* Last Message sent/received */
 558 };
 559
 560 /*--- The user list: Users and friends ---*/
 561 static struct ast_user_list {
 562         ASTOBJ_CONTAINER_COMPONENTS(struct sip_user);
 563 } userl;
 564
 565 /*--- The peer list: Peers and Friends ---*/
 566 static struct ast_peer_list {
 567         ASTOBJ_CONTAINER_COMPONENTS(struct sip_peer);
 568 } peerl;
 569
 570 /*--- The register list: Other SIP proxys we register with and call ---*/
 571 static struct ast_register_list {
 572         ASTOBJ_CONTAINER_COMPONENTS(struct sip_registry);
 573         int recheck;
 574 } regl;
 575
 576
 577 static int __sip_do_register(struct sip_registry *r);
 578
 579 static int sipsock  = -1;
 580
 581
 582 static struct sockaddr_in bindaddr;
 583 static struct sockaddr_in externip;
 584 static char externhost[256] = "";
 585 static time_t externexpire = 0;
 586 static int externrefresh = 10;
 587 static struct ast_ha *localaddr;
 588
 589 /* The list of manual NOTIFY types we know how to send */
 590 struct ast_config *notify_types;
 591
 592 static struct ast_frame  *sip_read(struct ast_channel *ast);
 593 static int transmit_response(struct sip_pvt *p, char *msg, struct sip_request *req);
 594 static int transmit_response_with_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans);
 595 static int transmit_response_with_auth(struct sip_pvt *p, char *msg, struct sip_request *req, char *rand, int reliable, char *header);
 596 static int transmit_request(struct sip_pvt *p, char *msg, int inc, int reliable, int newbranch);
 597 static int transmit_request_with_auth(struct sip_pvt *p, char *msg, int inc, int reliable, int newbranch);
 598 static int transmit_invite(struct sip_pvt *p, char *msg, int sendsdp, char *auth, char *authheader, char *vxml_url, char *distinctive_ring, char *osptoken, int addsipheaders, int init);
 599 static int transmit_reinvite_with_sdp(struct sip_pvt *p);
 600 static int transmit_info_with_digit(struct sip_pvt *p, char digit);
 601 static int transmit_message_with_text(struct sip_pvt *p, char *text);
 602 static int transmit_refer(struct sip_pvt *p, char *dest);
 603 static int sip_sipredirect(struct sip_pvt *p, char *dest);
 604 static struct sip_peer *temp_peer(char *name);
 605 static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader, char *msg, int init);
 606 static void free_old_route(struct sip_route *route);
 607 static int build_reply_digest(struct sip_pvt *p, char *orig_header, char *digest, int digest_len);
 608 static int update_user_counter(struct sip_pvt *fup, int event);
 609 static void prune_peers(void);
 610 static struct sip_peer *build_peer(const char *name, struct ast_variable *v, int realtime);
 611 static struct sip_user *build_user(const char *name, struct ast_variable *v, int realtime);
 612 static int sip_do_reload(void);
 613 static int expire_register(void *data);
 614 static int callevents = 0;
 615
 616 static struct ast_channel *sip_request(const char *type, int format, void *data, int *cause);
 617 static int sip_devicestate(void *data);
 618 static int sip_sendtext(struct ast_channel *ast, char *text);
 619 static int sip_call(struct ast_channel *ast, char *dest, int timeout);
 620 static int sip_hangup(struct ast_channel *ast);
 621 static int sip_answer(struct ast_channel *ast);
 622 static struct ast_frame *sip_read(struct ast_channel *ast);
 623 static int sip_write(struct ast_channel *ast, struct ast_frame *frame);
 624 static int sip_indicate(struct ast_channel *ast, int condition);
 625 static int sip_transfer(struct ast_channel *ast, char *dest);
 626 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
 627 static int sip_senddigit(struct ast_channel *ast, char digit);
 628 static int sip_sendtext(struct ast_channel *ast, char *text);
 629
 630 static const struct ast_channel_tech sip_tech = {
 631         .type = channeltype,
 632         .description = "Session Initiation Protocol (SIP)",
 633         .capabilities = ((AST_FORMAT_MAX_AUDIO << 1) - 1),
 634         .properties = AST_CHAN_TP_WANTSJITTER,
 635         .requester = sip_request,
 636         .devicestate = sip_devicestate,
 637         .call = sip_call,
 638         .hangup = sip_hangup,
 639         .answer = sip_answer,
 640         .read = sip_read,
 641         .write = sip_write,
 642         .write_video = sip_write,
 643         .indicate = sip_indicate,
 644         .transfer = sip_transfer,
 645         .fixup = sip_fixup,
 646         .send_digit = sip_senddigit,
 647         .bridge = ast_rtp_bridge,
 648         .send_text = sip_sendtext,
 649 };
 650
 651 /*--- sip_debug_test_addr: See if we pass debug IP filter */
 652 static inline int sip_debug_test_addr(struct sockaddr_in *addr)
 653 {
 654         if (sipdebug == 0)
 655                 return 0;
 656         if (debugaddr.sin_addr.s_addr) {
 657                 if (((ntohs(debugaddr.sin_port) != 0)
 658                         && (debugaddr.sin_port != addr->sin_port))
 659                         || (debugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
 660                         return 0;
 661         }
 662         return 1;
 663 }
 664
 665 static inline int sip_debug_test_pvt(struct sip_pvt *p)
 666 {
 667         if (sipdebug == 0)
 668                 return 0;
 669         return sip_debug_test_addr(((ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE) ? &p->recv : &p->sa));
 670 }
 671
 672
 673 /*--- __sip_xmit: Transmit SIP message ---*/
 674 static int __sip_xmit(struct sip_pvt *p, char *data, int len)
 675 {
 676         int res;
 677         char iabuf[INET_ADDRSTRLEN];
 678         if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
 679             res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->recv, sizeof(struct sockaddr_in));
 680         else
 681             res=sendto(sipsock, data, len, 0, (struct sockaddr *)&p->sa, sizeof(struct sockaddr_in));
 682         if (res != len) {
 683                 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));
 684         }
 685         return res;
 686 }
 687
 688 static void sip_destroy(struct sip_pvt *p);
 689
 690 /*--- build_via: Build a Via header for a request ---*/
 691 static void build_via(struct sip_pvt *p, char *buf, int len)
 692 {
 693         char iabuf[INET_ADDRSTRLEN];
 694
 695         /* z9hG4bK is a magic cookie.  See RFC 3261 section 8.1.1.7 */
 696         if (ast_test_flag(p, SIP_NAT) != SIP_NAT_NEVER)
 697                 snprintf(buf, len, "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x;rport", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ourport, p->branch);
 698         else /* Work around buggy UNIDEN UIP200 firmware */
 699                 snprintf(buf, len, "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x", ast_inet_ntoa(iabuf, sizeof(iabuf), p->ourip), ourport, p->branch);
 700 }
 701
 702 /*--- ast_sip_ouraddrfor: NAT fix - decide which IP address to use for ASterisk server? ---*/
 703 /* Only used for outbound registrations */
 704 static int ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us)
 705 {
 706         /*
 707          * Using the localaddr structure built up with localnet statements
 708          * apply it to their address to see if we need to substitute our
 709          * externip or can get away with our internal bindaddr
 710          */
 711         struct sockaddr_in theirs;
 712         theirs.sin_addr = *them;
 713         if (localaddr && externip.sin_addr.s_addr &&
 714            ast_apply_ha(localaddr, &theirs)) {
 715                 char iabuf[INET_ADDRSTRLEN];
 716                 if (externexpire && (time(NULL) >= externexpire)) {
 717                         struct ast_hostent ahp;
 718                         struct hostent *hp;
 719                         time(&externexpire);
 720                         externexpire += externrefresh;
 721                         if ((hp = ast_gethostbyname(externhost, &ahp))) {
 722                                 memcpy(&externip.sin_addr, hp->h_addr, sizeof(externip.sin_addr));
 723                         } else
 724                                 ast_log(LOG_NOTICE, "Warning: Re-lookup of '%s' failed!\n", externhost);
 725                 }
 726                 memcpy(us, &externip.sin_addr, sizeof(struct in_addr));
 727                 ast_inet_ntoa(iabuf, sizeof(iabuf), *(struct in_addr *)&them->s_addr);
 728                 ast_log(LOG_DEBUG, "Target address %s is not local, substituting externip\n", iabuf);
 729         }
 730         else if (bindaddr.sin_addr.s_addr)
 731                 memcpy(us, &bindaddr.sin_addr, sizeof(struct in_addr));
 732         else
 733                 return ast_ouraddrfor(them, us);
 734         return 0;
 735 }
 736
 737 /*--- append_history: Append to SIP dialog history */
 738 static int append_history(struct sip_pvt *p, char *event, char *data)
 739 {
 740         struct sip_history *hist, *prev;
 741         char *c;
 742         if (!recordhistory)
 743                 return 0;
 744         hist = malloc(sizeof(struct sip_history));
 745         if (hist) {
 746                 memset(hist, 0, sizeof(struct sip_history));
 747                 snprintf(hist->event, sizeof(hist->event), "%-15s %s", event, data);
 748                 /* Trim up nicely */
 749                 c = hist->event;
 750                 while(*c) {
 751                         if ((*c == '\r') || (*c == '\n')) {
 752                                 *c = '\0';
 753                                 break;
 754                         }
 755                         c++;
 756                 }
 757                 /* Enqueue into history */
 758                 prev = p->history;
 759                 if (prev) {
 760                         while(prev->next)
 761                                 prev = prev->next;
 762                         prev->next = hist;
 763                 } else {
 764                         p->history = hist;
 765                 }
 766         }
 767         return 0;
 768 }
 769
 770 /*--- retrans_pkt: Retransmit SIP message if no answer ---*/
 771 static int retrans_pkt(void *data)
 772 {
 773         struct sip_pkt *pkt=data, *prev, *cur;
 774         int res = 0;
 775         char iabuf[INET_ADDRSTRLEN];
 776         ast_mutex_lock(&pkt->owner->lock);
 777         if (pkt->retrans < MAX_RETRANS) {
 778                 pkt->retrans++;
 779                 if (sip_debug_test_pvt(pkt->owner)) {
 780                         if (ast_test_flag(pkt->owner, SIP_NAT) & SIP_NAT_ROUTE)
 781                                 ast_verbose("Retransmitting #%d (NAT) to %s:%d:\n%s\n---\n", pkt->retrans, ast_inet_ntoa(iabuf, sizeof(iabuf), pkt->owner->recv.sin_addr), ntohs(pkt->owner->recv.sin_port), pkt->data);
 782                         else
 783                                 ast_verbose("Retransmitting #%d (no NAT) to %s:%d:\n%s\n---\n", pkt->retrans, ast_inet_ntoa(iabuf, sizeof(iabuf), pkt->owner->sa.sin_addr), ntohs(pkt->owner->sa.sin_port), pkt->data);
 784                 }
 785                 append_history(pkt->owner, "ReTx", pkt->data);
 786                 __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
 787                 res = 1;
 788         } else {
 789                 ast_log(LOG_WARNING, "Maximum retries exceeded on call %s for seqno %d (%s %s)\n", pkt->owner->callid, pkt->seqno, (ast_test_flag(pkt, FLAG_FATAL)) ? "Critical" : "Non-critical", (ast_test_flag(pkt, FLAG_RESPONSE)) ? "Response" : "Request");
 790                 append_history(pkt->owner, "MaxRetries", (ast_test_flag(pkt, FLAG_FATAL)) ? "(Critical)" : "(Non-critical)");
 791                 pkt->retransid = -1;
 792                 if (ast_test_flag(pkt, FLAG_FATAL)) {
 793                         while(pkt->owner->owner && ast_mutex_trylock(&pkt->owner->owner->lock)) {
 794                                 ast_mutex_unlock(&pkt->owner->lock);
 795                                 usleep(1);
 796                                 ast_mutex_lock(&pkt->owner->lock);
 797                         }
 798                         if (pkt->owner->owner) {
 799                                 ast_set_flag(pkt->owner, SIP_ALREADYGONE);
 800                                 ast_queue_hangup(pkt->owner->owner);
 801                                 ast_mutex_unlock(&pkt->owner->owner->lock);
 802                         } else {
 803                                 /* If no owner, destroy now */
 804                                 ast_set_flag(pkt->owner, SIP_NEEDDESTROY);
 805                         }
 806                 }
 807                 /* In any case, go ahead and remove the packet */
 808                 prev = NULL;
 809                 cur = pkt->owner->packets;
 810                 while(cur) {
 811                         if (cur == pkt)
 812                                 break;
 813                         prev = cur;
 814                         cur = cur->next;
 815                 }
 816                 if (cur) {
 817                         if (prev)
 818                                 prev->next = cur->next;
 819                         else
 820                                 pkt->owner->packets = cur->next;
 821                         ast_mutex_unlock(&pkt->owner->lock);
 822                         free(cur);
 823                         pkt = NULL;
 824                 } else
 825                         ast_log(LOG_WARNING, "Weird, couldn't find packet owner!\n");
 826         }
 827         if (pkt)
 828                 ast_mutex_unlock(&pkt->owner->lock);
 829         return res;
 830 }
 831
 832 /*--- __sip_reliable_xmit: transmit packet with retransmits ---*/
 833 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal)
 834 {
 835         struct sip_pkt *pkt;
 836         pkt = malloc(sizeof(struct sip_pkt) + len + 1);
 837         if (!pkt)
 838                 return -1;
 839         memset(pkt, 0, sizeof(struct sip_pkt));
 840         memcpy(pkt->data, data, len);
 841         pkt->packetlen = len;
 842         pkt->next = p->packets;
 843         pkt->owner = p;
 844         pkt->seqno = seqno;
 845         pkt->flags = resp;
 846         pkt->data[len] = '\0';
 847         if (fatal)
 848                 ast_set_flag(pkt, FLAG_FATAL);
 849         /* Schedule retransmission */
 850         pkt->retransid = ast_sched_add(sched, DEFAULT_RETRANS, retrans_pkt, pkt);
 851         pkt->next = p->packets;
 852         p->packets = pkt;
 853         __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
 854         if (!strncasecmp(pkt->data, "INVITE", 6)) {
 855                 /* Note this is a pending invite */
 856                 p->pendinginvite = seqno;
 857         }
 858         return 0;
 859 }
 860
 861 /*--- __sip_autodestruct: Kill a call (called by scheduler) ---*/
 862 static int __sip_autodestruct(void *data)
 863 {
 864         struct sip_pvt *p = data;
 865         p->autokillid = -1;
 866         ast_log(LOG_DEBUG, "Auto destroying call '%s'\n", p->callid);
 867         append_history(p, "AutoDestroy", "");
 868         if (p->owner) {
 869                 ast_log(LOG_WARNING, "Autodestruct on call '%s' with owner in place\n", p->callid);
 870                 ast_queue_hangup(p->owner);
 871         } else {
 872                 sip_destroy(p);
 873         }
 874         return 0;
 875 }
 876
 877 /*--- sip_scheddestroy: Schedule destruction of SIP call ---*/
 878 static int sip_scheddestroy(struct sip_pvt *p, int ms)
 879 {
 880         char tmp[80];
 881         if (sip_debug_test_pvt(p))
 882                 ast_verbose("Scheduling destruction of call '%s' in %d ms\n", p->callid, ms);
 883         if (recordhistory) {
 884                 snprintf(tmp, sizeof(tmp), "%d ms", ms);
 885                 append_history(p, "SchedDestroy", tmp);
 886         }
 887         if (p->autokillid > -1)
 888                 ast_sched_del(sched, p->autokillid);
 889         p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, p);
 890         return 0;
 891 }
 892
 893 /*--- sip_cancel_destroy: Cancel destruction of SIP call ---*/
 894 static int sip_cancel_destroy(struct sip_pvt *p)
 895 {
 896         if (p->autokillid > -1)
 897                 ast_sched_del(sched, p->autokillid);
 898         append_history(p, "CancelDestroy", "");
 899         p->autokillid = -1;
 900         return 0;
 901 }
 902
 903 /*--- __sip_ack: Acknowledges receipt of a packet and stops retransmission ---*/
 904 static int __sip_ack(struct sip_pvt *p, int seqno, int resp, const char *msg)
 905 {
 906         struct sip_pkt *cur, *prev = NULL;
 907         int res = -1;
 908         int resetinvite = 0;
 909         /* Just in case... */
 910         if (!msg) msg = "___NEVER___";
 911         cur = p->packets;
 912         while(cur) {
 913                 if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
 914                         ((ast_test_flag(cur, FLAG_RESPONSE)) ||
 915                          (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
 916                         if (!resp && (seqno == p->pendinginvite)) {
 917                                 ast_log(LOG_DEBUG, "Acked pending invite %d\n", p->pendinginvite);
 918                                 p->pendinginvite = 0;
 919                                 resetinvite = 1;
 920                         }
 921                         /* this is our baby */
 922                         if (prev)
 923                                 prev->next = cur->next;
 924                         else
 925                                 p->packets = cur->next;
 926                         if (cur->retransid > -1)
 927                                 ast_sched_del(sched, cur->retransid);
 928                         free(cur);
 929                         res = 0;
 930                         break;
 931                 }
 932                 prev = cur;
 933                 cur = cur->next;
 934         }
 935         ast_log(LOG_DEBUG, "Stopping retransmission on '%s' of %s %d: %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
 936         return res;
 937 }
 938
 939 /* Pretend to ack all packets */
 940 static int __sip_pretend_ack(struct sip_pvt *p)
 941 {
 942         while(p->packets) {
 943                 __sip_ack(p, p->packets->seqno, (ast_test_flag(p->packets, FLAG_RESPONSE)), p->packets->data);
 944         }
 945         return 0;
 946 }
 947
 948 /*--- __sip_semi_ack: Acks receipt of packet, keep it around (used for provisional responses) ---*/
 949 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp, const char *msg)
 950 {
 951         struct sip_pkt *cur;
 952         int res = -1;
 953         cur = p->packets;
 954         while(cur) {
 955                 if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
 956                         ((ast_test_flag(cur, FLAG_RESPONSE)) ||
 957                          (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
 958                         /* this is our baby */
 959                         if (cur->retransid > -1)
 960                                 ast_sched_del(sched, cur->retransid);
 961                         cur->retransid = -1;
 962                         res = 0;
 963                         break;
 964                 }
 965                 cur = cur->next;
 966         }
 967         ast_log(LOG_DEBUG, "(Provisional) Stopping retransmission (but retaining packet) on '%s' %s %d: %s\n", p->callid, resp ? "Response" : "Request", seqno, res ? "Not Found" : "Found");
 968         return res;
 969 }
 970
 971 static void parse(struct sip_request *req);
 972 static char *get_header(struct sip_request *req, char *name);
 973 static void copy_request(struct sip_request *dst,struct sip_request *src);
 974
 975 static void parse_copy(struct sip_request *dst, struct sip_request *src)
 976 {
 977         memset(dst, 0, sizeof(*dst));
 978         memcpy(dst->data, src->data, sizeof(dst->data));
 979         dst->len = src->len;
 980         parse(dst);
 981 }
 982 /*--- send_response: Transmit response on SIP request---*/
 983 static int send_response(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
 984 {
 985         int res;
 986         char iabuf[INET_ADDRSTRLEN];
 987         struct sip_request tmp;
 988         char tmpmsg[80];
 989         if (sip_debug_test_pvt(p)) {
 990                 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
 991                         ast_verbose("%sTransmitting (NAT) to %s:%d:\n%s\n---\n", reliable ? "Reliably " : "", ast_inet_ntoa(iabuf, sizeof(iabuf), p->recv.sin_addr), ntohs(p->recv.sin_port), req->data);
 992                 else
 993                         ast_verbose("%sTransmitting (no NAT) to %s:%d:\n%s\n---\n", reliable ? "Reliably " : "", ast_inet_ntoa(iabuf, sizeof(iabuf), p->sa.sin_addr), ntohs(p->sa.sin_port), req->data);
 994         }
 995         if (reliable) {
 996                 if (recordhistory) {
 997                         parse_copy(&tmp, req);
 998                         snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
 999                         append_history(p, "TxRespRel", tmpmsg);
1000                 }
1001                 res = __sip_reliable_xmit(p, seqno, 1, req->data, req->len, (reliable > 1));
1002         } else {
1003                 if (recordhistory) {
1004                         parse_copy(&tmp, req);
1005                         snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
1006                         append_history(p, "TxResp", tmpmsg);
1007                 }
1008                 res = __sip_xmit(p, req->data, req->len);
1009         }
1010         if (res > 0)
1011                 res = 0;
1012         return res;
1013 }
1014
1015 /*--- send_request: Send SIP Request to the other part of the dialogue ---*/
1016 static int send_request(struct sip_pvt *p, struct sip_request *req, int reliable, int seqno)
1017 {
1018         int res;
1019         char iabuf[INET_ADDRSTRLEN];
1020         struct sip_request tmp;
1021         char tmpmsg[80];
1022         if (sip_debug_test_pvt(p)) {
1023                 if (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE)
1024                         ast_verbose("%sTransmitting (NAT) to %s:%d:\n%s\n---\n", reliable ? "Reliably " : "", ast_inet_ntoa(iabuf, sizeof(iabuf), p->recv.sin_addr), ntohs(p->recv.sin_port), req->data);
1025                 else
1026                         ast_verbose("%sTransmitting (no NAT) to %s:%d:\n%s\n---\n", reliable ? "Reliably " : "", ast_inet_ntoa(iabuf, sizeof(iabuf), p->sa.sin_addr), ntohs(p->sa.sin_port), req->data);
1027         }
1028         if (reliable) {
1029                 if (recordhistory) {
1030                         parse_copy(&tmp, req);
1031                         snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
1032                         append_history(p, "TxReqRel", tmpmsg);
1033                 }
1034                 res = __sip_reliable_xmit(p, seqno, 0, req->data, req->len, (reliable > 1));
1035         } else {
1036                 if (recordhistory) {
1037                         parse_copy(&tmp, req);
1038                         snprintf(tmpmsg, sizeof(tmpmsg), "%s / %s", tmp.data, get_header(&tmp, "CSeq"));
1039                         append_history(p, "TxReq", tmpmsg);
1040                 }
1041                 res = __sip_xmit(p, req->data, req->len);
1042         }
1043         return res;
1044 }
1045
1046 /*--- url_decode: Decode SIP URL  ---*/
1047 static void url_decode(char *s)
1048 {
1049         char *o = s;
1050         unsigned int tmp;
1051         while(*s) {
1052                 switch(*s) {
1053                 case '%':
1054                         if (strlen(s) > 2) {
1055                                 if (sscanf(s + 1, "%2x", &tmp) == 1) {
1056                                         *o = tmp;
1057                                         s += 2; /* Will be incremented once more when we break out */
1058                                         break;
1059                                 }
1060                         }
1061                         /* Fall through if something wasn't right with the formatting */
1062                 default:
1063                         *o = *s;
1064                 }
1065                 s++;
1066                 o++;
1067         }
1068         *o = '\0';
1069 }
1070
1071 /*--- ditch_braces: Pick out text in braces from character string  ---*/
1072 static char *ditch_braces(char *tmp)
1073 {
1074         char *c = tmp;
1075         char *n;
1076         char *q;
1077         if ((q = strchr(tmp, '"')) ) {
1078                 c = q + 1;
1079                 if ((q = strchr(c, '"')) )
1080                         c = q + 1;
1081                 else {
1082                         ast_log(LOG_WARNING, "No closing quote in '%s'\n", tmp);
1083                         c = tmp;
1084                 }
1085         }
1086         if ((n = strchr(c, '<')) ) {
1087                 c = n + 1;
1088                 while(*c && *c != '>') c++;
1089                 if (*c != '>') {
1090                         ast_log(LOG_WARNING, "No closing brace in '%s'\n", tmp);
1091                 } else {
1092                         *c = '\0';
1093                 }
1094                 return n+1;
1095         }
1096         return c;
1097 }
1098
1099 /*--- sip_sendtext: Send SIP MESSAGE text within a call ---*/
1100 /*      Called from PBX core text message functions */
1101 static int sip_sendtext(struct ast_channel *ast, char *text)
1102 {
1103         struct sip_pvt *p = ast->tech_pvt;
1104         int debug=sip_debug_test_pvt(p);
1105
1106         if (debug)
1107                 ast_verbose("Sending text %s on %s\n", text, ast->name);
1108         if (!p)
1109                 return -1;
1110         if (!text || ast_strlen_zero(text))
1111                 return 0;
1112         if (debug)
1113                 ast_verbose("Really sending text %s on %s\n", text, ast->name);
1114         transmit_message_with_text(p, text);
1115         return 0;
1116 }
1117
1118 /*--- realtime_update_peer: Update peer object in realtime storage ---*/
1119 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, const char *username, int expirey)
1120 {
1121         char port[10] = "";
1122         char ipaddr[20] = "";
1123         char regseconds[20] = "0";
1124
1125         if (expirey) {  /* Registration */
1126                 time_t nowtime;
1127                 time(&nowtime);
1128                 nowtime += expirey;
1129                 snprintf(regseconds, sizeof(regseconds), "%ld", nowtime);       /* Expiration time */
1130                 ast_inet_ntoa(ipaddr, sizeof(ipaddr), sin->sin_addr);
1131                 snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
1132         }
1133         ast_update_realtime("sippeers", "name", peername, "ipaddr", ipaddr, "port", port, "regseconds", regseconds, "username", username, NULL);
1134 }
1135
1136 /*--- register_peer_exten: Automatically add peer extension to dial plan ---*/
1137 static void register_peer_exten(struct sip_peer *peer, int onoff)
1138 {
1139         unsigned char multi[256]="";
1140         char *stringp, *ext;
1141         if (!ast_strlen_zero(regcontext)) {
1142                 strncpy(multi, ast_strlen_zero(peer->regexten) ? peer->name : peer->regexten, sizeof(multi) - 1);
1143                 stringp = multi;
1144                 while((ext = strsep(&stringp, "&"))) {
1145                         if (onoff)
1146                                 ast_add_extension(regcontext, 1, ext, 1, NULL, NULL, "Noop", strdup(peer->name), free, channeltype);
1147                         else
1148                                 ast_context_remove_extension(regcontext, ext, 1, NULL);
1149                 }
1150         }
1151 }
1152
1153 /*--- sip_destroy_peer: Destroy peer object from memory */
1154 static void sip_destroy_peer(struct sip_peer *peer)
1155 {
1156         /* Delete it, it needs to disappear */
1157         if (peer->call)
1158                 sip_destroy(peer->call);
1159         if(peer->chanvars) {
1160                 ast_variables_destroy(peer->chanvars);
1161                 peer->chanvars = NULL;
1162         }
1163         if (peer->expire > -1)
1164                 ast_sched_del(sched, peer->expire);
1165         if (peer->pokeexpire > -1)
1166                 ast_sched_del(sched, peer->pokeexpire);
1167         register_peer_exten(peer, 0);
1168         ast_free_ha(peer->ha);
1169         if (ast_test_flag(peer, SIP_SELFDESTRUCT))
1170                 apeerobjs--;
1171         else if (ast_test_flag(peer, SIP_REALTIME))
1172                 rpeerobjs--;
1173         else
1174                 speerobjs--;
1175         free(peer);
1176 }
1177
1178 /*--- update_peer: Update peer data in database (if used) ---*/
1179 static void update_peer(struct sip_peer *p, int expiry)
1180 {
1181         if (!ast_test_flag((&global_flags_page2), SIP_PAGE2_RTNOUPDATE) &&
1182                 (ast_test_flag(p, SIP_REALTIME) ||
1183                  ast_test_flag(&(p->flags_page2), SIP_PAGE2_RTCACHEFRIENDS))) {
1184                 if (p->expire == -1)
1185                         expiry = 0;     /* Unregister realtime peer */
1186                 realtime_update_peer(p->name, &p->addr, p->username, expiry);
1187         }
1188 }
1189
1190
1191 /*--- realtime_peer: Get peer from realtime storage ---*/
1192 /* Checks the "sippeers" realtime family from extconfig.conf */
1193 static struct sip_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
1194 {
1195         struct sip_peer *peer=NULL;
1196         struct ast_variable *var;
1197         struct ast_variable *tmp;
1198
1199         /* First check on peer name */
1200         if (peername)
1201                 var = ast_load_realtime("sippeers", "name", peername, NULL);
1202         else if (sin) { /* Then check on IP address */
1203                 char iabuf[80];
1204
1205                 ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr);
1206                 var = ast_load_realtime("sippeers", "ipaddr", iabuf, NULL);
1207         } else
1208                 return NULL;
1209
1210         if (!var)
1211                 return NULL;
1212
1213         tmp = var;
1214         /* If this is type=user, then skip this object. */
1215         while(tmp) {
1216                 if (!strcasecmp(tmp->name, "type") &&
1217                     !strcasecmp(tmp->value, "user")) {
1218                         ast_variables_destroy(var);
1219                         return NULL;
1220                 }
1221                 tmp = tmp->next;
1222         }
1223
1224         peer = build_peer(peername, var, ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS) ? 0 : 1);
1225
1226         if (peer) {
1227                 if(ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS)) {
1228                         ast_copy_flags((&peer->flags_page2),(&global_flags_page2), SIP_PAGE2_RTAUTOCLEAR|SIP_PAGE2_RTCACHEFRIENDS);
1229                         if(ast_test_flag((&global_flags_page2), SIP_PAGE2_RTAUTOCLEAR)) {
1230                                 peer->expire = ast_sched_add(sched, (global_rtautoclear) * 1000, expire_register, (void *)peer);
1231                         }
1232                         ASTOBJ_CONTAINER_LINK(&peerl,peer);
1233                 } else {
1234                         ast_set_flag(peer, SIP_REALTIME);
1235                 }
1236         }
1237         ast_variables_destroy(var);
1238         return peer;
1239 }
1240
1241 /*--- sip_addrcmp: Support routine for find_peer ---*/
1242 static int sip_addrcmp(char *name, struct sockaddr_in *sin)
1243 {
1244         /* We know name is the first field, so we can cast */
1245         struct sip_peer *p = (struct sip_peer *)name;
1246         return  !(!inaddrcmp(&p->addr, sin) ||
1247                                         (ast_test_flag(p, SIP_INSECURE) &&
1248                                         (p->addr.sin_addr.s_addr == sin->sin_addr.s_addr)));
1249 }
1250
1251 /*--- find_peer: Locate peer by name or ip address */
1252 static struct sip_peer *find_peer(const char *peer, struct sockaddr_in *sin, int realtime)
1253 {
1254         struct sip_peer *p = NULL;
1255
1256         if (peer)
1257                 p = ASTOBJ_CONTAINER_FIND(&peerl,peer);
1258         else
1259                 p = ASTOBJ_CONTAINER_FIND_FULL(&peerl,sin,name,sip_addr_hashfunc,1,sip_addrcmp);
1260
1261         if (!p && realtime) {
1262                 p = realtime_peer(peer, sin);
1263         }
1264
1265         return(p);
1266 }
1267
1268 /*--- sip_destroy_user: Remove user object from in-memory storage ---*/
1269 static void sip_destroy_user(struct sip_user *user)
1270 {
1271         ast_free_ha(user->ha);
1272         if(user->chanvars) {
1273                 ast_variables_destroy(user->chanvars);
1274                 user->chanvars = NULL;
1275         }
1276         if (ast_test_flag(user, SIP_REALTIME))
1277                 ruserobjs--;
1278         else
1279                 suserobjs--;
1280         free(user);
1281 }
1282
1283 /*--- realtime_user: Load user from realtime storage ---*/
1284 /* Loads user from "sipusers" category in realtime (extconfig.conf) */
1285 /* Users are matched on From: user name (the domain in skipped) */
1286 static struct sip_user *realtime_user(const char *username)
1287 {
1288         struct ast_variable *var;
1289         struct ast_variable *tmp;
1290         struct sip_user *user = NULL;
1291
1292         var = ast_load_realtime("sipusers", "name", username, NULL);
1293
1294         if (!var)
1295                 return NULL;
1296
1297         tmp = var;
1298         while (tmp) {
1299                 if (!strcasecmp(tmp->name, "type") &&
1300                         !strcasecmp(tmp->value, "peer")) {
1301                         ast_variables_destroy(var);
1302                         return NULL;
1303                 }
1304                 tmp = tmp->next;
1305         }
1306
1307
1308
1309         user = build_user(username, var, !ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS));
1310
1311         if (user) {
1312                 /* Add some finishing touches, addresses, etc */
1313                 if(ast_test_flag((&global_flags_page2), SIP_PAGE2_RTCACHEFRIENDS)) {
1314                         suserobjs++;
1315
1316                         ASTOBJ_CONTAINER_LINK(&userl,user);
1317                 } else {
1318                         /* Move counter from s to r... */
1319                         suserobjs--;
1320                         ruserobjs++;
1321                         ast_set_flag(user, SIP_REALTIME);
1322         }
1323         }
1324         ast_variables_destroy(var);
1325         return user;
1326 }
1327
1328 /*--- find_user: Locate user by name ---*/
1329 /* Locates user by name (From: sip uri user name part) first
1330    from in-memory list (static configuration) then from
1331    realtime storage (defined in extconfig.conf) */
1332 static struct sip_user *find_user(const char *name, int realtime)
1333 {
1334         struct sip_user *u = NULL;
1335         u = ASTOBJ_CONTAINER_FIND(&userl,name);
1336         if (!u && realtime) {
1337                 u = realtime_user(name);
1338         }
1339         return(u);
1340 }
1341
1342 /*--- create_addr: create address structure from peer definition ---*/
1343 /*      Or, if peer not found, find it in the global DNS */
1344 /*      returns TRUE on failure, FALSE on success */
1345 static int create_addr(struct sip_pvt *r, char *opeer)
1346 {
1347         struct hostent *hp;
1348         struct ast_hostent ahp;
1349         struct sip_peer *p;
1350         int found=0;
1351         char *port;
1352         char *callhost;
1353         int portno;
1354         char host[256], *hostn;
1355         char peer[256]="";
1356
1357         strncpy(peer, opeer, sizeof(peer) - 1);
1358         port = strchr(peer, ':');
1359         if (port) {
1360                 *port = '\0';
1361                 port++;
1362         }
1363         r->sa.sin_family = AF_INET;
1364         p = find_peer(peer, NULL, 1);
1365
1366         if (p) {
1367                 found++;
1368                 ast_copy_flags(r, p, SIP_PROMISCREDIR | SIP_USEREQPHONE | SIP_DTMF | SIP_NAT | SIP_REINVITE | SIP_INSECURE);
1369                 r->capability = p->capability;
1370                 if (r->rtp) {
1371                         ast_log(LOG_DEBUG, "Setting NAT on RTP to %d\n", (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1372                         ast_rtp_setnat(r->rtp, (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1373                 }
1374                 if (r->vrtp) {
1375                         ast_log(LOG_DEBUG, "Setting NAT on VRTP to %d\n", (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1376                         ast_rtp_setnat(r->vrtp, (ast_test_flag(r, SIP_NAT) & SIP_NAT_ROUTE));
1377                 }
1378                 strncpy(r->peername, p->username, sizeof(r->peername)-1);
1379                 strncpy(r->authname, p->username, sizeof(r->authname)-1);
1380                 strncpy(r->username, p->username, sizeof(r->username)-1);
1381                 strncpy(r->peersecret, p->secret, sizeof(r->peersecret)-1);
1382                 strncpy(r->peermd5secret, p->md5secret, sizeof(r->peermd5secret)-1);
1383                 strncpy(r->tohost, p->tohost, sizeof(r->tohost)-1);
1384                 strncpy(r->fullcontact, p->fullcontact, sizeof(r->fullcontact)-1);
1385                 if (!r->initreq.headers && !ast_strlen_zero(p->fromdomain)) {
1386                         if ((callhost = strchr(r->callid, '@'))) {
1387                                 strncpy(callhost + 1, p->fromdomain, sizeof(r->callid) - (callhost - r->callid) - 2);
1388                         }
1389                 }
1390                 if (ast_strlen_zero(r->tohost)) {
1391                         if (p->addr.sin_addr.s_addr)
1392                                 ast_inet_ntoa(r->tohost, sizeof(r->tohost), p->addr.sin_addr);
1393                         else
1394                                 ast_inet_ntoa(r->tohost, sizeof(r->tohost), p->defaddr.sin_addr);
1395                 }
1396                 if (!ast_strlen_zero(p->fromdomain))
1397                         strncpy(r->fromdomain, p->fromdomain, sizeof(r->fromdomain)-1);
1398                 if (!ast_strlen_zero(p->fromuser))
1399                         strncpy(r->fromuser, p->fromuser, sizeof(r->fromuser)-1);
1400                 r->maxtime = p->maxms;
1401                 r->callgroup = p->callgroup;
1402                 r->pickupgroup = p->pickupgroup;
1403                 if (ast_test_flag(r, SIP_DTMF) == SIP_DTMF_RFC2833)
1404                         r->noncodeccapability |= AST_RTP_DTMF;
1405                 else
1406                         r->noncodeccapability &= ~AST_RTP_DTMF;
1407                 strncpy(r->context, p->context,sizeof(r->context)-1);
1408                 if ((p->addr.sin_addr.s_addr || p->defaddr.sin_addr.s_addr) &&
1409                     (!p->maxms || ((p->lastms >= 0)  && (p->lastms <= p->maxms)))) {
1410                         if (p->addr.sin_addr.s_addr) {
1411                                 r->sa.sin_addr = p->addr.sin_addr;
1412                                 r->sa.sin_port = p->addr.sin_port;
1413                         } else {
1414                                 r->sa.sin_addr = p->defaddr.sin_addr;
1415                                 r->sa.sin_port = p->defaddr.sin_port;
1416                         }
1417                         memcpy(&r->recv, &r->sa, sizeof(r->recv));
1418                 } else {
1419                         ASTOBJ_UNREF(p,sip_destroy_peer);
1420                 }
1421         }
1422         if (!p && !found) {
1423                 hostn = peer;
1424                 if (port)
1425                         portno = atoi(port);
1426                 else
1427                         portno = DEFAULT_SIP_PORT;
1428                 if (srvlookup) {
1429                         char service[256];
1430                         int tportno;
1431                         int ret;
1432                         snprintf(service, sizeof(service), "_sip._udp.%s", peer);
1433                         ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service);
1434                         if (ret > 0) {
1435                                 hostn = host;
1436                                 portno = tportno;
1437                         }
1438                 }
1439                 hp = ast_gethostbyname(hostn, &ahp);
1440                 if (hp) {
1441                         strncpy(r->tohost, peer, sizeof(r->tohost) - 1);
1442                         memcpy(&r->sa.sin_addr, hp->h_addr, sizeof(r->sa.sin_addr));
1443                         r->sa.sin_port = htons(portno);
1444                         memcpy(&r->recv, &r->sa, sizeof(r->recv));
1445                         return 0;
1446                 } else {
1447                         ast_log(LOG_WARNING, "No such host: %s\n", peer);
1448                         return -1;
1449                 }
1450         } else if (!p)
1451                 return -1;
1452         else {
1453                 ASTOBJ_UNREF(p,sip_destroy_peer);
1454                 return 0;
1455         }
1456 }
1457
1458 /*--- auto_congest: Scheduled congestion on a call ---*/
1459 static int auto_congest(void *nothing)
1460 {
1461         struct sip_pvt *p = nothing;
1462         ast_mutex_lock(&p->lock);
1463         p->initid = -1;
1464         if (p->owner) {
1465                 if (!ast_mutex_trylock(&p->owner->lock)) {
1466                         ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name);
1467                         ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
1468                         ast_mutex_unlock(&p->owner->lock);
1469                 }
1470         }
1471         ast_mutex_unlock(&p->lock);
1472         return 0;
1473 }
1474
1475
1476
1477
1478 /*--- sip_call: Initiate SIP call from PBX ---*/
1479 /*      used from the dial() application      */
1480 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
1481 {
1482         int res;
1483         struct sip_pvt *p;
1484         char *vxml_url = NULL;
1485         char *distinctive_ring = NULL;
1486         char *osptoken = NULL;
1487 #ifdef OSP_SUPPORT
1488         char *osphandle = NULL;
1489 #endif
1490         struct varshead *headp;
1491         struct ast_var_t *current;
1492         int addsipheaders = 0;
1493
1494         p = ast->tech_pvt;
1495         if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
1496                 ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
1497                 return -1;
1498         }
1499         /* Check whether there is vxml_url, distinctive ring variables */
1500
1501         headp=&ast->varshead;
1502         AST_LIST_TRAVERSE(headp,current,entries) {
1503                 /* Check whether there is a VXML_URL variable */
1504                 if (!vxml_url && !strcasecmp(ast_var_name(current),"VXML_URL")) {
1505                         vxml_url = ast_var_value(current);
1506                 } else if (!distinctive_ring && !strcasecmp(ast_var_name(current),"ALERT_INFO")) {
1507                         /* Check whether there is a ALERT_INFO variable */
1508                         distinctive_ring = ast_var_value(current);
1509                 } else if (!addsipheaders && !strncasecmp(ast_var_name(current),"SIPADDHEADER",strlen("SIPADDHEADER"))) {
1510                         /* Check whether there is a variable with a name starting with SIPADDHEADER */
1511                         addsipheaders = 1;
1512                 }
1513
1514
1515 #ifdef OSP_SUPPORT
1516                   else if (!osptoken && !strcasecmp(ast_var_name(current), "OSPTOKEN")) {
1517                         osptoken = ast_var_value(current);
1518                 } else if (!osphandle && !strcasecmp(ast_var_name(current), "OSPHANDLE")) {
1519                         osphandle = ast_var_value(current);
1520                 }
1521 #endif
1522         }
1523
1524         res = 0;
1525         ast_set_flag(p, SIP_OUTGOING);
1526 #ifdef OSP_SUPPORT
1527         if (!osptoken || !osphandle || (sscanf(osphandle, "%i", &p->osphandle) != 1)) {
1528                 /* Force Disable OSP support */
1529                 ast_log(LOG_DEBUG, "Disabling OSP support for this call. osptoken = %s, osphandle = %s\n", osptoken, osphandle);
1530                 osptoken = NULL;
1531                 osphandle = NULL;
1532                 p->osphandle = -1;
1533         }
1534 #endif
1535         ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);
1536         res = update_user_counter(p,INC_OUT_USE);
1537         if ( res != -1 ) {
1538                 p->callingpres = ast->cid.cid_pres;
1539                 p->jointcapability = p->capability;
1540                 transmit_invite(p, "INVITE", 1, NULL, NULL, vxml_url,distinctive_ring, osptoken, addsipheaders, 1);
1541                 if (p->maxtime) {
1542                         /* Initialize auto-congest time */
1543                         p->initid = ast_sched_add(sched, p->maxtime * 4, auto_congest, p);
1544                 }
1545         }
1546         return res;
1547 }
1548
1549 /*--- sip_registry_destroy: Destroy registry object ---*/
1550 /* Objects created with the register= statement in static configuration */
1551 static void sip_registry_destroy(struct sip_registry *reg)
1552 {
1553         /* Really delete */
1554         if (reg->call) {
1555                 /* Clear registry before destroying to ensure
1556                    we don't get reentered trying to grab the registry lock */
1557                 reg->call->registry = NULL;
1558                 sip_destroy(reg->call);
1559         }
1560         if (reg->expire > -1)
1561                 ast_sched_del(sched, reg->expire);
1562         if (reg->timeout > -1)
1563                 ast_sched_del(sched, reg->timeout);
1564         regobjs--;
1565         free(reg);
1566
1567 }
1568
1569 /*---  __sip_destroy: Execute destrucion of call structure, release memory---*/
1570 static void __sip_destroy(struct sip_pvt *p, int lockowner)
1571 {
1572         struct sip_pvt *cur, *prev = NULL;
1573         struct sip_pkt *cp;
1574         struct sip_history *hist;
1575
1576         if (sip_debug_test_pvt(p))
1577                 ast_verbose("Destroying call '%s'\n", p->callid);
1578         if (p->stateid > -1)
1579                 ast_extension_state_del(p->stateid, NULL);
1580         if (p->initid > -1)
1581                 ast_sched_del(sched, p->initid);
1582         if (p->autokillid > -1)
1583                 ast_sched_del(sched, p->autokillid);
1584
1585         if (p->rtp) {
1586                 ast_rtp_destroy(p->rtp);
1587         }
1588         if (p->vrtp) {
1589                 ast_rtp_destroy(p->vrtp);
1590         }
1591         if (p->route) {
1592                 free_old_route(p->route);
1593                 p->route = NULL;
1594         }
1595         if (p->registry) {
1596                 if (p->registry->call == p)
1597                         p->registry->call = NULL;
1598                 ASTOBJ_UNREF(p->registry,sip_registry_destroy);
1599         }
1600         /* Unlink us from the owner if we have one */
1601         if (p->owner) {
1602                 if (lockowner)
1603                         ast_mutex_lock(&p->owner->lock);
1604                 ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
1605                 p->owner->tech_pvt = NULL;
1606                 if (lockowner)
1607                         ast_mutex_unlock(&p->owner->lock);
1608         }
1609         /* Clear history */
1610         while(p->history) {
1611                 hist = p->history;
1612                 p->history = p->history->next;
1613                 free(hist);
1614         }
1615         cur = iflist;
1616         while(cur) {
1617                 if (cur == p) {
1618                         if (prev)
1619                                 prev->next = cur->next;
1620                         else
1621                                 iflist = cur->next;
1622                         break;
1623                 }
1624                 prev = cur;
1625                 cur = cur->next;
1626         }
1627         if (!cur) {
1628                 ast_log(LOG_WARNING, "%p is not in list?!?! \n", cur);
1629         } else {
1630                 if (p->initid > -1)
1631                         ast_sched_del(sched, p->initid);
1632                 while((cp = p->packets)) {
1633                         p->packets = p->packets->next;
1634                         if (cp->retransid > -1)
1635                                 ast_sched_del(sched, cp->retransid);
1636                         free(cp);
1637                 }
1638                 ast_mutex_destroy(&p->lock);
1639                 if(p->chanvars) {
1640                         ast_variables_destroy(p->chanvars);
1641                         p->chanvars = NULL;
1642                 }
1643                 free(p);
1644         }
1645 }
1646
1647 /*--- update_user_counter: Handle incominglimit and outgoinglimit for SIP users ---*/
1648 /* Note: This is going to be replaced by app_groupcount */
1649 /* Thought: For realtime, we should propably update storage with inuse counter... */
1650 static int update_user_counter(struct sip_pvt *fup, int event)
1651 {
1652         char name[256] = "";
1653         struct sip_user *u;
1654         struct sip_peer *p;
1655         int *inuse, *incominglimit;
1656
1657         /* Test if we need to check call limits, in order to avoid
1658            realtime lookups if we do not need it */
1659         if (!ast_test_flag(fup, SIP_CALL_LIMIT))
1660                 return 0;
1661
1662         strncpy(name, fup->username, sizeof(name) - 1);
1663
1664         /* Check the list of users */
1665         u = find_user(name, 1);
1666         if (u) {
1667                 inuse = &u->inUse;
1668                 incominglimit = &u->incominglimit;
1669                 p = NULL;
1670         } else {
1671                 /* Try to find peer */
1672                 p = find_peer(fup->peername, NULL, 1);
1673                 if (p) {
1674                         inuse = &p->inUse;
1675                         incominglimit = &p->incominglimit;
1676                         strncpy(name, fup->peername, sizeof(name) -1);
1677                 } else {
1678                         ast_log(LOG_DEBUG, "%s is not a local user\n", name);
1679                         return 0;
1680                 }
1681         }
1682         switch(event) {
1683                 /* incoming and outgoing affects the inUse counter */
1684                 case DEC_OUT_USE:
1685                 case DEC_IN_USE:
1686                         if ( *inuse > 0 ) {
1687                                 (*inuse)--;
1688                         } else {
1689                                 *inuse = 0;
1690                         }
1691                         break;
1692                 case INC_IN_USE:
1693                 case INC_OUT_USE:
1694                         if (*incominglimit > 0 ) {
1695                                 if (*inuse >= *incominglimit) {
1696                                         ast_log(LOG_ERROR, "Call from %s '%s' rejected due to usage limit of %d\n", u?"user":"peer", name, *incominglimit);
1697                                         /* inc inUse as well */
1698                                         if ( event == INC_OUT_USE ) {
1699                                                 (*inuse)++;
1700                                         }
1701                                         if (u)
1702                                                 ASTOBJ_UNREF(u,sip_destroy_user);
1703                                         else
1704                                                 ASTOBJ_UNREF(p,sip_destroy_peer);
1705                                         return -1;
1706                                 }
1707                         }
1708                         u->inUse++;
1709                         ast_log(LOG_DEBUG, "Call from %s '%s' is %d out of %d\n", u?"user":"peer", name, *inuse, *incominglimit);
1710                         break;
1711 #ifdef DISABLED_CODE
1712                 /* we don't use these anymore */
1713                 case DEC_OUT_USE:
1714                         if ( u->outUse > 0 ) {
1715                                 u->outUse--;
1716                         } else {
1717                                 u->outUse = 0;
1718                         }
1719                         break;
1720                 case INC_OUT_USE:
1721                         if ( u->outgoinglimit > 0 ) {
1722                                 if ( u->outUse >= u->outgoinglimit ) {
1723                                         ast_log(LOG_ERROR, "Outgoing call from user '%s' rejected due to usage limit of %d\n", u->name, u->outgoinglimit);
1724                                         ast_mutex_unlock(&userl.lock);
1725                                         if (u->temponly) {
1726                                                 destroy_user(u);
1727                                         }
1728                                         return -1;
1729                                 }
1730                         }
1731                         u->outUse++;
1732                         break;
1733 #endif
1734                 default:
1735                         ast_log(LOG_ERROR, "update_user_counter(%s,%d) called with no event!\n",name,event);
1736         }
1737         if (u)
1738                 ASTOBJ_UNREF(u,sip_destroy_user);
1739         else
1740                 ASTOBJ_UNREF(p,sip_destroy_peer);
1741         return 0;
1742 }
1743
1744 /*--- sip_destroy: Destroy SIP call structure ---*/
1745 static void sip_destroy(struct sip_pvt *p)
1746 {
1747         ast_mutex_lock(&iflock);
1748         __sip_destroy(p, 1);
1749         ast_mutex_unlock(&iflock);
1750 }
1751
1752
1753 static int transmit_response_reliable(struct sip_pvt *p, char *msg, struct sip_request *req, int fatal);
1754
1755 /*--- hangup_sip2cause: Convert SIP hangup causes to Asterisk hangup causes ---*/
1756 static int hangup_sip2cause(int cause)
1757 {
1758 /* Possible values from causes.h
1759         AST_CAUSE_NOTDEFINED    AST_CAUSE_NORMAL        AST_CAUSE_BUSY
1760         AST_CAUSE_FAILURE       AST_CAUSE_CONGESTION    AST_CAUSE_UNALLOCATED
1761 */
1762
1763         switch(cause) {
1764                 case 404:       /* Not found */
1765                         return AST_CAUSE_UNALLOCATED;
1766                 case 483:       /* Too many hops */
1767                         return AST_CAUSE_FAILURE;
1768                 case 486:
1769                         return AST_CAUSE_BUSY;
1770                 default:
1771                         return AST_CAUSE_NORMAL;
1772         }
1773         /* Never reached */
1774         return 0;
1775 }
1776
1777 /*--- hangup_cause2sip: Convert Asterisk hangup causes to SIP codes ---*/
1778 static char *hangup_cause2sip(int cause)
1779 {
1780         switch(cause)
1781         {
1782                 case AST_CAUSE_FAILURE:
1783                         return "500 Server internal failure";
1784                 case AST_CAUSE_CONGESTION:
1785                         return "503 Service Unavailable";
1786                 case AST_CAUSE_BUSY:
1787                         return "486 Busy";
1788                 default:
1789                         return NULL;
1790         }
1791         /* Never reached */
1792         return 0;
1793 }
1794
1795 /*--- sip_hangup: Hangup SIP call ---*/
1796 /* Part of PBX interface */
1797 static int sip_hangup(struct ast_channel *ast)
1798 {
1799         struct sip_pvt *p = ast->tech_pvt;
1800         int needcancel = 0;
1801         struct ast_flags locflags = {0};
1802         if (option_debug)
1803                 ast_log(LOG_DEBUG, "sip_hangup(%s)\n", ast->name);
1804         if (!p) {
1805                 ast_log(LOG_DEBUG, "Asked to hangup channel not connected\n");
1806                 return 0;
1807         }
1808         ast_mutex_lock(&p->lock);
1809 #ifdef OSP_SUPPORT
1810         if ((p->osphandle > -1) && (ast->_state == AST_STATE_UP)) {
1811                 ast_osp_terminate(p->osphandle, AST_CAUSE_NORMAL, p->ospstart, time(NULL) - p->ospstart);
1812         }
1813 #endif
1814         if (ast_test_flag(p, SIP_OUTGOING)) {
1815                 ast_log(LOG_DEBUG, "update_user_counter(%s) - decrement outUse counter\n", p->username);
1816                 update_user_counter(p, DEC_OUT_USE);
1817         } else {
1818                 ast_log(LOG_DEBUG, "update_user_counter(%s) - decrement inUse counter\n", p->username);
1819                 update_user_counter(p, DEC_IN_USE);
1820         }
1821         /* Determine how to disconnect */
1822         if (p->owner != ast) {
1823                 ast_log(LOG_WARNING, "Huh?  We aren't the owner?\n");
1824                 ast_mutex_unlock(&p->lock);
1825                 return 0;
1826         }
1827         if (ast->_state != AST_STATE_UP)
1828                 needcancel = 1;
1829         /* Disconnect */
1830         p = ast->tech_pvt;
1831         if (p->vad) {
1832             ast_dsp_free(p->vad);
1833         }
1834         p->owner = NULL;
1835         ast->tech_pvt = NULL;
1836
1837         ast_mutex_lock(&usecnt_lock);
1838         usecnt--;
1839         ast_mutex_unlock(&usecnt_lock);
1840         ast_update_use_count();
1841
1842         ast_set_flag(&locflags, SIP_NEEDDESTROY);
1843         /* Start the process if it's not already started */
1844         if (!ast_test_flag(p, SIP_ALREADYGONE) && !ast_strlen_zero(p->initreq.data)) {
1845                 if (needcancel) {
1846                         if (ast_test_flag(p, SIP_OUTGOING)) {
1847                                 transmit_request_with_auth(p, "CANCEL", p->ocseq, 1, 0);
1848                                 /* Actually don't destroy us yet, wait for the 487 on our original
1849                                    INVITE, but do set an autodestruct just in case we never get it. */
1850                                 ast_clear_flag(&locflags, SIP_NEEDDESTROY);
1851                                 sip_scheddestroy(p, 15000);
1852                                 if ( p->initid != -1 ) {
1853                                         /* channel still up - reverse dec of inUse counter
1854                                            only if the channel is not auto-congested */
1855                                         if (ast_test_flag(p, SIP_OUTGOING)) {
1856                                                 update_user_counter(p, INC_OUT_USE);
1857                                         }
1858                                         else {
1859                                                 update_user_counter(p, INC_IN_USE);
1860                                         }
1861                                 }
1862                         } else {
1863                                 char *res;
1864                                 if (ast->hangupcause && ((res = hangup_cause2sip(ast->hangupcause)))) {
1865                                         transmit_response_reliable(p, res, &p->initreq, 1);
1866                                 } else
1867                                         transmit_response_reliable(p, "403 Forbidden", &p->initreq, 1);
1868                         }
1869                 } else {
1870                         if (!p->pendinginvite) {
1871                                 /* Send a hangup */
1872                                 transmit_request_with_auth(p, "BYE", 0, 1, 1);
1873                         } else {
1874                                 /* Note we will need a BYE when this all settles out
1875                                    but we can't send one while we have "INVITE" outstanding. */
1876                                 ast_set_flag(p, SIP_PENDINGBYE);
1877                                 ast_clear_flag(p, SIP_NEEDREINVITE);
1878                         }
1879                 }
1880         }
1881         ast_copy_flags(p, (&locflags), SIP_NEEDDESTROY);
1882         ast_mutex_unlock(&p->lock);
1883         return 0;
1884 }
1885
1886 /*--- sip_answer: Answer SIP call , send 200 OK on Invite ---*/
1887 /* Part of PBX interface */
1888 static int sip_answer(struct ast_channel *ast)
1889 {
1890         int res = 0,fmt;
1891         char *codec;
1892         struct sip_pvt *p = ast->tech_pvt;
1893
1894         ast_mutex_lock(&p->lock);
1895         if (ast->_state != AST_STATE_UP) {
1896 #ifdef OSP_SUPPORT
1897                 time(&p->ospstart);
1898 #endif
1899
1900                 codec=pbx_builtin_getvar_helper(p->owner,"SIP_CODEC");
1901                 if (codec) {
1902                         fmt=ast_getformatbyname(codec);
1903                         if (fmt) {
1904                                 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC) variable\n",codec);
1905                                 if (p->jointcapability & fmt) {
1906                                         p->jointcapability &= fmt;
1907                                         p->capability &= fmt;
1908                                 } else
1909                                         ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because it is not shared by both ends.\n");
1910                         } else ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n",codec);
1911                 }
1912
1913                 ast_setstate(ast, AST_STATE_UP);
1914                 if (option_debug)
1915                         ast_log(LOG_DEBUG, "sip_answer(%s)\n", ast->name);
1916                 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, 1);
1917         }
1918         ast_mutex_unlock(&p->lock);
1919         return res;
1920 }
1921
1922 /*--- sip_write: Send response, support audio media ---*/
1923 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
1924 {
1925         struct sip_pvt *p = ast->tech_pvt;
1926         int res = 0;
1927         if (frame->frametype == AST_FRAME_VOICE) {
1928                 if (!(frame->subclass & ast->nativeformats)) {
1929                         ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
1930                                 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
1931                         return 0;
1932                 }
1933                 if (p) {
1934                         ast_mutex_lock(&p->lock);
1935                         if (p->rtp) {
1936                                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
1937                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1938                                         ast_set_flag(p, SIP_PROGRESS_SENT);
1939                                 }
1940                                 time(&p->lastrtptx);
1941                                 res =  ast_rtp_write(p->rtp, frame);
1942                         }
1943                         ast_mutex_unlock(&p->lock);
1944                 }
1945         } else if (frame->frametype == AST_FRAME_VIDEO) {
1946                 if (p) {
1947                         ast_mutex_lock(&p->lock);
1948                         if (p->vrtp) {
1949                                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
1950                                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
1951                                         ast_set_flag(p, SIP_PROGRESS_SENT);
1952                                 }
1953                                 time(&p->lastrtptx);
1954                                 res =  ast_rtp_write(p->vrtp, frame);
1955                         }
1956                         ast_mutex_unlock(&p->lock);
1957                 }
1958         } else if (frame->frametype == AST_FRAME_IMAGE) {
1959                 return 0;
1960         } else {
1961                 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
1962                 return 0;
1963         }
1964
1965         return res;
1966 }
1967
1968 /*--- sip_fixup: Fix up a channel:  If a channel is consumed, this is called.
1969         Basically update any ->owner links ----*/
1970 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
1971 {
1972         struct sip_pvt *p = newchan->tech_pvt;
1973         ast_mutex_lock(&p->lock);
1974         if (p->owner != oldchan) {
1975                 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
1976                 ast_mutex_unlock(&p->lock);
1977                 return -1;
1978         }
1979         p->owner = newchan;
1980         ast_mutex_unlock(&p->lock);
1981         return 0;
1982 }
1983
1984 /*--- sip_senddigit: Send DTMF character on SIP channel */
1985 /*    within one call, we're able to transmit in many methods simultaneously */
1986 static int sip_senddigit(struct ast_channel *ast, char digit)
1987 {
1988         struct sip_pvt *p = ast->tech_pvt;
1989         int res = 0;
1990         ast_mutex_lock(&p->lock);
1991         switch (ast_test_flag(p, SIP_DTMF)) {
1992         case SIP_DTMF_INFO:
1993                 transmit_info_with_digit(p, digit);
1994                 break;
1995         case SIP_DTMF_RFC2833:
1996                 if (p->rtp)
1997                         ast_rtp_senddigit(p->rtp, digit);
1998                 break;
1999         case SIP_DTMF_INBAND:
2000                 res = -1;
2001                 break;
2002         }
2003         ast_mutex_unlock(&p->lock);
2004         return res;
2005 }
2006
2007
2008 /*--- sip_transfer: Transfer SIP call */
2009 static int sip_transfer(struct ast_channel *ast, char *dest)
2010 {
2011         struct sip_pvt *p = ast->tech_pvt;
2012         int res;
2013
2014         ast_mutex_lock(&p->lock);
2015         if (ast->_state == AST_STATE_RING)
2016                 res = sip_sipredirect(p, dest);
2017         else
2018                 res = transmit_refer(p, dest);
2019         res = transmit_refer(p, dest);
2020         ast_mutex_unlock(&p->lock);
2021         return res;
2022 }
2023
2024 /*--- sip_indicate: Play indication to user */
2025 /* With SIP a lot of indications is sent as messages, letting the device play
2026    the indication - busy signal, congestion etc */
2027 static int sip_indicate(struct ast_channel *ast, int condition)
2028 {
2029         struct sip_pvt *p = ast->tech_pvt;
2030         int res = 0;
2031
2032         ast_mutex_lock(&p->lock);
2033         switch(condition) {
2034         case AST_CONTROL_RINGING:
2035                 if (ast->_state == AST_STATE_RING) {
2036                         if (!ast_test_flag(p, SIP_PROGRESS_SENT) ||
2037                             (ast_test_flag(p, SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER)) {
2038                                 /* Send 180 ringing if out-of-band seems reasonable */
2039                                 transmit_response(p, "180 Ringing", &p->initreq);
2040                                 ast_set_flag(p, SIP_RINGING);
2041                                 if (ast_test_flag(p, SIP_PROG_INBAND) != SIP_PROG_INBAND_YES)
2042                                         break;
2043                         } else {
2044                                 /* Well, if it's not reasonable, just send in-band */
2045                         }
2046                 }
2047                 res = -1;
2048                 break;
2049         case AST_CONTROL_BUSY:
2050                 if (ast->_state != AST_STATE_UP) {
2051                         transmit_response(p, "486 Busy Here", &p->initreq);
2052                         ast_set_flag(p, SIP_ALREADYGONE);
2053                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2054                         break;
2055                 }
2056                 res = -1;
2057                 break;
2058         case AST_CONTROL_CONGESTION:
2059                 if (ast->_state != AST_STATE_UP) {
2060                         transmit_response(p, "503 Service Unavailable", &p->initreq);
2061                         ast_set_flag(p, SIP_ALREADYGONE);
2062                         ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
2063                         break;
2064                 }
2065                 res = -1;
2066                 break;
2067         case AST_CONTROL_PROGRESS:
2068         case AST_CONTROL_PROCEEDING:
2069                 if ((ast->_state != AST_STATE_UP) && !ast_test_flag(p, SIP_PROGRESS_SENT) && !ast_test_flag(p, SIP_OUTGOING)) {
2070                         transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, 0);
2071                         ast_set_flag(p, SIP_PROGRESS_SENT);
2072                         break;
2073                 }
2074                 res = -1;
2075                 break;
2076         case -1:
2077                 res = -1;
2078                 break;
2079         default:
2080                 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
2081                 res = -1;
2082                 break;
2083         }
2084         ast_mutex_unlock(&p->lock);
2085         return res;
2086 }
2087
2088
2089
2090 /*--- sip_new: Initiate a call in the SIP channel */
2091 /*      called from sip_request_call (calls from the pbx ) */
2092 static struct ast_channel *sip_new(struct sip_pvt *i, int state, char *title)
2093 {
2094         struct ast_channel *tmp;
2095         struct ast_variable *v = NULL;
2096         int fmt;
2097
2098         ast_mutex_unlock(&i->lock);
2099         /* Don't hold a sip pvt lock while we allocate a channel */
2100         tmp = ast_channel_alloc(1);
2101         ast_mutex_lock(&i->lock);
2102         if (tmp) {
2103                 tmp->tech = &sip_tech;
2104                 /* Select our native format based on codec preference until we receive
2105                    something from another device to the contrary. */
2106                 ast_mutex_lock(&i->lock);
2107                 if (i->jointcapability)
2108                         tmp->nativeformats = ast_codec_choose(&i->prefs, i->jointcapability, 1);
2109                 else if (i->capability)
2110                         tmp->nativeformats = ast_codec_choose(&i->prefs, i->capability, 1);
2111                 else
2112                         tmp->nativeformats = ast_codec_choose(&i->prefs, global_capability, 1);
2113                 ast_mutex_unlock(&i->lock);
2114                 fmt = ast_best_codec(tmp->nativeformats);
2115                 if (title)
2116                         snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%04x", title, rand() & 0xffff);
2117                 else
2118                         if (strchr(i->fromdomain,':'))
2119                         {
2120                                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", strchr(i->fromdomain,':')+1, (int)(long)(i));
2121                         }
2122                         else
2123                         {
2124                                 snprintf(tmp->name, sizeof(tmp->name), "SIP/%s-%08x", i->fromdomain, (int)(long)(i));
2125                         }
2126                 tmp->type = channeltype;
2127                 if (ast_test_flag(i, SIP_DTMF) ==  SIP_DTMF_INBAND) {
2128                     i->vad = ast_dsp_new();
2129                     ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
2130                     if (relaxdtmf)
2131                         ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
2132                 }
2133                 tmp->fds[0] = ast_rtp_fd(i->rtp);
2134                 tmp->fds[1] = ast_rtcp_fd(i->rtp);
2135                 if (i->vrtp) {
2136                         tmp->fds[2] = ast_rtp_fd(i->vrtp);
2137                         tmp->fds[3] = ast_rtcp_fd(i->vrtp);
2138                 }
2139                 if (state == AST_STATE_RING)
2140                         tmp->rings = 1;
2141                 tmp->adsicpe = AST_ADSI_UNAVAILABLE;
2142                 tmp->writeformat = fmt;
2143                 tmp->rawwriteformat = fmt;
2144                 tmp->readformat = fmt;
2145                 tmp->rawreadformat = fmt;
2146                 tmp->tech_pvt = i;
2147
2148                 tmp->callgroup = i->callgroup;
2149                 tmp->pickupgroup = i->pickupgroup;
2150                 tmp->cid.cid_pres = i->callingpres;
2151                 if (!ast_strlen_zero(i->accountcode))
2152                         strncpy(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode)-1);
2153                 if (i->amaflags)
2154                         tmp->amaflags = i->amaflags;
2155                 if (!ast_strlen_zero(i->language))
2156                         strncpy(tmp->language, i->language, sizeof(tmp->language)-1);
2157                 if (!ast_strlen_zero(i->musicclass))
2158                         strncpy(tmp->musicclass, i->musicclass, sizeof(tmp->musicclass)-1);
2159                 i->owner = tmp;
2160                 ast_mutex_lock(&usecnt_lock);
2161                 usecnt++;
2162                 ast_mutex_unlock(&usecnt_lock);
2163                 strncpy(tmp->context, i->context, sizeof(tmp->context)-1);
2164                 strncpy(tmp->exten, i->exten, sizeof(tmp->exten)-1);
2165                 if (!ast_strlen_zero(i->cid_num))
2166                         tmp->cid.cid_num = strdup(i->cid_num);
2167                 if (!ast_strlen_zero(i->cid_name))
2168                         tmp->cid.cid_name = strdup(i->cid_name);
2169                 if (!ast_strlen_zero(i->rdnis))
2170                         tmp->cid.cid_rdnis = strdup(i->rdnis);
2171                 if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
2172                         tmp->cid.cid_dnid = strdup(i->exten);
2173                 tmp->priority = 1;
2174                 if (!ast_strlen_zero(i->uri)) {
2175                         pbx_builtin_setvar_helper(tmp, "SIPURI", i->uri);
2176                 }
2177                 if (!ast_strlen_zero(i->domain)) {
2178                         pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
2179                 }
2180                 if (!ast_strlen_zero(i->useragent)) {
2181                         pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
2182                 }
2183                 if (!ast_strlen_zero(i->callid)) {
2184                         pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
2185                 }
2186                 ast_setstate(tmp, state);
2187                 if (state != AST_STATE_DOWN) {
2188                         if (ast_pbx_start(tmp)) {
2189                                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
2190                                 ast_hangup(tmp);
2191                                 tmp = NULL;
2192                         }
2193                 }
2194                 /* Set channel variables for this call from configuration */
2195                 for (v = i->chanvars ; v ; v = v->next)
2196                         pbx_builtin_setvar_helper(tmp,v->name,v->value);
2197
2198         } else
2199                 ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
2200         return tmp;
2201 }
2202
2203 /* Structure for conversion between compressed SIP and "normal" SIP */
2204 static struct cfalias {
2205         char *fullname;
2206         char *shortname;
2207 } aliases[] = {
2208         { "Content-Type", "c" },
2209         { "Content-Encoding", "e" },
2210         { "From", "f" },
2211         { "Call-ID", "i" },
2212         { "Contact", "m" },
2213         { "Content-Length", "l" },
2214         { "Subject", "s" },
2215         { "To", "t" },
2216         { "Supported", "k" },
2217         { "Refer-To", "r" },
2218         { "Allow-Events", "u" },
2219         { "Event", "o" },
2220         { "Via", "v" },
2221 };
2222
2223 /*--- get_sdp_by_line: Reads one line of SIP message body */
2224 static char* get_sdp_by_line(char* line, char *name, int nameLen) {
2225   if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
2226     char* r = line + nameLen + 1;
2227     while (*r && (*r < 33)) ++r;
2228     return r;
2229   }
2230
2231   return "";
2232 }
2233
2234 /*--- get_sdp: Gets all kind of SIP message bodies, including SDP,
2235    but the name wrongly applies _only_ sdp */
2236 static char *get_sdp(struct sip_request *req, char *name) {
2237   int x;
2238   int len = strlen(name);
2239   char *r;
2240
2241   for (x=0; x<req->lines; x++) {
2242     r = get_sdp_by_line(req->line[x], name, len);
2243     if (r[0] != '\0') return r;
2244   }
2245   return "";
2246 }
2247
2248
2249 static void sdpLineNum_iterator_init(int* iterator) {
2250   *iterator = 0;
2251 }
2252
2253 static char* get_sdp_iterate(int* iterator,
2254                              struct sip_request *req, char *name) {
2255   int len = strlen(name);
2256   char *r;
2257   while (*iterator < req->lines) {
2258     r = get_sdp_by_line(req->line[(*iterator)++], name, len);
2259     if (r[0] != '\0') return r;
2260   }
2261   return "";
2262 }
2263
2264 static char *__get_header(struct sip_request *req, char *name, int *start)
2265 {
2266         int x;
2267         int len = strlen(name);
2268         char *r;
2269         if (pedanticsipchecking) {
2270                 /* Technically you can place arbitrary whitespace both before and after the ':' in
2271                    a header, although RFC3261 clearly says you shouldn't before, and place just
2272                    one afterwards.  If you shouldn't do it, what absolute idiot decided it was
2273                    a good idea to say you can do it, and if you can do it, why in the hell would
2274                    you say you shouldn't.  */
2275                 for (x=*start;x<req->headers;x++) {
2276                         if (!strncasecmp(req->header[x], name, len)) {
2277                                 r = req->header[x] + len;
2278                                 while(*r && (*r < 33))
2279                                         r++;
2280                                 if (*r == ':') {
2281                                         r++ ;
2282                                         while(*r && (*r < 33))
2283                                                 r++;
2284                                         *start = x+1;
2285                                         return r;
2286                                 }
2287                         }
2288                 }
2289         } else {
2290                 /* We probably shouldn't even bother counting whitespace afterwards but
2291                    I guess for backwards compatibility we will */
2292                 for (x=*start;x<req->headers;x++) {
2293                         if (!strncasecmp(req->header[x], name, len) &&
2294                                         (req->header[x][len] == ':')) {
2295                                                 r = req->header[x] + len + 1;
2296                                                 while(*r && (*r < 33))
2297                                                                 r++;
2298                                                 *start = x+1;
2299                                                 return r;
2300                         }
2301                 }
2302         }
2303         /* Try aliases */
2304         for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++)
2305                 if (!strcasecmp(aliases[x].fullname, name))
2306                         return __get_header(req, aliases[x].shortname, start);
2307
2308         /* Don't return NULL, so get_header is always a valid pointer */
2309         return "";
2310 }
2311
2312 /*--- get_header: Get header from SIP request ---*/
2313 static char *get_header(struct sip_request *req, char *name)
2314 {
2315         int start = 0;
2316         return __get_header(req, name, &start);
2317 }
2318
2319 /*--- sip_rtp_read: Read RTP from network ---*/
2320 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p)
2321 {
2322         /* Retrieve audio/etc from channel.  Assumes p->lock is already held. */
2323         struct ast_frame *f;
2324         static struct ast_frame null_frame = { AST_FRAME_NULL, };
2325         switch(ast->fdno) {
2326         case 0:
2327                 f = ast_rtp_read(p->rtp);       /* RTP Audio */
2328                 break;
2329         case 1:
2330                 f = ast_rtcp_read(p->rtp);      /* RTCP Control Channel */
2331                 break;
2332         case 2:
2333                 f = ast_rtp_read(p->vrtp);      /* RTP Video */
2334                 break;
2335         case 3:
2336                 f = ast_rtcp_read(p->vrtp);     /* RTCP Control Channel for video */
2337                 break;
2338         default:
2339                 f = &null_frame;
2340         }
2341         /* Don't send RFC2833 if we're not supposed to */
2342         if (f && (f->frametype == AST_FRAME_DTMF) && (ast_test_flag(p, SIP_DTMF) != SIP_DTMF_RFC2833))
2343                 return &null_frame;
2344         if (p->owner) {
2345                 /* We already hold the channel lock */
2346                 if (f->frametype == AST_FRAME_VOICE) {
2347                         if (f->subclass != p->owner->nativeformats) {
2348                                 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
2349                                 p->owner->nativeformats = f->subclass;
2350                                 ast_set_read_format(p->owner, p->owner->readformat);
2351                                 ast_set_write_format(p->owner, p->owner->writeformat);
2352                         }
2353             if ((ast_test_flag(p, SIP_DTMF) == SIP_DTMF_INBAND) && p->vad) {
2354                    f = ast_dsp_process(p->owner,p->vad,f);
2355                    if (f && (f->frametype == AST_FRAME_DTMF))
2356                         ast_log(LOG_DEBUG, "Detected DTMF '%c'\n", f->subclass);
2357             }
2358                 }
2359         }
2360         return f;
2361 }
2362
2363 /*--- sip_read: Read SIP RTP from channel */
2364 static struct ast_frame *sip_read(struct ast_channel *ast)
2365 {
2366         struct ast_frame *fr;
2367         struct sip_pvt *p = ast->tech_pvt;
2368         ast_mutex_lock(&p->lock);
2369         fr = sip_rtp_read(ast, p);
2370         time(&p->lastrtprx);
2371         ast_mutex_unlock(&p->lock);
2372         return fr;
2373 }
2374
2375 /*--- build_callid: Build SIP CALLID header ---*/
2376 static void build_callid(char *callid, int len, struct in_addr ourip, char *fromdomain)
2377 {
2378         int res;
2379         int val;
2380         int x;
2381         char iabuf[INET_ADDRSTRLEN];
2382         for (x=0;x<4;x++) {
2383                 val = rand();
2384                 res = snprintf(callid, len, "%08x", val);
2385                 len -= res;
2386                 callid += res;
2387         }
2388         if (!ast_strlen_zero(fromdomain))
2389                 snprintf(callid, len, "@%s", fromdomain);
2390         else
2391         /* It's not important that we really use our right IP here... */
2392                 snprintf(callid, len, "@%s", ast_inet_ntoa(iabuf, sizeof(iabuf), ourip));
2393 }
2394
2395 /*--- sip_alloc: Allocate SIP_PVT structure and set defaults ---*/
2396 static struct sip_pvt *sip_alloc(char *callid, struct sockaddr_in *sin, int useglobal_nat)
2397 {
2398         struct sip_pvt *p;
2399
2400         p = malloc(sizeof(struct sip_pvt));
2401         if (!p)
2402                 return NULL;
2403         /* Keep track of stuff */
2404         memset(p, 0, sizeof(struct sip_pvt));
2405         ast_mutex_init(&p->lock);
2406
2407         p->initid = -1;
2408         p->autokillid = -1;
2409         p->stateid = -1;
2410         p->prefs = prefs;
2411 #ifdef OSP_SUPPORT
2412         p->osphandle = -1;
2413 #endif
2414         if (sin) {
2415                 memcpy(&p->sa, sin, sizeof(p->sa));
2416                 if (ast_sip_ouraddrfor(&p->sa.sin_addr,&p->ourip))
2417                         memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2418         } else {
2419                 memcpy(&p->ourip, &__ourip, sizeof(p->ourip));
2420         }
2421         p->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2422         if (videosupport)
2423                 p->vrtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2424         p->branch = rand();
2425         p->tag = rand();
2426
2427         /* Start with 101 instead of 1 */
2428         p->ocseq = 101;
2429         if (!p->rtp) {
2430                 ast_log(LOG_WARNING, "Unable to create RTP session: %s\n", strerror(errno));
2431                 ast_mutex_destroy(&p->lock);
2432                 if(p->chanvars) {
2433                         ast_variables_destroy(p->chanvars);
2434                         p->chanvars = NULL;
2435                 }
2436                 free(p);
2437                 return NULL;
2438         }
2439         ast_rtp_settos(p->rtp, tos);
2440         if (p->vrtp)
2441                 ast_rtp_settos(p->vrtp, tos);
2442         if (useglobal_nat && sin) {
2443                 /* Setup NAT structure according to global settings if we have an address */
2444                 ast_copy_flags(p, &global_flags, SIP_NAT);
2445                 memcpy(&p->recv, sin, sizeof(p->recv));
2446                 ast_rtp_setnat(p->rtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
2447                 if (p->vrtp)
2448                         ast_rtp_setnat(p->vrtp, (ast_test_flag(p, SIP_NAT) & SIP_NAT_ROUTE));
2449         }
2450
2451         strncpy(p->fromdomain, default_fromdomain, sizeof(p->fromdomain) - 1);
2452         build_via(p, p->via, sizeof(p->via));
2453         if (!callid)
2454                 build_callid(p->callid, sizeof(p->callid), p->ourip, p->fromdomain);
2455         else
2456                 strncpy(p->callid, callid, sizeof(p->callid) - 1);
2457         ast_copy_flags(p, (&global_flags), SIP_PROMISCREDIR | SIP_TRUSTRPID | SIP_DTMF | SIP_REINVITE | SIP_PROG_INBAND | SIP_OSPAUTH);
2458         /* Assign default music on hold class */
2459         strncpy(p->musicclass, global_musicclass, sizeof(p->musicclass) - 1);
2460         p->rtptimeout = global_rtptimeout;
2461         p->rtpholdtimeout = global_rtpholdtimeout;
2462         p->rtpkeepalive = global_rtpkeepalive;
2463         p->capability = global_capability;
2464         if (ast_test_flag(p, SIP_DTMF) == SIP_DTMF_RFC2833)
2465                 p->noncodeccapability |= AST_RTP_DTMF;
2466         strncpy(p->context, default_context, sizeof(p->context) - 1);
2467         /* Add to list */
2468         ast_mutex_lock(&iflock);
2469         p->next = iflist;
2470         iflist = p;
2471         ast_mutex_unlock(&iflock);
2472         if (option_debug)
2473                 ast_log(LOG_DEBUG, "Allocating new SIP call for %s\n", callid);
2474         return p;
2475 }
2476
2477 /*--- find_call: Connect incoming SIP message to current call or create new call structure */
2478 /*               Called by handle_request ,sipsock_read */
2479 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin)
2480 {
2481         struct sip_pvt *p;
2482         char *callid;
2483         char tmp[256] = "";
2484         char iabuf[INET_ADDRSTRLEN];
2485         char *cmd;
2486         char *tag = "", *c;
2487
2488         callid = get_header(req, "Call-ID");
2489
2490         if (pedanticsipchecking) {
2491                 /* In principle Call-ID's uniquely identify a call, however some vendors
2492                    (i.e. Pingtel) send multiple calls with the same Call-ID and different
2493                    tags in order to simplify billing.  The RFC does state that we have to
2494                    compare tags in addition to the call-id, but this generate substantially
2495                    more overhead which is totally unnecessary for the vast majority of sane
2496                    SIP implementations, and thus Asterisk does not enable this behavior
2497                    by default. Short version: You'll need this option to support conferencing
2498                    on the pingtel */
2499                 strncpy(tmp, req->header[0], sizeof(tmp) - 1);
2500                 cmd = tmp;
2501                 c = strchr(tmp, ' ');
2502                 if (c)
2503                         *c = '\0';
2504                 if (!strcasecmp(cmd, "SIP/2.0"))
2505                         strncpy(tmp, get_header(req, "To"), sizeof(tmp) - 1);
2506                 else
2507                         strncpy(tmp, get_header(req, "From"), sizeof(tmp) - 1);
2508                 tag = strstr(tmp, "tag=");
2509                 if (tag) {
2510                         tag += 4;
2511                         c = strchr(tag, ';');
2512                         if (c)
2513                                 *c = '\0';
2514                 }
2515
2516         }
2517
2518         if (ast_strlen_zero(callid)) {
2519                 ast_log(LOG_WARNING, "Call missing call ID from '%s'\n", ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr));
2520                 return NULL;
2521         }
2522         ast_mutex_lock(&iflock);
2523         p = iflist;
2524         while(p) {
2525                 if (!strcmp(p->callid, callid) &&
2526                         (!pedanticsipchecking || !tag || ast_strlen_zero(p->theirtag) || !strcmp(p->theirtag, tag))) {
2527                         /* Found the call */
2528                         ast_mutex_lock(&p->lock);
2529                         ast_mutex_unlock(&iflock);
2530                         return p;
2531                 }
2532                 p = p->next;
2533         }
2534         ast_mutex_unlock(&iflock);
2535         p = sip_alloc(callid, sin, 1);
2536         if (p)
2537                 ast_mutex_lock(&p->lock);
2538         return p;
2539 }
2540
2541 /*--- sip_register: Parse register=> line in sip.conf and add to registry */
2542 static int sip_register(char *value, int lineno)
2543 {
2544         struct sip_registry *reg;
2545         char copy[256] = "";
2546         char *username=NULL, *hostname=NULL, *secret=NULL, *authuser=NULL;
2547         char *porta=NULL;
2548         char *contact=NULL;
2549         char *stringp=NULL;
2550
2551         if (!value)
2552                 return -1;
2553         strncpy(copy, value, sizeof(copy)-1);
2554         stringp=copy;
2555         username = stringp;
2556         hostname = strrchr(stringp, '@');
2557         if (hostname) {
2558                 *hostname = '\0';
2559                 hostname++;
2560         }
2561         if (!username || ast_strlen_zero(username) || !hostname || ast_strlen_zero(hostname)) {
2562                 ast_log(LOG_WARNING, "Format for registration is user[:secret[:authuser]]@host[:port][/contact] at line %d", lineno);
2563                 return -1;
2564         }
2565         stringp=username;
2566         username = strsep(&stringp, ":");
2567         if (username) {
2568                 secret = strsep(&stringp, ":");
2569                 if (secret)
2570                         authuser = strsep(&stringp, ":");
2571         }
2572         stringp = hostname;
2573         hostname = strsep(&stringp, "/");
2574         if (hostname)
2575                 contact = strsep(&stringp, "/");
2576         if (!contact || ast_strlen_zero(contact))
2577                 contact = "s";
2578         stringp=hostname;
2579         hostname = strsep(&stringp, ":");
2580         porta = strsep(&stringp, ":");
2581
2582         if (porta && !atoi(porta)) {
2583                 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
2584                 return -1;
2585         }
2586         reg = malloc(sizeof(struct sip_registry));
2587         if (reg) {
2588                 memset(reg, 0, sizeof(struct sip_registry));
2589                 regobjs++;
2590                 ASTOBJ_INIT(reg);
2591                 strncpy(reg->contact, contact, sizeof(reg->contact) - 1);
2592                 if (username)
2593                         strncpy(reg->username, username, sizeof(reg->username)-1);
2594                 if (hostname)
2595                         strncpy(reg->hostname, hostname, sizeof(reg->hostname)-1);
2596                 if (authuser)
2597                         strncpy(reg->authuser, authuser, sizeof(reg->authuser)-1);
2598                 if (secret)
2599                         strncpy(reg->secret, secret, sizeof(reg->secret)-1);
2600                 reg->expire = -1;
2601                 reg->timeout =  -1;
2602                 reg->refresh = default_expiry;
2603                 reg->portno = porta ? atoi(porta) : 0;
2604                 reg->callid_valid = 0;
2605                 reg->ocseq = 101;
2606                 ASTOBJ_CONTAINER_LINK(&regl, reg);
2607                 ASTOBJ_UNREF(reg,sip_registry_destroy);
2608         } else {
2609                 ast_log(LOG_ERROR, "Out of memory\n");
2610                 return -1;
2611         }
2612         return 0;
2613 }
2614
2615 /*--- lws2sws: Parse multiline SIP headers into one header */
2616 /* This is enabled if pedanticsipchecking is enabled */
2617 static int lws2sws(char *msgbuf, int len)
2618 {
2619         int h = 0, t = 0;
2620         int lws = 0;
2621
2622         for (; h < len;) {
2623                 /* Eliminate all CRs */
2624                 if (msgbuf[h] == '\r') {
2625                         h++;
2626                         continue;
2627                 }
2628                 /* Check for end-of-line */
2629                 if (msgbuf[h] == '\n') {
2630                         /* Check for end-of-message */
2631                         if (h + 1 == len)
2632                                 break;
2633                         /* Check for a continuation line */
2634                         if (msgbuf[h + 1] == ' ' || msgbuf[h + 1] == '\t') {
2635                                 /* Merge continuation line */
2636                                 h++;
2637                                 continue;
2638                         }
2639                         /* Propagate LF and start new line */
2640                         msgbuf[t++] = msgbuf[h++];
2641                         lws = 0;
2642                         continue;
2643                 }
2644                 if (msgbuf[h] == ' ' || msgbuf[h] == '\t') {
2645                         if (lws) {
2646                                 h++;
2647                                 continue;
2648                         }
2649                         msgbuf[t++] = msgbuf[h++];
2650                         lws = 1;
2651                         continue;
2652                 }
2653                 msgbuf[t++] = msgbuf[h++];
2654                 if (lws)
2655                         lws = 0;
2656         }
2657         msgbuf[t] = '\0';
2658         return t;
2659 }
2660
2661 /*--- parse: Parse a SIP message ----*/
2662 static void parse(struct sip_request *req)
2663 {
2664         /* Divide fields by NULL's */
2665         char *c;
2666         int f = 0;
2667         c = req->data;
2668
2669         /* First header starts immediately */
2670         req->header[f] = c;
2671         while(*c) {
2672                 if (*c == '\n') {
2673                         /* We've got a new header */
2674                         *c = 0;
2675
2676 #if 0
2677                         printf("Header: %s (%d)\n", req->header[f], strlen(req->header[f]));
2678 #endif
2679                         if (ast_strlen_zero(req->header[f])) {
2680                                 /* Line by itself means we're now in content */
2681                                 c++;
2682                                 break;
2683                         }
2684                         if (f >= SIP_MAX_HEADERS - 1) {
2685                                 ast_log(LOG_WARNING, "Too many SIP headers...\n");
2686                         } else
2687                                 f++;
2688                         req->header[f] = c + 1;
2689                 } else if (*c == '\r') {
2690                         /* Ignore but eliminate \r's */
2691                         *c = 0;
2692                 }
2693                 c++;
2694         }
2695         /* Check for last header */
2696         if (!ast_strlen_zero(req->header[f]))
2697                 f++;
2698         req->headers = f;
2699         /* Now we process any mime content */
2700         f = 0;
2701         req->line[f] = c;
2702         while(*c) {
2703                 if (*c == '\n') {
2704                         /* We've got a new line */
2705                         *c = 0;
2706 #if 0
2707                         printf("Line: %s (%d)\n", req->line[f], strlen(req->line[f]));
2708 #endif
2709                         if (f >= SIP_MAX_LINES - 1) {
2710                                 ast_log(LOG_WARNING, "Too many SDP lines...\n");
2711                         } else
2712                                 f++;
2713                         req->line[f] = c + 1;
2714                 } else if (*c == '\r') {
2715                         /* Ignore and eliminate \r's */
2716                         *c = 0;
2717                 }
2718                 c++;
2719         }
2720         /* Check for last line */
2721         if (!ast_strlen_zero(req->line[f]))
2722                 f++;
2723         req->lines = f;
2724         if (*c)
2725                 ast_log(LOG_WARNING, "Odd content, extra stuff left over ('%s')\n", c);
2726 }
2727
2728 /*--- process_sdp: Process SIP SDP ---*/
2729 static int process_sdp(struct sip_pvt *p, struct sip_request *req)
2730 {
2731         char *m;
2732         char *c;
2733         char *a;
2734         char host[258];
2735         char iabuf[INET_ADDRSTRLEN];
2736         int len = -1;
2737         int portno=0;
2738         int vportno=0;
2739         int peercapability, peernoncodeccapability;
2740         int vpeercapability=0, vpeernoncodeccapability=0;
2741         struct sockaddr_in sin;
2742         char *codecs;
2743         struct hostent *hp;
2744         struct ast_hostent ahp;
2745         int codec;
2746         int destiterator = 0;
2747         int iterator;
2748         int sendonly = 0;
2749         int x,y;
2750         int debug=sip_debug_test_pvt(p);
2751
2752         /* Update our last rtprx when we receive an SDP, too */
2753         time(&p->lastrtprx);
2754         time(&p->lastrtptx);
2755
2756         /* Get codec and RTP info from SDP */
2757         if (strcasecmp(get_header(req, "Content-Type"), "application/sdp")) {
2758                 ast_log(LOG_NOTICE, "Content is '%s', not 'application/sdp'\n", get_header(req, "Content-Type"));
2759                 return -1;
2760         }
2761         m = get_sdp(req, "m");
2762         sdpLineNum_iterator_init(&destiterator);
2763         c = get_sdp_iterate(&destiterator, req, "c");
2764         if (ast_strlen_zero(m) || ast_strlen_zero(c)) {
2765                 ast_log(LOG_WARNING, "Insufficient information for SDP (m = '%s', c = '%s')\n", m, c);
2766                 return -1;
2767         }
2768         if (sscanf(c, "IN IP4 %256s", host) != 1) {
2769                 ast_log(LOG_WARNING, "Invalid host in c= line, '%s'\n", c);
2770                 return -1;
2771         }
2772         /* XXX This could block for a long time, and block the main thread! XXX */
2773         hp = ast_gethostbyname(host, &ahp);
2774         if (!hp) {
2775                 ast_log(LOG_WARNING, "Unable to lookup host in c= line, '%s'\n", c);
2776                 return -1;
2777         }
2778         sdpLineNum_iterator_init(&iterator);
2779         ast_set_flag(p, SIP_NOVIDEO);
2780         while ((m = get_sdp_iterate(&iterator, req, "m"))[0] != '\0') {
2781                 if ((sscanf(m, "audio %d RTP/AVP %n", &x, &len) == 1) ||
2782                     (sscanf(m, "audio %d/%d RTP/AVP %n", &x, &y, &len) == 2)) {
2783                         portno = x;
2784                         /* Scan through the RTP payload types specified in a "m=" line: */
2785                         ast_rtp_pt_clear(p->rtp);
2786                         codecs = m + len;
2787                         while(!ast_strlen_zero(codecs)) {
2788                                 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2789                                         ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2790                                         return -1;
2791                                 }
2792                                 if (debug)
2793                                         ast_verbose("Found RTP audio format %d\n", codec);
2794                                 ast_rtp_set_m_type(p->rtp, codec);
2795                                 codecs += len;
2796                                 /* Skip over any whitespace */
2797                                 while(*codecs && (*codecs < 33)) codecs++;
2798                         }
2799                 }
2800                 if (p->vrtp)
2801                         ast_rtp_pt_clear(p->vrtp);  /* Must be cleared in case no m=video line exists */
2802
2803                 if (p->vrtp && (sscanf(m, "video %d RTP/AVP %n", &x, &len) == 1)) {
2804                         ast_clear_flag(p, SIP_NOVIDEO);
2805                         vportno = x;
2806                         /* Scan through the RTP payload types specified in a "m=" line: */
2807                         codecs = m + len;
2808                         while(!ast_strlen_zero(codecs)) {
2809                                 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
2810                                         ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
2811                                         return -1;
2812                                 }
2813                                 if (debug)
2814                                         ast_verbose("Found video format %s\n", ast_getformatname(codec));
2815                                 ast_rtp_set_m_type(p->vrtp, codec);
2816                                 codecs += len;
2817                                 /* Skip over any whitespace */
2818                                 while(*codecs && (*codecs < 33)) codecs++;
2819                         }
2820                 }
2821         }
2822         /* Check for Media-description-level-address for audio */
2823         if (pedanticsipchecking) {
2824                 c = get_sdp_iterate(&destiterator, req, "c");
2825                 if (!ast_strlen_zero(c)) {
2826                         if (sscanf(c, "IN IP4 %256s", host) != 1) {
2827                                 ast_log(LOG_WARNING, "Invalid secondary host in c= line, '%s'\n", c);
2828                         } else {
2829                                 /* XXX This could block for a long time, and block the main thread! XXX */
2830                                 hp = ast_gethostbyname(host, &ahp);
2831                                 if (!hp) {
2832                                         ast_log(LOG_WARNING, "Unable to lookup host in secondary c= line, '%s'\n", c);
2833                                 }
2834                         }
2835                 }
2836         }
2837         /* RTP addresses and ports for audio and video */
2838         sin.sin_family = AF_INET;
2839         memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
2840
2841         /* Setup audio port number */
2842         sin.sin_port = htons(portno);
2843         if (p->rtp && sin.sin_port) {
2844                 ast_rtp_set_peer(p->rtp, &sin);
2845                 if (debug) {
2846                         ast_verbose("Peer audio RTP is at port %s:%d\n", ast_inet_ntoa(iabuf,sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2847                         ast_log(LOG_DEBUG,"Peer audio RTP is at port %s:%d\n",ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2848                 }
2849         }
2850         /* Check for Media-description-level-address for video */
2851         if (pedanticsipchecking) {
2852                 c = get_sdp_iterate(&destiterator, req, "c");
2853                 if (!ast_strlen_zero(c)) {
2854                         if (sscanf(c, "IN IP4 %256s", host) != 1) {
2855                                 ast_log(LOG_WARNING, "Invalid secondary host in c= line, '%s'\n", c);
2856                         } else {
2857                                 /* XXX This could block for a long time, and block the main thread! XXX */
2858                                 hp = ast_gethostbyname(host, &ahp);
2859                                 if (!hp) {
2860                                         ast_log(LOG_WARNING, "Unable to lookup host in secondary c= line, '%s'\n", c);
2861                                 }
2862                         }
2863                 }
2864         }
2865         /* Setup video port number */
2866         sin.sin_port = htons(vportno);
2867         if (p->vrtp && sin.sin_port) {
2868                 ast_rtp_set_peer(p->vrtp, &sin);
2869                 if (debug) {
2870                         ast_verbose("Peer video RTP is at port %s:%d\n", ast_inet_ntoa(iabuf,sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2871                         ast_log(LOG_DEBUG,"Peer video RTP is at port %s:%d\n",ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
2872                 }
2873         }
2874
2875         /* Next, scan through each "a=rtpmap:" line, noting each
2876          * specified RTP payload type (with corresponding MIME subtype):
2877          */
2878         sdpLineNum_iterator_init(&iterator);
2879         while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
2880       char* mimeSubtype = ast_strdupa(a); /* ensures we have enough space */
2881           if (!strcasecmp(a, "sendonly")) {
2882                 sendonly=1;
2883                 continue;
2884           }
2885           if (!strcasecmp(a, "sendrecv")) {
2886                 sendonly=0;
2887           }
2888           if (sscanf(a, "rtpmap: %u %[^/]/", &codec, mimeSubtype) != 2) continue;
2889           if (debug)
2890                 ast_verbose("Found description format %s\n", mimeSubtype);
2891           /* Note: should really look at the 'freq' and '#chans' params too */
2892           ast_rtp_set_rtpmap_type(p->rtp, codec, "audio", mimeSubtype);
2893           if (p->vrtp)
2894                   ast_rtp_set_rtpmap_type(p->vrtp, codec, "video", mimeSubtype);
2895         }
2896
2897         /* Now gather all of the codecs that were asked for: */
2898         ast_rtp_get_current_formats(p->rtp,
2899                                 &peercapability, &peernoncodeccapability);
2900         if (p->vrtp)
2901                 ast_rtp_get_current_formats(p->vrtp,
2902                                 &vpeercapability, &vpeernoncodeccapability);
2903         p->jointcapability = p->capability & (peercapability | vpeercapability);
2904         p->peercapability = (peercapability | vpeercapability);
2905         p->noncodeccapability = noncodeccapability & peernoncodeccapability;
2906
2907         if (debug) {
2908                 /* shame on whoever coded this.... */
2909                 const unsigned slen=512;
2910                 char s1[slen], s2[slen], s3[slen], s4[slen];
2911
2912                 ast_verbose("Capabilities: us - %s, peer - audio=%s/video=%s, combined - %s\n",
2913                         ast_getformatname_multiple(s1, slen, p->capability),
2914                         ast_getformatname_multiple(s2, slen, peercapability),
2915                         ast_getformatname_multiple(s3, slen, vpeercapability),
2916                         ast_getformatname_multiple(s4, slen, p->jointcapability));
2917
2918                 ast_verbose("Non-codec capabilities: us - %s, peer - %s, combined - %s\n",
2919                         ast_getformatname_multiple(s1, slen, noncodeccapability),
2920                         ast_getformatname_multiple(s2, slen, peernoncodeccapability),
2921                         ast_getformatname_multiple(s3, slen, p->noncodeccapability));
2922         }
2923         if (!p->jointcapability) {
2924                 ast_log(LOG_NOTICE, "No compatible codecs!\n");
2925                 return -1;
2926         }
2927         if (p->owner) {
2928                 if (!(p->owner->nativeformats & p->jointcapability)) {
2929                         const unsigned slen=512;
2930                         char s1[slen], s2[slen];
2931                         ast_log(LOG_DEBUG, "Oooh, we need to change our formats since our peer supports only %s and not %s\n",
2932                                         ast_getformatname_multiple(s1, slen, p->jointcapability),
2933                                         ast_getformatname_multiple(s2, slen, p->owner->nativeformats));
2934                         p->owner->nativeformats = ast_codec_choose(&p->prefs, p->jointcapability, 1);
2935                         ast_set_read_format(p->owner, p->owner->readformat);
2936                         ast_set_write_format(p->owner, p->owner->writeformat);
2937                 }
2938                 if (ast_bridged_channel(p->owner)) {
2939                         /* Turn on/off music on hold if we are holding/unholding */
2940                         if (sin.sin_addr.s_addr && !sendonly) {
2941                                 ast_moh_stop(ast_bridged_channel(p->owner));
2942                                 if (callevents && ast_test_flag(p, SIP_CALL_ONHOLD)) {
2943                                         manager_event(EVENT_FLAG_CALL, "Unhold",
2944                                                 "Channel: %s\r\n"
2945                                                 "Uniqueid: %s\r\n",
2946                                                 p->owner->name,
2947                                                 p->owner->uniqueid);
2948                                         ast_clear_flag(p, SIP_CALL_ONHOLD);
2949                                 }
2950                         } else {
2951                                 if (callevents && !ast_test_flag(p, SIP_CALL_ONHOLD)) {
2952                                         manager_event(EVENT_FLAG_CALL, "Hold",
2953                                                 "Channel: %s\r\n"
2954                                                 "Uniqueid: %s\r\n",
2955                                                 p->owner->name,
2956                                                 p->owner->uniqueid);
2957                                                 ast_set_flag(p, SIP_CALL_ONHOLD);
2958                                 }
2959                                 ast_moh_start(ast_bridged_channel(p->owner), NULL);
2960                                 if (sendonly)
2961                                         ast_rtp_stop(p->rtp);
2962                         }
2963                 }
2964         }
2965         return 0;
2966
2967 }
2968
2969 /*--- add_header: Add header to SIP message */
2970 static int add_header(struct sip_request *req, char *var, char *value)
2971 {
2972         int x = 0;
2973         char *shortname = "";
2974         if (req->len >= sizeof(req->data) - 4) {
2975                 ast_log(LOG_WARNING, "Out of space, can't add anymore (%s:%s)\n", var, value);
2976                 return -1;
2977         }
2978         if (req->lines) {
2979                 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
2980                 return -1;
2981         }
2982
2983         req->header[req->headers] = req->data + req->len;
2984         if (compactheaders) {
2985                 for (x=0;x<sizeof(aliases) / sizeof(aliases[0]); x++)
2986                         if (!strcasecmp(aliases[x].fullname, var))
2987                                 shortname = aliases[x].shortname;
2988         }
2989         if(!ast_strlen_zero(shortname)) {
2990                 snprintf(req->header[req->headers], sizeof(req->data) - req->len - 4, "%s: %s\r\n", shortname, value);
2991         } else {
2992                 snprintf(req->header[req->headers], sizeof(req->data) - req->len - 4, "%s: %s\r\n", var, value);
2993         }
2994         req->len += strlen(req->header[req->headers]);
2995         if (req->headers < SIP_MAX_HEADERS)
2996                 req->headers++;
2997         else {
2998                 ast_log(LOG_WARNING, "Out of header space\n");
2999                 return -1;
3000         }
3001         return 0;
3002 }
3003
3004 /*--- add_blank_header: Add blank header to SIP message */
3005 static int add_blank_header(struct sip_request *req)
3006 {
3007         if (req->len >= sizeof(req->data) - 4) {
3008                 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
3009                 return -1;
3010         }
3011         if (req->lines) {
3012