channels/chan_sip.c

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