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