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