channels/chan_sip.c

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