channels/chan_sip.c

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