channels/chan_sip.c

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