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