channels/chan_sip.c

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