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