00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094 #include "asterisk.h"
00095
00096 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 141809 $")
00097
00098 #include <stdio.h>
00099 #include <ctype.h>
00100 #include <string.h>
00101 #include <unistd.h>
00102 #include <sys/socket.h>
00103 #include <sys/ioctl.h>
00104 #include <net/if.h>
00105 #include <errno.h>
00106 #include <stdlib.h>
00107 #include <fcntl.h>
00108 #include <netdb.h>
00109 #include <signal.h>
00110 #include <sys/signal.h>
00111 #include <netinet/in.h>
00112 #include <netinet/in_systm.h>
00113 #include <arpa/inet.h>
00114 #include <netinet/ip.h>
00115 #include <regex.h>
00116
00117 #include "asterisk/lock.h"
00118 #include "asterisk/channel.h"
00119 #include "asterisk/config.h"
00120 #include "asterisk/logger.h"
00121 #include "asterisk/module.h"
00122 #include "asterisk/pbx.h"
00123 #include "asterisk/options.h"
00124 #include "asterisk/sched.h"
00125 #include "asterisk/io.h"
00126 #include "asterisk/rtp.h"
00127 #include "asterisk/udptl.h"
00128 #include "asterisk/acl.h"
00129 #include "asterisk/manager.h"
00130 #include "asterisk/callerid.h"
00131 #include "asterisk/cli.h"
00132 #include "asterisk/app.h"
00133 #include "asterisk/musiconhold.h"
00134 #include "asterisk/dsp.h"
00135 #include "asterisk/features.h"
00136 #include "asterisk/srv.h"
00137 #include "asterisk/astdb.h"
00138 #include "asterisk/causes.h"
00139 #include "asterisk/utils.h"
00140 #include "asterisk/file.h"
00141 #include "asterisk/astobj.h"
00142 #include "asterisk/devicestate.h"
00143 #include "asterisk/linkedlists.h"
00144 #include "asterisk/stringfields.h"
00145 #include "asterisk/monitor.h"
00146 #include "asterisk/localtime.h"
00147 #include "asterisk/abstract_jb.h"
00148 #include "asterisk/compiler.h"
00149 #include "asterisk/threadstorage.h"
00150 #include "asterisk/translate.h"
00151
00152 #ifndef FALSE
00153 #define FALSE 0
00154 #endif
00155
00156 #ifndef TRUE
00157 #define TRUE 1
00158 #endif
00159
00160 #define SIPBUFSIZE 512
00161
00162 #define XMIT_ERROR -2
00163
00164 #define VIDEO_CODEC_MASK 0x1fc0000
00165 #ifndef IPTOS_MINCOST
00166 #define IPTOS_MINCOST 0x02
00167 #endif
00168
00169
00170
00171 #define DEFAULT_DEFAULT_EXPIRY 120
00172 #define DEFAULT_MIN_EXPIRY 60
00173 #define DEFAULT_MAX_EXPIRY 3600
00174 #define DEFAULT_REGISTRATION_TIMEOUT 20
00175 #define DEFAULT_MAX_FORWARDS "70"
00176
00177
00178
00179 #define EXPIRY_GUARD_SECS 15
00180 #define EXPIRY_GUARD_LIMIT 30
00181
00182 #define EXPIRY_GUARD_MIN 500
00183
00184
00185
00186 #define EXPIRY_GUARD_PCT 0.20
00187
00188 #define DEFAULT_EXPIRY 900
00189
00190 static int min_expiry = DEFAULT_MIN_EXPIRY;
00191 static int max_expiry = DEFAULT_MAX_EXPIRY;
00192 static int default_expiry = DEFAULT_DEFAULT_EXPIRY;
00193 static int expiry = DEFAULT_EXPIRY;
00194
00195 #ifndef MAX
00196 #define MAX(a,b) ((a) > (b) ? (a) : (b))
00197 #endif
00198
00199 #define CALLERID_UNKNOWN "Unknown"
00200
00201 #define DEFAULT_MAXMS 2000
00202 #define DEFAULT_FREQ_OK 60 * 1000
00203 #define DEFAULT_FREQ_NOTOK 10 * 1000
00204
00205 #define DEFAULT_RETRANS 1000
00206 #define MAX_RETRANS 6
00207 #define SIP_TRANS_TIMEOUT 32000
00208
00209
00210 #define DEFAULT_TRANS_TIMEOUT -1
00211 #define MAX_AUTHTRIES 3
00212
00213 #define SIP_MAX_HEADERS 64
00214 #define SIP_MAX_LINES 64
00215 #define SIP_MAX_PACKET 4096
00216
00217 #define SDP_MAX_RTPMAP_CODECS 32
00218
00219 #define INITIAL_CSEQ 101
00220
00221
00222 static struct ast_jb_conf default_jbconf =
00223 {
00224 .flags = 0,
00225 .max_size = -1,
00226 .resync_threshold = -1,
00227 .impl = ""
00228 };
00229 static struct ast_jb_conf global_jbconf;
00230
00231 static const char config[] = "sip.conf";
00232 static const char notify_config[] = "sip_notify.conf";
00233
00234 #define RTP 1
00235 #define NO_RTP 0
00236
00237
00238
00239
00240 enum transfermodes {
00241 TRANSFER_OPENFORALL,
00242 TRANSFER_CLOSED,
00243 };
00244
00245
00246 enum sip_result {
00247 AST_SUCCESS = 0,
00248 AST_FAILURE = -1,
00249 };
00250
00251
00252
00253
00254 enum invitestates {
00255 INV_NONE = 0,
00256 INV_CALLING = 1,
00257 INV_PROCEEDING = 2,
00258 INV_EARLY_MEDIA = 3,
00259 INV_COMPLETED = 4,
00260 INV_CONFIRMED = 5,
00261 INV_TERMINATED = 6,
00262
00263 INV_CANCELLED = 7,
00264 };
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274 enum xmittype {
00275 XMIT_CRITICAL = 2,
00276
00277 XMIT_RELIABLE = 1,
00278 XMIT_UNRELIABLE = 0,
00279 };
00280
00281 enum parse_register_result {
00282 PARSE_REGISTER_FAILED,
00283 PARSE_REGISTER_UPDATE,
00284 PARSE_REGISTER_QUERY,
00285 };
00286
00287 enum subscriptiontype {
00288 NONE = 0,
00289 XPIDF_XML,
00290 DIALOG_INFO_XML,
00291 CPIM_PIDF_XML,
00292 PIDF_XML,
00293 MWI_NOTIFICATION
00294 };
00295
00296 static const struct cfsubscription_types {
00297 enum subscriptiontype type;
00298 const char * const event;
00299 const char * const mediatype;
00300 const char * const text;
00301 } subscription_types[] = {
00302 { NONE, "-", "unknown", "unknown" },
00303
00304 { DIALOG_INFO_XML, "dialog", "application/dialog-info+xml", "dialog-info+xml" },
00305 { CPIM_PIDF_XML, "presence", "application/cpim-pidf+xml", "cpim-pidf+xml" },
00306 { PIDF_XML, "presence", "application/pidf+xml", "pidf+xml" },
00307 { XPIDF_XML, "presence", "application/xpidf+xml", "xpidf+xml" },
00308 { MWI_NOTIFICATION, "message-summary", "application/simple-message-summary", "mwi" }
00309 };
00310
00311
00312 enum sipmethod {
00313 SIP_UNKNOWN,
00314 SIP_RESPONSE,
00315 SIP_REGISTER,
00316 SIP_OPTIONS,
00317 SIP_NOTIFY,
00318 SIP_INVITE,
00319 SIP_ACK,
00320 SIP_PRACK,
00321 SIP_BYE,
00322 SIP_REFER,
00323 SIP_SUBSCRIBE,
00324 SIP_MESSAGE,
00325 SIP_UPDATE,
00326 SIP_INFO,
00327 SIP_CANCEL,
00328 SIP_PUBLISH,
00329 SIP_PING,
00330 };
00331
00332
00333
00334
00335
00336
00337 enum sip_auth_type {
00338 PROXY_AUTH,
00339 WWW_AUTH,
00340 };
00341
00342
00343 enum check_auth_result {
00344 AUTH_SUCCESSFUL = 0,
00345 AUTH_CHALLENGE_SENT = 1,
00346 AUTH_SECRET_FAILED = -1,
00347 AUTH_USERNAME_MISMATCH = -2,
00348 AUTH_NOT_FOUND = -3,
00349 AUTH_FAKE_AUTH = -4,
00350 AUTH_UNKNOWN_DOMAIN = -5,
00351 AUTH_PEER_NOT_DYNAMIC = -6,
00352 AUTH_ACL_FAILED = -7,
00353 };
00354
00355
00356 enum sipregistrystate {
00357 REG_STATE_UNREGISTERED = 0,
00358 REG_STATE_REGSENT,
00359 REG_STATE_AUTHSENT,
00360 REG_STATE_REGISTERED,
00361 REG_STATE_REJECTED,
00362 REG_STATE_TIMEOUT,
00363 REG_STATE_NOAUTH,
00364 REG_STATE_FAILED,
00365 };
00366
00367 #define CAN_NOT_CREATE_DIALOG 0
00368 #define CAN_CREATE_DIALOG 1
00369 #define CAN_CREATE_DIALOG_UNSUPPORTED_METHOD 2
00370
00371
00372 static const struct cfsip_methods {
00373 enum sipmethod id;
00374 int need_rtp;
00375 char * const text;
00376 int can_create;
00377 } sip_methods[] = {
00378 { SIP_UNKNOWN, RTP, "-UNKNOWN-", CAN_CREATE_DIALOG },
00379 { SIP_RESPONSE, NO_RTP, "SIP/2.0", CAN_NOT_CREATE_DIALOG },
00380 { SIP_REGISTER, NO_RTP, "REGISTER", CAN_CREATE_DIALOG },
00381 { SIP_OPTIONS, NO_RTP, "OPTIONS", CAN_CREATE_DIALOG },
00382 { SIP_NOTIFY, NO_RTP, "NOTIFY", CAN_CREATE_DIALOG },
00383 { SIP_INVITE, RTP, "INVITE", CAN_CREATE_DIALOG },
00384 { SIP_ACK, NO_RTP, "ACK", CAN_NOT_CREATE_DIALOG },
00385 { SIP_PRACK, NO_RTP, "PRACK", CAN_NOT_CREATE_DIALOG },
00386 { SIP_BYE, NO_RTP, "BYE", CAN_NOT_CREATE_DIALOG },
00387 { SIP_REFER, NO_RTP, "REFER", CAN_CREATE_DIALOG },
00388 { SIP_SUBSCRIBE, NO_RTP, "SUBSCRIBE", CAN_CREATE_DIALOG },
00389 { SIP_MESSAGE, NO_RTP, "MESSAGE", CAN_CREATE_DIALOG },
00390 { SIP_UPDATE, NO_RTP, "UPDATE", CAN_NOT_CREATE_DIALOG },
00391 { SIP_INFO, NO_RTP, "INFO", CAN_NOT_CREATE_DIALOG },
00392 { SIP_CANCEL, NO_RTP, "CANCEL", CAN_NOT_CREATE_DIALOG },
00393 { SIP_PUBLISH, NO_RTP, "PUBLISH", CAN_CREATE_DIALOG_UNSUPPORTED_METHOD },
00394 { SIP_PING, NO_RTP, "PING", CAN_CREATE_DIALOG_UNSUPPORTED_METHOD }
00395 };
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407 #define SUPPORTED 1
00408 #define NOT_SUPPORTED 0
00409
00410 #define SIP_OPT_REPLACES (1 << 0)
00411 #define SIP_OPT_100REL (1 << 1)
00412 #define SIP_OPT_TIMER (1 << 2)
00413 #define SIP_OPT_EARLY_SESSION (1 << 3)
00414 #define SIP_OPT_JOIN (1 << 4)
00415 #define SIP_OPT_PATH (1 << 5)
00416 #define SIP_OPT_PREF (1 << 6)
00417 #define SIP_OPT_PRECONDITION (1 << 7)
00418 #define SIP_OPT_PRIVACY (1 << 8)
00419 #define SIP_OPT_SDP_ANAT (1 << 9)
00420 #define SIP_OPT_SEC_AGREE (1 << 10)
00421 #define SIP_OPT_EVENTLIST (1 << 11)
00422 #define SIP_OPT_GRUU (1 << 12)
00423 #define SIP_OPT_TARGET_DIALOG (1 << 13)
00424 #define SIP_OPT_NOREFERSUB (1 << 14)
00425 #define SIP_OPT_HISTINFO (1 << 15)
00426 #define SIP_OPT_RESPRIORITY (1 << 16)
00427
00428
00429
00430 static const struct cfsip_options {
00431 int id;
00432 int supported;
00433 char * const text;
00434 } sip_options[] = {
00435
00436 { SIP_OPT_REPLACES, SUPPORTED, "replaces" },
00437
00438 { SIP_OPT_REPLACES, SUPPORTED, "replace" },
00439
00440 { SIP_OPT_100REL, NOT_SUPPORTED, "100rel" },
00441
00442 { SIP_OPT_TIMER, NOT_SUPPORTED, "timer" },
00443
00444 { SIP_OPT_EARLY_SESSION, NOT_SUPPORTED, "early-session" },
00445
00446 { SIP_OPT_JOIN, NOT_SUPPORTED, "join" },
00447
00448 { SIP_OPT_PATH, NOT_SUPPORTED, "path" },
00449
00450 { SIP_OPT_PREF, NOT_SUPPORTED, "pref" },
00451
00452 { SIP_OPT_PRECONDITION, NOT_SUPPORTED, "precondition" },
00453
00454 { SIP_OPT_PRIVACY, NOT_SUPPORTED, "privacy" },
00455
00456 { SIP_OPT_SDP_ANAT, NOT_SUPPORTED, "sdp-anat" },
00457
00458 { SIP_OPT_SEC_AGREE, NOT_SUPPORTED, "sec_agree" },
00459
00460 { SIP_OPT_EVENTLIST, NOT_SUPPORTED, "eventlist" },
00461
00462 { SIP_OPT_GRUU, NOT_SUPPORTED, "gruu" },
00463
00464 { SIP_OPT_TARGET_DIALOG,NOT_SUPPORTED, "tdialog" },
00465
00466 { SIP_OPT_NOREFERSUB, NOT_SUPPORTED, "norefersub" },
00467
00468 { SIP_OPT_HISTINFO, NOT_SUPPORTED, "histinfo" },
00469
00470 { SIP_OPT_RESPRIORITY, NOT_SUPPORTED, "resource-priority" },
00471 };
00472
00473
00474
00475 #define ALLOWED_METHODS "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, SUBSCRIBE, NOTIFY"
00476
00477
00478 #define SUPPORTED_EXTENSIONS "replaces"
00479
00480
00481 #define STANDARD_SIP_PORT 5060
00482
00483
00484
00485
00486
00487
00488
00489
00490
00491
00492
00493
00494 #define DEFAULT_CONTEXT "default"
00495 #define DEFAULT_MOHINTERPRET "default"
00496 #define DEFAULT_MOHSUGGEST ""
00497 #define DEFAULT_VMEXTEN "asterisk"
00498 #define DEFAULT_CALLERID "asterisk"
00499 #define DEFAULT_NOTIFYMIME "application/simple-message-summary"
00500 #define DEFAULT_MWITIME 10
00501 #define DEFAULT_ALLOWGUEST TRUE
00502 #define DEFAULT_SRVLOOKUP TRUE
00503 #define DEFAULT_COMPACTHEADERS FALSE
00504 #define DEFAULT_TOS_SIP 0
00505 #define DEFAULT_TOS_AUDIO 0
00506 #define DEFAULT_TOS_VIDEO 0
00507 #define DEFAULT_ALLOW_EXT_DOM TRUE
00508 #define DEFAULT_REALM "asterisk"
00509 #define DEFAULT_NOTIFYRINGING TRUE
00510 #define DEFAULT_PEDANTIC FALSE
00511 #define DEFAULT_AUTOCREATEPEER FALSE
00512 #define DEFAULT_QUALIFY FALSE
00513 #define DEFAULT_T1MIN 100
00514 #define DEFAULT_MAX_CALL_BITRATE (384)
00515 #ifndef DEFAULT_USERAGENT
00516 #define DEFAULT_USERAGENT "Asterisk PBX"
00517 #endif
00518
00519
00520
00521
00522 static char default_context[AST_MAX_CONTEXT];
00523 static char default_subscribecontext[AST_MAX_CONTEXT];
00524 static char default_language[MAX_LANGUAGE];
00525 static char default_callerid[AST_MAX_EXTENSION];
00526 static char default_fromdomain[AST_MAX_EXTENSION];
00527 static char default_notifymime[AST_MAX_EXTENSION];
00528 static int default_qualify;
00529 static char default_vmexten[AST_MAX_EXTENSION];
00530 static char default_mohinterpret[MAX_MUSICCLASS];
00531 static char default_mohsuggest[MAX_MUSICCLASS];
00532
00533 static int default_maxcallbitrate;
00534 static struct ast_codec_pref default_prefs;
00535
00536
00537 static int global_directrtpsetup;
00538 static int global_limitonpeers;
00539 static int global_rtautoclear;
00540 static int global_notifyringing;
00541 static int global_notifyhold;
00542 static int global_alwaysauthreject;
00543 static int srvlookup;
00544 static int pedanticsipchecking;
00545 static int autocreatepeer;
00546 static int global_relaxdtmf;
00547 static int global_rtptimeout;
00548 static int global_rtpholdtimeout;
00549 static int global_rtpkeepalive;
00550 static int global_reg_timeout;
00551 static int global_regattempts_max;
00552 static int global_allowguest;
00553 static int global_allowsubscribe;
00554
00555 static int global_mwitime;
00556 static unsigned int global_tos_sip;
00557 static unsigned int global_tos_audio;
00558 static unsigned int global_tos_video;
00559 static int compactheaders;
00560 static int recordhistory;
00561 static int dumphistory;
00562 static char global_realm[MAXHOSTNAMELEN];
00563 static char global_regcontext[AST_MAX_CONTEXT];
00564 static char global_useragent[AST_MAX_EXTENSION];
00565 static int allow_external_domains;
00566 static int global_callevents;
00567 static int global_t1min;
00568 static int global_autoframing;
00569 static enum transfermodes global_allowtransfer;
00570
00571 static int global_matchexterniplocally;
00572
00573
00574 static int global_capability = AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_GSM | AST_FORMAT_H263;
00575
00576
00577 static int suserobjs = 0;
00578 static int ruserobjs = 0;
00579 static int speerobjs = 0;
00580 static int rpeerobjs = 0;
00581 static int apeerobjs = 0;
00582 static int regobjs = 0;
00583
00584 static struct ast_flags global_flags[2] = {{0}};
00585
00586
00587 AST_MUTEX_DEFINE_STATIC(iflock);
00588
00589
00590
00591 AST_MUTEX_DEFINE_STATIC(netlock);
00592
00593 AST_MUTEX_DEFINE_STATIC(monlock);
00594
00595 AST_MUTEX_DEFINE_STATIC(sip_reload_lock);
00596
00597
00598
00599 static pthread_t monitor_thread = AST_PTHREADT_NULL;
00600
00601 static int sip_reloading = FALSE;
00602 static enum channelreloadreason sip_reloadreason;
00603
00604 static struct sched_context *sched;
00605 static struct io_context *io;
00606 static int *sipsock_read_id;
00607 static int *siptcpsock_read_id;
00608
00609 #define DEC_CALL_LIMIT 0
00610 #define INC_CALL_LIMIT 1
00611 #define DEC_CALL_RINGING 2
00612 #define INC_CALL_RINGING 3
00613
00614
00615 struct sip_request {
00616 char *rlPart1;
00617 char *rlPart2;
00618 int len;
00619 int headers;
00620 int method;
00621 int lines;
00622 unsigned int flags;
00623 char *header[SIP_MAX_HEADERS];
00624 char *line[SIP_MAX_LINES];
00625 char data[SIP_MAX_PACKET];
00626 unsigned int sdp_start;
00627 unsigned int sdp_end;
00628 };
00629
00630
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642
00643
00644
00645
00646
00647
00648
00649
00650 struct sip_dual {
00651 struct ast_channel *chan1;
00652 struct ast_channel *chan2;
00653 struct sip_request req;
00654 int seqno;
00655 };
00656
00657 struct sip_pkt;
00658
00659
00660 struct sip_invite_param {
00661 const char *distinctive_ring;
00662 int addsipheaders;
00663 const char *uri_options;
00664 const char *vxml_url;
00665 char *auth;
00666 char *authheader;
00667 enum sip_auth_type auth_type;
00668 const char *replaces;
00669 int transfer;
00670 };
00671
00672
00673 struct sip_route {
00674 struct sip_route *next;
00675 char hop[0];
00676 };
00677
00678
00679 enum domain_mode {
00680 SIP_DOMAIN_AUTO,
00681 SIP_DOMAIN_CONFIG,
00682 };
00683
00684
00685
00686
00687
00688 struct domain {
00689 char domain[MAXHOSTNAMELEN];
00690 char context[AST_MAX_EXTENSION];
00691 enum domain_mode mode;
00692 AST_LIST_ENTRY(domain) list;
00693 };
00694
00695 static AST_LIST_HEAD_STATIC(domain_list, domain);
00696
00697
00698
00699 struct sip_history {
00700 AST_LIST_ENTRY(sip_history) list;
00701 char event[0];
00702 };
00703
00704 AST_LIST_HEAD_NOLOCK(sip_history_head, sip_history);
00705
00706
00707 struct sip_auth {
00708 char realm[AST_MAX_EXTENSION];
00709 char username[256];
00710 char secret[256];
00711 char md5secret[256];
00712 struct sip_auth *next;
00713 };
00714
00715
00716 #define SIP_ALREADYGONE (1 << 0)
00717 #define SIP_NEEDDESTROY (1 << 1)
00718 #define SIP_NOVIDEO (1 << 2)
00719 #define SIP_RINGING (1 << 3)
00720 #define SIP_PROGRESS_SENT (1 << 4)
00721 #define SIP_NEEDREINVITE (1 << 5)
00722 #define SIP_PENDINGBYE (1 << 6)
00723 #define SIP_GOTREFER (1 << 7)
00724 #define SIP_PROMISCREDIR (1 << 8)
00725 #define SIP_TRUSTRPID (1 << 9)
00726 #define SIP_USEREQPHONE (1 << 10)
00727 #define SIP_REALTIME (1 << 11)
00728 #define SIP_USECLIENTCODE (1 << 12)
00729 #define SIP_OUTGOING (1 << 13)
00730 #define SIP_FREE_BIT (1 << 14)
00731 #define SIP_DEFER_BYE_ON_TRANSFER (1 << 15)
00732 #define SIP_DTMF (3 << 16)
00733 #define SIP_DTMF_RFC2833 (0 << 16)
00734 #define SIP_DTMF_INBAND (1 << 16)
00735 #define SIP_DTMF_INFO (2 << 16)
00736 #define SIP_DTMF_AUTO (3 << 16)
00737
00738 #define SIP_NAT (3 << 18)
00739 #define SIP_NAT_NEVER (0 << 18)
00740 #define SIP_NAT_RFC3581 (1 << 18)
00741 #define SIP_NAT_ROUTE (2 << 18)
00742 #define SIP_NAT_ALWAYS (3 << 18)
00743
00744 #define SIP_REINVITE (7 << 20)
00745 #define SIP_CAN_REINVITE (1 << 20)
00746 #define SIP_CAN_REINVITE_NAT (2 << 20)
00747 #define SIP_REINVITE_UPDATE (4 << 20)
00748
00749 #define SIP_INSECURE_PORT (1 << 23)
00750 #define SIP_INSECURE_INVITE (1 << 24)
00751
00752 #define SIP_PROG_INBAND (3 << 25)
00753 #define SIP_PROG_INBAND_NEVER (0 << 25)
00754 #define SIP_PROG_INBAND_NO (1 << 25)
00755 #define SIP_PROG_INBAND_YES (2 << 25)
00756 #define SIP_NO_HISTORY (1 << 27)
00757 #define SIP_CALL_LIMIT (1 << 28)
00758 #define SIP_SENDRPID (1 << 29)
00759 #define SIP_INC_COUNT (1 << 30)
00760 #define SIP_G726_NONSTANDARD (1 << 31)
00761
00762 #define SIP_FLAGS_TO_COPY \
00763 (SIP_PROMISCREDIR | SIP_TRUSTRPID | SIP_SENDRPID | SIP_DTMF | SIP_REINVITE | \
00764 SIP_PROG_INBAND | SIP_USECLIENTCODE | SIP_NAT | SIP_G726_NONSTANDARD | \
00765 SIP_USEREQPHONE | SIP_INSECURE_PORT | SIP_INSECURE_INVITE)
00766
00767
00768
00769 #define SIP_PAGE2_RTCACHEFRIENDS (1 << 0)
00770 #define SIP_PAGE2_RTUPDATE (1 << 1)
00771 #define SIP_PAGE2_RTAUTOCLEAR (1 << 2)
00772 #define SIP_PAGE2_RT_FROMCONTACT (1 << 4)
00773 #define SIP_PAGE2_RTSAVE_SYSNAME (1 << 5)
00774
00775 #define SIP_PAGE2_STATECHANGEQUEUE (1 << 9)
00776 #define SIP_PAGE2_IGNOREREGEXPIRE (1 << 10)
00777 #define SIP_PAGE2_DEBUG (3 << 11)
00778 #define SIP_PAGE2_DEBUG_CONFIG (1 << 11)
00779 #define SIP_PAGE2_DEBUG_CONSOLE (1 << 12)
00780 #define SIP_PAGE2_DYNAMIC (1 << 13)
00781 #define SIP_PAGE2_SELFDESTRUCT (1 << 14)
00782 #define SIP_PAGE2_VIDEOSUPPORT (1 << 15)
00783 #define SIP_PAGE2_ALLOWSUBSCRIBE (1 << 16)
00784 #define SIP_PAGE2_ALLOWOVERLAP (1 << 17)
00785 #define SIP_PAGE2_SUBSCRIBEMWIONLY (1 << 18)
00786 #define SIP_PAGE2_INC_RINGING (1 << 19)
00787 #define SIP_PAGE2_T38SUPPORT (7 << 20)
00788 #define SIP_PAGE2_T38SUPPORT_UDPTL (1 << 20)
00789 #define SIP_PAGE2_T38SUPPORT_RTP (2 << 20)
00790 #define SIP_PAGE2_T38SUPPORT_TCP (4 << 20)
00791 #define SIP_PAGE2_CALL_ONHOLD (3 << 23)
00792 #define SIP_PAGE2_CALL_ONHOLD_ACTIVE (1 << 23)
00793 #define SIP_PAGE2_CALL_ONHOLD_ONEDIR (2 << 23)
00794 #define SIP_PAGE2_CALL_ONHOLD_INACTIVE (3 << 23)
00795 #define SIP_PAGE2_RFC2833_COMPENSATE (1 << 25)
00796 #define SIP_PAGE2_BUGGY_MWI (1 << 26)
00797 #define SIP_PAGE2_OUTGOING_CALL (1 << 27)
00798 #define SIP_PAGE2_UDPTL_DESTINATION (1 << 28)
00799 #define SIP_PAGE2_DIALOG_ESTABLISHED (1 << 29)
00800 #define SIP_PAGE2_TCP (1 << 30)
00801 #define SIP_PAGE2_TCP_CONNECTED (1 << 31)
00802
00803 #define SIP_PAGE2_FLAGS_TO_COPY \
00804 (SIP_PAGE2_ALLOWSUBSCRIBE | SIP_PAGE2_ALLOWOVERLAP | SIP_PAGE2_VIDEOSUPPORT | \
00805 SIP_PAGE2_T38SUPPORT | SIP_PAGE2_RFC2833_COMPENSATE | SIP_PAGE2_BUGGY_MWI | SIP_PAGE2_UDPTL_DESTINATION)
00806
00807
00808 #define SIP_PKT_DEBUG (1 << 0)
00809 #define SIP_PKT_WITH_TOTAG (1 << 1)
00810 #define SIP_PKT_IGNORE (1 << 2)
00811 #define SIP_PKT_IGNORE_RESP (1 << 3)
00812 #define SIP_PKT_IGNORE_REQ (1 << 4)
00813
00814
00815 #define T38FAX_FILL_BIT_REMOVAL (1 << 0)
00816 #define T38FAX_TRANSCODING_MMR (1 << 1)
00817 #define T38FAX_TRANSCODING_JBIG (1 << 2)
00818
00819 #define T38FAX_RATE_MANAGEMENT_TRANSFERED_TCF (0 << 3)
00820 #define T38FAX_RATE_MANAGEMENT_LOCAL_TCF (1 << 3)
00821
00822 #define T38FAX_UDP_EC_NONE (0 << 4)
00823 #define T38FAX_UDP_EC_FEC (1 << 4)
00824 #define T38FAX_UDP_EC_REDUNDANCY (2 << 4)
00825
00826 #define T38FAX_VERSION (3 << 6)
00827 #define T38FAX_VERSION_0 (0 << 6)
00828 #define T38FAX_VERSION_1 (1 << 6)
00829
00830 #define T38FAX_RATE_2400 (1 << 8)
00831 #define T38FAX_RATE_4800 (1 << 9)
00832 #define T38FAX_RATE_7200 (1 << 10)
00833 #define T38FAX_RATE_9600 (1 << 11)
00834 #define T38FAX_RATE_12000 (1 << 12)
00835 #define T38FAX_RATE_14400 (1 << 13)
00836
00837
00838 static int global_t38_capability = T38FAX_VERSION_0 | T38FAX_RATE_2400 | T38FAX_RATE_4800 | T38FAX_RATE_7200 | T38FAX_RATE_9600;
00839
00840 #define sipdebug ast_test_flag(&global_flags[1], SIP_PAGE2_DEBUG)
00841 #define sipdebug_config ast_test_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONFIG)
00842 #define sipdebug_console ast_test_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE)
00843
00844
00845 enum t38state {
00846 T38_DISABLED = 0,
00847 T38_LOCAL_DIRECT,
00848 T38_LOCAL_REINVITE,
00849 T38_PEER_DIRECT,
00850 T38_PEER_REINVITE,
00851 T38_ENABLED
00852 };
00853
00854
00855 struct t38properties {
00856 struct ast_flags t38support;
00857 int capability;
00858 int peercapability;
00859 int jointcapability;
00860 enum t38state state;
00861 };
00862
00863
00864 enum referstatus {
00865 REFER_IDLE,
00866 REFER_SENT,
00867 REFER_RECEIVED,
00868 REFER_CONFIRMED,
00869 REFER_ACCEPTED,
00870 REFER_RINGING,
00871 REFER_200OK,
00872 REFER_FAILED,
00873 REFER_NOAUTH
00874 };
00875
00876 static const struct c_referstatusstring {
00877 enum referstatus status;
00878 char *text;
00879 } referstatusstrings[] = {
00880 { REFER_IDLE, "<none>" },
00881 { REFER_SENT, "Request sent" },
00882 { REFER_RECEIVED, "Request received" },
00883 { REFER_ACCEPTED, "Accepted" },
00884 { REFER_RINGING, "Target ringing" },
00885 { REFER_200OK, "Done" },
00886 { REFER_FAILED, "Failed" },
00887 { REFER_NOAUTH, "Failed - auth failure" }
00888 } ;
00889
00890
00891
00892 struct sip_refer {
00893 char refer_to[AST_MAX_EXTENSION];
00894 char refer_to_domain[AST_MAX_EXTENSION];
00895 char refer_to_urioption[AST_MAX_EXTENSION];
00896 char refer_to_context[AST_MAX_EXTENSION];
00897 char referred_by[AST_MAX_EXTENSION];
00898 char referred_by_name[AST_MAX_EXTENSION];
00899 char refer_contact[AST_MAX_EXTENSION];
00900 char replaces_callid[SIPBUFSIZE];
00901 char replaces_callid_totag[SIPBUFSIZE/2];
00902 char replaces_callid_fromtag[SIPBUFSIZE/2];
00903 struct sip_pvt *refer_call;
00904 int attendedtransfer;
00905 int localtransfer;
00906 enum referstatus status;
00907 };
00908
00909
00910 static struct sip_pvt {
00911 ast_mutex_t lock;
00912 int method;
00913 enum invitestates invitestate;
00914 AST_DECLARE_STRING_FIELDS(
00915 AST_STRING_FIELD(callid);
00916 AST_STRING_FIELD(randdata);
00917 AST_STRING_FIELD(accountcode);
00918 AST_STRING_FIELD(realm);
00919 AST_STRING_FIELD(nonce);
00920 AST_STRING_FIELD(opaque);
00921 AST_STRING_FIELD(qop);
00922 AST_STRING_FIELD(domain);
00923 AST_STRING_FIELD(from);
00924 AST_STRING_FIELD(useragent);
00925 AST_STRING_FIELD(exten);
00926 AST_STRING_FIELD(context);
00927 AST_STRING_FIELD(subscribecontext);
00928 AST_STRING_FIELD(subscribeuri);
00929 AST_STRING_FIELD(fromdomain);
00930 AST_STRING_FIELD(fromuser);
00931 AST_STRING_FIELD(fromname);
00932 AST_STRING_FIELD(tohost);
00933 AST_STRING_FIELD(language);
00934 AST_STRING_FIELD(mohinterpret);
00935 AST_STRING_FIELD(mohsuggest);
00936 AST_STRING_FIELD(rdnis);
00937 AST_STRING_FIELD(theirtag);
00938 AST_STRING_FIELD(username);
00939 AST_STRING_FIELD(peername);
00940 AST_STRING_FIELD(authname);
00941 AST_STRING_FIELD(uri);
00942 AST_STRING_FIELD(okcontacturi);
00943 AST_STRING_FIELD(peersecret);
00944 AST_STRING_FIELD(peermd5secret);
00945 AST_STRING_FIELD(cid_num);
00946 AST_STRING_FIELD(cid_name);
00947 AST_STRING_FIELD(via);
00948 AST_STRING_FIELD(fullcontact);
00949 AST_STRING_FIELD(our_contact);
00950 AST_STRING_FIELD(rpid);
00951 AST_STRING_FIELD(rpid_from);
00952 );
00953 unsigned int ocseq;
00954 unsigned int icseq;
00955 ast_group_t callgroup;
00956 ast_group_t pickupgroup;
00957 int lastinvite;
00958 int lastnoninvite;
00959 struct ast_flags flags[2];
00960 int timer_t1;
00961 unsigned int sipoptions;
00962 struct ast_codec_pref prefs;
00963 int capability;
00964 int jointcapability;
00965 int peercapability;
00966 int prefcodec;
00967 int noncodeccapability;
00968 int jointnoncodeccapability;
00969 int redircodecs;
00970 int maxcallbitrate;
00971 struct t38properties t38;
00972 struct sockaddr_in udptlredirip;
00973 struct ast_udptl *udptl;
00974 int callingpres;
00975 int authtries;
00976 int expiry;
00977 long branch;
00978 char tag[11];
00979 int sessionid;
00980 int sessionversion;
00981 struct sockaddr_in sa;
00982 struct sockaddr_in redirip;
00983 struct sockaddr_in vredirip;
00984 time_t lastrtprx;
00985 time_t lastrtptx;
00986 int rtptimeout;
00987 struct sockaddr_in recv;
00988 struct in_addr ourip;
00989 struct ast_channel *owner;
00990 struct sip_route *route;
00991 int route_persistant;
00992 struct sip_auth *peerauth;
00993 int noncecount;
00994 char lastmsg[256];
00995 int amaflags;
00996 int pendinginvite;
00997 struct sip_request initreq;
00998
00999
01000 int maxtime;
01001 int initid;
01002 int waitid;
01003 int autokillid;
01004 enum transfermodes allowtransfer;
01005 struct sip_refer *refer;
01006 enum subscriptiontype subscribed;
01007 int stateid;
01008 int laststate;
01009 int dialogver;
01010
01011 struct ast_dsp *vad;
01012
01013 struct sip_peer *relatedpeer;
01014
01015 struct sip_registry *registry;
01016 struct ast_rtp *rtp;
01017 struct ast_rtp *vrtp;
01018 struct sip_pkt *packets;
01019 struct sip_history_head *history;
01020 size_t history_entries;
01021 struct ast_variable *chanvars;
01022 struct sip_pvt *next;
01023 struct sip_invite_param *options;
01024 int autoframing;
01025 int sockfd;
01026 } *iflist = NULL;
01027
01028
01029 #define MAX_HISTORY_ENTRIES 50
01030
01031 #define FLAG_RESPONSE (1 << 0)
01032 #define FLAG_FATAL (1 << 1)
01033
01034
01035 struct sip_pkt {
01036 struct sip_pkt *next;
01037 int retrans;
01038 int method;
01039 int seqno;
01040 unsigned int flags;
01041 struct sip_pvt *owner;
01042 int retransid;
01043 int timer_a;
01044 int timer_t1;
01045 int packetlen;
01046 char data[0];
01047 };
01048
01049
01050 struct sip_user {
01051
01052 ASTOBJ_COMPONENTS(struct sip_user);
01053 char secret[80];
01054 char md5secret[80];
01055 char context[AST_MAX_CONTEXT];
01056 char subscribecontext[AST_MAX_CONTEXT];
01057 char cid_num[80];
01058 char cid_name[80];
01059 char accountcode[AST_MAX_ACCOUNT_CODE];
01060 char language[MAX_LANGUAGE];
01061 char mohinterpret[MAX_MUSICCLASS];
01062 char mohsuggest[MAX_MUSICCLASS];
01063 char useragent[256];
01064 struct ast_codec_pref prefs;
01065 ast_group_t callgroup;
01066 ast_group_t pickupgroup;
01067 unsigned int sipoptions;
01068 struct ast_flags flags[2];
01069 int amaflags;
01070 int callingpres;
01071 int capability;
01072 int inUse;
01073 int call_limit;
01074 enum transfermodes allowtransfer;
01075 struct ast_ha *ha;
01076 struct ast_variable *chanvars;
01077 int maxcallbitrate;
01078 int autoframing;
01079 };
01080
01081
01082
01083 struct sip_peer {
01084 ASTOBJ_COMPONENTS(struct sip_peer);
01085
01086 char secret[80];
01087 char md5secret[80];
01088 struct sip_auth *auth;
01089 char context[AST_MAX_CONTEXT];
01090 char subscribecontext[AST_MAX_CONTEXT];
01091 char username[80];
01092 char accountcode[AST_MAX_ACCOUNT_CODE];
01093 int amaflags;
01094 char tohost[MAXHOSTNAMELEN];
01095 char regexten[AST_MAX_EXTENSION];
01096 char fromuser[80];
01097 char fromdomain[MAXHOSTNAMELEN];
01098 char fullcontact[256];
01099 char cid_num[80];
01100 char cid_name[80];
01101 int callingpres;
01102 int inUse;
01103 int inRinging;
01104 int onHold;
01105 int call_limit;
01106 enum transfermodes allowtransfer;
01107 char vmexten[AST_MAX_EXTENSION];
01108 char mailbox[AST_MAX_EXTENSION];
01109 char language[MAX_LANGUAGE];
01110 char mohinterpret[MAX_MUSICCLASS];
01111 char mohsuggest[MAX_MUSICCLASS];
01112 char useragent[256];
01113 struct ast_codec_pref prefs;
01114 int lastmsgssent;
01115 time_t lastmsgcheck;
01116 unsigned int sipoptions;
01117 struct ast_flags flags[2];
01118 int expire;
01119 int capability;
01120 int rtptimeout;
01121 int rtpholdtimeout;
01122 int rtpkeepalive;
01123 ast_group_t callgroup;
01124 ast_group_t pickupgroup;
01125 struct sockaddr_in addr;
01126 int maxcallbitrate;
01127
01128
01129 struct sip_pvt *call;
01130 int pokeexpire;
01131 int lastms;
01132 int maxms;
01133 struct timeval ps;
01134
01135 struct sockaddr_in defaddr;
01136 struct ast_ha *ha;
01137 struct ast_variable *chanvars;
01138 struct sip_pvt *mwipvt;
01139 int lastmsg;
01140 int autoframing;
01141 int sockfd;
01142 };
01143
01144
01145
01146
01147 struct sip_registry {
01148 ASTOBJ_COMPONENTS_FULL(struct sip_registry,1,1);
01149 AST_DECLARE_STRING_FIELDS(
01150 AST_STRING_FIELD(callid);
01151 AST_STRING_FIELD(realm);
01152 AST_STRING_FIELD(nonce);
01153 AST_STRING_FIELD(opaque);
01154 AST_STRING_FIELD(qop);
01155 AST_STRING_FIELD(domain);
01156 AST_STRING_FIELD(username);
01157 AST_STRING_FIELD(authuser);
01158 AST_STRING_FIELD(hostname);
01159 AST_STRING_FIELD(secret);
01160 AST_STRING_FIELD(md5secret);
01161 AST_STRING_FIELD(contact);
01162 AST_STRING_FIELD(random);
01163 );
01164 int portno;
01165 int expire;
01166 int regattempts;
01167 int timeout;
01168 int refresh;
01169 struct sip_pvt *call;
01170 enum sipregistrystate regstate;
01171 time_t regtime;
01172 int callid_valid;
01173 unsigned int ocseq;
01174 struct sockaddr_in us;
01175 int noncecount;
01176 char lastmsg[256];
01177 };
01178
01179
01180
01181
01182 static struct ast_user_list {
01183 ASTOBJ_CONTAINER_COMPONENTS(struct sip_user);
01184 } userl;
01185
01186
01187 static struct ast_peer_list {
01188 ASTOBJ_CONTAINER_COMPONENTS(struct sip_peer);
01189 } peerl;
01190
01191
01192 static struct ast_register_list {
01193 ASTOBJ_CONTAINER_COMPONENTS(struct sip_registry);
01194 int recheck;
01195 } regl;
01196
01197 static void temp_pvt_cleanup(void *);
01198
01199
01200 AST_THREADSTORAGE_CUSTOM(ts_temp_pvt, temp_pvt_init, temp_pvt_cleanup);
01201
01202 #ifdef LOW_MEMORY
01203 static void ts_ast_rtp_destroy(void *);
01204
01205 AST_THREADSTORAGE_CUSTOM(ts_audio_rtp, ts_audio_rtp_init, ts_ast_rtp_destroy);
01206 AST_THREADSTORAGE_CUSTOM(ts_video_rtp, ts_video_rtp_init, ts_ast_rtp_destroy);
01207 #endif
01208
01209
01210 static struct sip_auth *authl = NULL;
01211
01212
01213
01214 static int sipsock = -1;
01215 static int siptcpsock = -1;
01216 static struct sockaddr_in bindaddr = { 0, };
01217 static struct sockaddr_in externip;
01218 static char externhost[MAXHOSTNAMELEN];
01219 static time_t externexpire = 0;
01220 static int externrefresh = 10;
01221 static struct ast_ha *localaddr;
01222 static struct in_addr __ourip;
01223 static struct sockaddr_in outboundproxyip;
01224 static int ourport;
01225 static struct sockaddr_in debugaddr;
01226
01227 static struct ast_config *notify_types;
01228
01229
01230
01231
01232
01233
01234 static struct ast_channel *sip_request_call(const char *type, int format, void *data, int *cause);
01235 static int sip_devicestate(void *data);
01236 static int sip_sendtext(struct ast_channel *ast, const char *text);
01237 static int sip_call(struct ast_channel *ast, char *dest, int timeout);
01238 static int sip_hangup(struct ast_channel *ast);
01239 static int sip_answer(struct ast_channel *ast);
01240 static struct ast_frame *sip_read(struct ast_channel *ast);
01241 static int sip_write(struct ast_channel *ast, struct ast_frame *frame);
01242 static int sip_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen);
01243 static int sip_transfer(struct ast_channel *ast, const char *dest);
01244 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
01245 static int sip_senddigit_begin(struct ast_channel *ast, char digit);
01246 static int sip_senddigit_end(struct ast_channel *ast, char digit, unsigned int duration);
01247
01248
01249 static int sipsock_read(int *id, int fd, short events, void *ignore);
01250 static int __sip_xmit(struct sip_pvt *p, char *data, int len);
01251 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal, int sipmethod);
01252 static int __transmit_response(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable);
01253 static int retrans_pkt(const void *data);
01254 static int transmit_sip_request(struct sip_pvt *p, struct sip_request *req);
01255 static int transmit_response_using_temp(ast_string_field callid, struct sockaddr_in *sin, int useglobal_nat, const int intended_method, const struct sip_request *req, const char *msg);
01256 static int transmit_response(struct sip_pvt *p, const char *msg, const struct sip_request *req);
01257 static int transmit_response_reliable(struct sip_pvt *p, const char *msg, const struct sip_request *req);
01258 static int transmit_response_with_date(struct sip_pvt *p, const char *msg, const struct sip_request *req);
01259 static int transmit_response_with_sdp(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable);
01260 static int transmit_response_with_unsupported(struct sip_pvt *p, const char *msg, const struct sip_request *req, const char *unsupported);
01261 static int transmit_response_with_auth(struct sip_pvt *p, const char *msg, const struct sip_request *req, const char *rand, enum xmittype reliable, const char *header, int stale);
01262 static int transmit_response_with_allow(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable);
01263 static void transmit_fake_auth_response(struct sip_pvt *p, struct sip_request *req, int reliable);
01264 static int transmit_request(struct sip_pvt *p, int sipmethod, int inc, enum xmittype reliable, int newbranch);
01265 static int transmit_request_with_auth(struct sip_pvt *p, int sipmethod, int seqno, enum xmittype reliable, int newbranch);
01266 static int transmit_invite(struct sip_pvt *p, int sipmethod, int sdp, int init);
01267 static int transmit_reinvite_with_sdp(struct sip_pvt *p);
01268 static int transmit_info_with_digit(struct sip_pvt *p, const char digit, unsigned int duration);
01269 static int transmit_info_with_vidupdate(struct sip_pvt *p);
01270 static int transmit_message_with_text(struct sip_pvt *p, const char *text);
01271 static int transmit_refer(struct sip_pvt *p, const char *dest);
01272 static int transmit_notify_with_mwi(struct sip_pvt *p, int newmsgs, int oldmsgs, char *vmexten);
01273 static int transmit_notify_with_sipfrag(struct sip_pvt *p, int cseq, char *message, int terminate);
01274 static int transmit_register(struct sip_registry *r, int sipmethod, const char *auth, const char *authheader);
01275 static int send_response(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno);
01276 static int send_request(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno);
01277 static void copy_request(struct sip_request *dst, const struct sip_request *src);
01278 static void receive_message(struct sip_pvt *p, struct sip_request *req);
01279 static void parse_moved_contact(struct sip_pvt *p, struct sip_request *req);
01280 static int sip_send_mwi_to_peer(struct sip_peer *peer);
01281 static int does_peer_need_mwi(struct sip_peer *peer);
01282
01283
01284 static struct sip_pvt *sip_alloc(ast_string_field callid, struct sockaddr_in *sin,
01285 int useglobal_nat, const int intended_method);
01286 static int __sip_autodestruct(const void *data);
01287 static void sip_scheddestroy(struct sip_pvt *p, int ms);
01288 static int sip_cancel_destroy(struct sip_pvt *p);
01289 static void sip_destroy(struct sip_pvt *p);
01290 static int __sip_destroy(struct sip_pvt *p, int lockowner);
01291 static void __sip_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod);
01292 static void __sip_pretend_ack(struct sip_pvt *p);
01293 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod);
01294 static int auto_congest(const void *nothing);
01295 static int update_call_counter(struct sip_pvt *fup, int event);
01296 static int hangup_sip2cause(int cause);
01297 static const char *hangup_cause2sip(int cause);
01298 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin, const int intended_method);
01299 static void free_old_route(struct sip_route *route);
01300 static void list_route(struct sip_route *route);
01301 static void build_route(struct sip_pvt *p, struct sip_request *req, int backwards);
01302 static enum check_auth_result register_verify(struct sip_pvt *p, struct sockaddr_in *sin,
01303 struct sip_request *req, char *uri);
01304 static struct sip_pvt *get_sip_pvt_byid_locked(const char *callid, const char *totag, const char *fromtag);
01305 static void check_pendings(struct sip_pvt *p);
01306 static void *sip_park_thread(void *stuff);
01307 static int sip_park(struct ast_channel *chan1, struct ast_channel *chan2, struct sip_request *req, int seqno);
01308 static int sip_sipredirect(struct sip_pvt *p, const char *dest);
01309
01310
01311 static void try_suggested_sip_codec(struct sip_pvt *p);
01312 static const char* get_sdp_iterate(int* start, struct sip_request *req, const char *name);
01313 static const char *get_sdp(struct sip_request *req, const char *name);
01314 static int find_sdp(struct sip_request *req);
01315 static int process_sdp(struct sip_pvt *p, struct sip_request *req);
01316 static void add_codec_to_sdp(const struct sip_pvt *p, int codec, int sample_rate,
01317 char **m_buf, size_t *m_size, char **a_buf, size_t *a_size,
01318 int debug, int *min_packet_size);
01319 static void add_noncodec_to_sdp(const struct sip_pvt *p, int format, int sample_rate,
01320 char **m_buf, size_t *m_size, char **a_buf, size_t *a_size,
01321 int debug);
01322 static enum sip_result add_sdp(struct sip_request *resp, struct sip_pvt *p);
01323 static void stop_media_flows(struct sip_pvt *p);
01324
01325
01326 static int reply_digest(struct sip_pvt *p, struct sip_request *req, char *header, int sipmethod, char *digest, int digest_len);
01327 static int build_reply_digest(struct sip_pvt *p, int method, char *digest, int digest_len);
01328 static enum check_auth_result check_auth(struct sip_pvt *p, struct sip_request *req, const char *username,
01329 const char *secret, const char *md5secret, int sipmethod,
01330 char *uri, enum xmittype reliable, int ignore);
01331 static enum check_auth_result check_user_full(struct sip_pvt *p, struct sip_request *req,
01332 int sipmethod, char *uri, enum xmittype reliable,
01333 struct sockaddr_in *sin, struct sip_peer **authpeer);
01334 static int check_user(struct sip_pvt *p, struct sip_request *req, int sipmethod, char *uri, enum xmittype reliable, struct sockaddr_in *sin);
01335
01336
01337 static int check_sip_domain(const char *domain, char *context, size_t len);
01338 static int add_sip_domain(const char *domain, const enum domain_mode mode, const char *context);
01339 static void clear_sip_domains(void);
01340
01341
01342 static struct sip_auth *add_realm_authentication(struct sip_auth *authlist, char *configuration, int lineno);
01343 static int clear_realm_authentication(struct sip_auth *authlist);
01344 static struct sip_auth *find_realm_authentication(struct sip_auth *authlist, const char *realm);
01345
01346
01347 static int sip_do_reload(enum channelreloadreason reason);
01348 static int reload_config(enum channelreloadreason reason);
01349 static int expire_register(const void *data);
01350 static void *do_monitor(void *data);
01351 static int restart_monitor(void);
01352 static int sip_send_mwi_to_peer(struct sip_peer *peer);
01353 static int sip_addrcmp(char *name, struct sockaddr_in *sin);
01354 static int sip_refer_allocate(struct sip_pvt *p);
01355 static void ast_quiet_chan(struct ast_channel *chan);
01356 static int attempt_transfer(struct sip_dual *transferer, struct sip_dual *target);
01357
01358
01359 static int cb_extensionstate(char *context, char* exten, int state, void *data);
01360 static int sip_devicestate(void *data);
01361 static int sip_poke_noanswer(const void *data);
01362 static int sip_poke_peer(struct sip_peer *peer);
01363 static void sip_poke_all_peers(void);
01364 static void sip_peer_hold(struct sip_pvt *p, int hold);
01365
01366
01367 static const char *sip_nat_mode(const struct sip_pvt *p);
01368 static int sip_show_inuse(int fd, int argc, char *argv[]);
01369 static char *transfermode2str(enum transfermodes mode) attribute_const;
01370 static char *nat2str(int nat) attribute_const;
01371 static int peer_status(struct sip_peer *peer, char *status, int statuslen);
01372 static int sip_show_users(int fd, int argc, char *argv[]);
01373 static int _sip_show_peers(int fd, int *total, struct mansession *s, const struct message *m, int argc, const char *argv[]);
01374 static int sip_show_peers(int fd, int argc, char *argv[]);
01375 static int sip_show_objects(int fd, int argc, char *argv[]);
01376 static void print_group(int fd, ast_group_t group, int crlf);
01377 static const char *dtmfmode2str(int mode) attribute_const;
01378 static const char *insecure2str(int port, int invite) attribute_const;
01379 static void cleanup_stale_contexts(char *new, char *old);
01380 static void print_codec_to_cli(int fd, struct ast_codec_pref *pref);
01381 static const char *domain_mode_to_text(const enum domain_mode mode);
01382 static int sip_show_domains(int fd, int argc, char *argv[]);
01383 static int _sip_show_peer(int type, int fd, struct mansession *s, const struct message *m, int argc, const char *argv[]);
01384 static int sip_show_peer(int fd, int argc, char *argv[]);
01385 static int sip_show_user(int fd, int argc, char *argv[]);
01386 static int sip_show_registry(int fd, int argc, char *argv[]);
01387 static int sip_show_settings(int fd, int argc, char *argv[]);
01388 static const char *subscription_type2str(enum subscriptiontype subtype) attribute_pure;
01389 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype);
01390 static int __sip_show_channels(int fd, int argc, char *argv[], int subscriptions);
01391 static int sip_show_channels(int fd, int argc, char *argv[]);
01392 static int sip_show_subscriptions(int fd, int argc, char *argv[]);
01393 static int __sip_show_channels(int fd, int argc, char *argv[], int subscriptions);
01394 static char *complete_sipch(const char *line, const char *word, int pos, int state);
01395 static char *complete_sip_peer(const char *word, int state, int flags2);
01396 static char *complete_sip_show_peer(const char *line, const char *word, int pos, int state);
01397 static char *complete_sip_debug_peer(const char *line, const char *word, int pos, int state);
01398 static char *complete_sip_user(const char *word, int state, int flags2);
01399 static char *complete_sip_show_user(const char *line, const char *word, int pos, int state);
01400 static char *complete_sipnotify(const char *line, const char *word, int pos, int state);
01401 static char *complete_sip_prune_realtime_peer(const char *line, const char *word, int pos, int state);
01402 static char *complete_sip_prune_realtime_user(const char *line, const char *word, int pos, int state);
01403 static int sip_show_channel(int fd, int argc, char *argv[]);
01404 static int sip_show_history(int fd, int argc, char *argv[]);
01405 static int sip_do_debug_ip(int fd, int argc, char *argv[]);
01406 static int sip_do_debug_peer(int fd, int argc, char *argv[]);
01407 static int sip_do_debug(int fd, int argc, char *argv[]);
01408 static int sip_no_debug(int fd, int argc, char *argv[]);
01409 static int sip_notify(int fd, int argc, char *argv[]);
01410 static int sip_do_history(int fd, int argc, char *argv[]);
01411 static int sip_no_history(int fd, int argc, char *argv[]);
01412 static int func_header_read(struct ast_channel *chan, char *function, char *data, char *buf, size_t len);
01413 static int func_check_sipdomain(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len);
01414 static int function_sippeer(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len);
01415 static int function_sipchaninfo_read(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len);
01416 static int sip_dtmfmode(struct ast_channel *chan, void *data);
01417 static int sip_addheader(struct ast_channel *chan, void *data);
01418 static int sip_do_reload(enum channelreloadreason reason);
01419 static int sip_reload(int fd, int argc, char *argv[]);
01420 static int acf_channel_read(struct ast_channel *chan, char *funcname, char *preparse, char *buf, size_t buflen);
01421
01422
01423
01424
01425
01426 static void sip_dump_history(struct sip_pvt *dialog);
01427 static inline int sip_debug_test_addr(const struct sockaddr_in *addr);
01428 static inline int sip_debug_test_pvt(struct sip_pvt *p);
01429 static void append_history_full(struct sip_pvt *p, const char *fmt, ...);
01430 static void sip_dump_history(struct sip_pvt *dialog);
01431
01432
01433 static struct sip_peer *temp_peer(const char *name);
01434 static struct sip_peer *build_peer(const char *name, struct ast_variable *v, struct ast_variable *alt, int realtime);
01435 static struct sip_user *build_user(const char *name, struct ast_variable *v, struct ast_variable *alt, int realtime);
01436 static int update_call_counter(struct sip_pvt *fup, int event);
01437 static void sip_destroy_peer(struct sip_peer *peer);
01438 static void sip_destroy_user(struct sip_user *user);
01439 static int sip_poke_peer(struct sip_peer *peer);
01440 static int sip_poke_peer_s(const void *data);
01441 static void set_peer_defaults(struct sip_peer *peer);
01442 static struct sip_peer *temp_peer(const char *name);
01443 static void register_peer_exten(struct sip_peer *peer, int onoff);
01444 static struct sip_peer *find_peer(const char *peer, struct sockaddr_in *sin, int realtime, int devstate_only);
01445 static struct sip_user *find_user(const char *name, int realtime);
01446 static enum parse_register_result parse_register_contact(struct sip_pvt *pvt, struct sip_peer *p, struct sip_request *req);
01447 static int expire_register(const void *data);
01448 static void reg_source_db(struct sip_peer *peer);
01449 static void destroy_association(struct sip_peer *peer);
01450 static int handle_common_options(struct ast_flags *flags, struct ast_flags *mask, struct ast_variable *v);
01451
01452
01453 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, const char *username, const char *fullcontact, int expirey);
01454 static struct sip_user *realtime_user(const char *username);
01455 static void update_peer(struct sip_peer *p, int expiry);
01456 static struct sip_peer *realtime_peer(const char *peername, struct sockaddr_in *sin, int devstate_only);
01457 static int sip_prune_realtime(int fd, int argc, char *argv[]);
01458
01459
01460 static int ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us);
01461 static void sip_registry_destroy(struct sip_registry *reg);
01462 static int sip_register(char *value, int lineno);
01463 static char *regstate2str(enum sipregistrystate regstate) attribute_const;
01464 static int sip_reregister(const void *data);
01465 static int __sip_do_register(struct sip_registry *r);
01466 static int sip_reg_timeout(const void *data);
01467 static void sip_send_all_registers(void);
01468
01469
01470 static void append_date(struct sip_request *req);
01471 static int determine_firstline_parts(struct sip_request *req);
01472 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype);
01473 static const char *gettag(const struct sip_request *req, const char *header, char *tagbuf, int tagbufsize);
01474 static void set_insecure_flags(struct ast_flags *flags, const char *value, int lineno);
01475 static int find_sip_method(const char *msg);
01476 static unsigned int parse_sip_options(struct sip_pvt *pvt, const char *supported);
01477 static int parse_request(struct sip_request *req);
01478 static const char *get_header(const struct sip_request *req, const char *name);
01479 static char *referstatus2str(enum referstatus rstatus) attribute_pure;
01480 static int method_match(enum sipmethod id, const char *name);
01481 static void parse_copy(struct sip_request *dst, const struct sip_request *src);
01482 static char *get_in_brackets(char *tmp);
01483 static const char *find_alias(const char *name, const char *_default);
01484 static const char *__get_header(const struct sip_request *req, const char *name, int *start);
01485 static int lws2sws(char *msgbuf, int len);
01486 static void extract_uri(struct sip_pvt *p, struct sip_request *req);
01487 static int get_refer_info(struct sip_pvt *transferer, struct sip_request *outgoing_req);
01488 static int get_also_info(struct sip_pvt *p, struct sip_request *oreq);
01489 static int parse_ok_contact(struct sip_pvt *pvt, struct sip_request *req);
01490 static int set_address_from_contact(struct sip_pvt *pvt);
01491 static void check_via(struct sip_pvt *p, const struct sip_request *req);
01492 static char *get_calleridname(const char *input, char *output, size_t outputsize);
01493 static int get_rpid_num(const char *input, char *output, int maxlen);
01494 static int get_rdnis(struct sip_pvt *p, struct sip_request *oreq);
01495 static int get_destination(struct sip_pvt *p, struct sip_request *oreq);
01496 static int get_msg_text(char *buf, int len, struct sip_request *req);
01497 static void free_old_route(struct sip_route *route);
01498 static int transmit_state_notify(struct sip_pvt *p, int state, int full, int timeout);
01499
01500
01501 static void initialize_initreq(struct sip_pvt *p, struct sip_request *req);
01502 static int init_req(struct sip_request *req, int sipmethod, const char *recip);
01503 static int reqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod, int seqno, int newbranch);
01504 static void initreqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod);
01505 static int init_resp(struct sip_request *resp, const char *msg);
01506 static int respprep(struct sip_request *resp, struct sip_pvt *p, const char *msg, const struct sip_request *req);
01507 static const struct sockaddr_in *sip_real_dst(const struct sip_pvt *p);
01508 static void build_via(struct sip_pvt *p);
01509 static int create_addr_from_peer(struct sip_pvt *r, struct sip_peer *peer);
01510 static int create_addr(struct sip_pvt *dialog, const char *opeer);
01511 static char *generate_random_string(char *buf, size_t size);
01512 static void build_callid_pvt(struct sip_pvt *pvt);
01513 static void build_callid_registry(struct sip_registry *reg, struct in_addr ourip, const char *fromdomain);
01514 static void make_our_tag(char *tagbuf, size_t len);
01515 static int add_header(struct sip_request *req, const char *var, const char *value);
01516 static int add_header_contentLength(struct sip_request *req, int len);
01517 static int add_line(struct sip_request *req, const char *line);
01518 static int add_text(struct sip_request *req, const char *text);
01519 static int add_digit(struct sip_request *req, char digit, unsigned int duration);
01520 static int add_vidupdate(struct sip_request *req);
01521 static void add_route(struct sip_request *req, struct sip_route *route);
01522 static int copy_header(struct sip_request *req, const struct sip_request *orig, const char *field);
01523 static int copy_all_header(struct sip_request *req, const struct sip_request *orig, const char *field);
01524 static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, const struct sip_request *orig, const char *field);
01525 static void set_destination(struct sip_pvt *p, char *uri);
01526 static void append_date(struct sip_request *req);
01527 static void build_contact(struct sip_pvt *p);
01528 static void build_rpid(struct sip_pvt *p);
01529
01530
01531 static int handle_request(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int *recount, int *nounlock);
01532 static int handle_request_invite(struct sip_pvt *p, struct sip_request *req, int debug, int seqno, struct sockaddr_in *sin, int *recount, char *e, int *nounlock);
01533 static int handle_request_refer(struct sip_pvt *p, struct sip_request *req, int debug, int ignore, int seqno, int *nounlock);
01534 static int handle_request_bye(struct sip_pvt *p, struct sip_request *req);
01535 static int handle_request_register(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, char *e);
01536 static int handle_request_cancel(struct sip_pvt *p, struct sip_request *req);
01537 static int handle_request_message(struct sip_pvt *p, struct sip_request *req);
01538 static int handle_request_subscribe(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int seqno, char *e);
01539 static void handle_request_info(struct sip_pvt *p, struct sip_request *req);
01540 static int handle_request_options(struct sip_pvt *p, struct sip_request *req);
01541 static int handle_invite_replaces(struct sip_pvt *p, struct sip_request *req, int debug, int ignore, int seqno, struct sockaddr_in *sin);
01542 static int handle_request_notify(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int seqno, char *e);
01543 static int local_attended_transfer(struct sip_pvt *transferer, struct sip_dual *current, struct sip_request *req, int seqno);
01544
01545
01546 static void handle_response_invite(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int seqno);
01547 static void handle_response_refer(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int seqno);
01548 static int handle_response_register(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int ignore, int seqno);
01549 static void handle_response(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int ignore, int seqno);
01550
01551
01552 static int sip_set_rtp_peer(struct ast_channel *chan, struct ast_rtp *rtp, struct ast_rtp *vrtp, int codecs, int nat_active);
01553 static enum ast_rtp_get_result sip_get_rtp_peer(struct ast_channel *chan, struct ast_rtp **rtp);
01554 static enum ast_rtp_get_result sip_get_vrtp_peer(struct ast_channel *chan, struct ast_rtp **rtp);
01555 static int sip_get_codec(struct ast_channel *chan);
01556 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p, int *faxdetect);
01557
01558
01559 static int sip_handle_t38_reinvite(struct ast_channel *chan, struct sip_pvt *pvt, int reinvite);
01560 static int transmit_response_with_t38_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans);
01561 static int transmit_reinvite_with_t38_sdp(struct sip_pvt *p);
01562 static struct ast_udptl *sip_get_udptl_peer(struct ast_channel *chan);
01563 static int sip_set_udptl_peer(struct ast_channel *chan, struct ast_udptl *udptl);
01564
01565
01566 static const struct ast_channel_tech sip_tech = {
01567 .type = "SIP",
01568 .description = "Session Initiation Protocol (SIP)",
01569 .capabilities = ((AST_FORMAT_MAX_AUDIO << 1) - 1),
01570 .properties = AST_CHAN_TP_WANTSJITTER | AST_CHAN_TP_CREATESJITTER,
01571 .requester = sip_request_call,
01572 .devicestate = sip_devicestate,
01573 .call = sip_call,
01574 .hangup = sip_hangup,
01575 .answer = sip_answer,
01576 .read = sip_read,
01577 .write = sip_write,
01578 .write_video = sip_write,
01579 .indicate = sip_indicate,
01580 .transfer = sip_transfer,
01581 .fixup = sip_fixup,
01582 .send_digit_begin = sip_senddigit_begin,
01583 .send_digit_end = sip_senddigit_end,
01584 .bridge = ast_rtp_bridge,
01585 .send_text = sip_sendtext,
01586 .func_channel_read = acf_channel_read,
01587 };
01588
01589
01590
01591
01592 static const struct ast_channel_tech sip_tech_info = {
01593 .type = "SIP",
01594 .description = "Session Initiation Protocol (SIP)",
01595 .capabilities = ((AST_FORMAT_MAX_AUDIO << 1) - 1),
01596 .properties = AST_CHAN_TP_WANTSJITTER | AST_CHAN_TP_CREATESJITTER,
01597 .requester = sip_request_call,
01598 .devicestate = sip_devicestate,
01599 .call = sip_call,
01600 .hangup = sip_hangup,
01601 .answer = sip_answer,
01602 .read = sip_read,
01603 .write = sip_write,
01604 .write_video = sip_write,
01605 .indicate = sip_indicate,
01606 .transfer = sip_transfer,
01607 .fixup = sip_fixup,
01608 .send_digit_end = sip_senddigit_end,
01609 .bridge = ast_rtp_bridge,
01610 .send_text = sip_sendtext,
01611 .func_channel_read = acf_channel_read,
01612 };
01613
01614
01615
01616 #define UNLINK(element, head, prev) do { \
01617 if (prev) \
01618 (prev)->next = (element)->next; \
01619 else \
01620 (head) = (element)->next; \
01621 } while (0)
01622
01623
01624 static struct ast_rtp_protocol sip_rtp = {
01625 type: "SIP",
01626 get_rtp_info: sip_get_rtp_peer,
01627 get_vrtp_info: sip_get_vrtp_peer,
01628 set_rtp_peer: sip_set_rtp_peer,
01629 get_codec: sip_get_codec,
01630 };
01631
01632
01633 static struct ast_udptl_protocol sip_udptl = {
01634 type: "SIP",
01635 get_udptl_info: sip_get_udptl_peer,
01636 set_udptl_peer: sip_set_udptl_peer,
01637 };
01638
01639
01640 static char *referstatus2str(enum referstatus rstatus)
01641 {
01642 int i = (sizeof(referstatusstrings) / sizeof(referstatusstrings[0]));
01643 int x;
01644
01645 for (x = 0; x < i; x++) {
01646 if (referstatusstrings[x].status == rstatus)
01647 return (char *) referstatusstrings[x].text;
01648 }
01649 return "";
01650 }
01651
01652
01653
01654
01655 static void initialize_initreq(struct sip_pvt *p, struct sip_request *req)
01656 {
01657 if (p->initreq.headers && option_debug) {
01658 ast_log(LOG_DEBUG, "Initializing already initialized SIP dialog %s (presumably reinvite)\n", p->callid);
01659 }
01660
01661 copy_request(&p->initreq, req);
01662 parse_request(&p->initreq);
01663 if (ast_test_flag(req, SIP_PKT_DEBUG))
01664 ast_verbose("%d headers, %d lines\n", p->initreq.headers, p->initreq.lines);
01665 }
01666
01667 static void sip_alreadygone(struct sip_pvt *dialog)
01668 {
01669 if (option_debug > 2)
01670 ast_log(LOG_DEBUG, "Setting SIP_ALREADYGONE on dialog %s\n", dialog->callid);
01671 ast_set_flag(&dialog->flags[0], SIP_ALREADYGONE);
01672 }
01673
01674
01675
01676
01677
01678
01679
01680
01681 static int method_match(enum sipmethod id, const char *name)
01682 {
01683 int len = strlen(sip_methods[id].text);
01684 int l_name = name ? strlen(name) : 0;
01685
01686 return (l_name >= len && name[len] < 33 &&
01687 !strncasecmp(sip_methods[id].text, name, len));
01688 }
01689
01690
01691 static int find_sip_method(const char *msg)
01692 {
01693 int i, res = 0;
01694
01695 if (ast_strlen_zero(msg))
01696 return 0;
01697 for (i = 1; i < (sizeof(sip_methods) / sizeof(sip_methods[0])) && !res; i++) {
01698 if (method_match(i, msg))
01699 res = sip_methods[i].id;
01700 }
01701 return res;
01702 }
01703
01704
01705 static unsigned int parse_sip_options(struct sip_pvt *pvt, const char *supported)
01706 {
01707 char *next, *sep;
01708 char *temp;
01709 unsigned int profile = 0;
01710 int i, found;
01711
01712 if (ast_strlen_zero(supported) )
01713 return 0;
01714 temp = ast_strdupa(supported);
01715
01716 if (option_debug > 2 && sipdebug)
01717 ast_log(LOG_DEBUG, "Begin: parsing SIP \"Supported: %s\"\n", supported);
01718
01719 for (next = temp; next; next = sep) {
01720 found = FALSE;
01721 if ( (sep = strchr(next, ',')) != NULL)
01722 *sep++ = '\0';
01723 next = ast_skip_blanks(next);
01724 if (option_debug > 2 && sipdebug)
01725 ast_log(LOG_DEBUG, "Found SIP option: -%s-\n", next);
01726 for (i=0; i < (sizeof(sip_options) / sizeof(sip_options[0])); i++) {
01727 if (!strcasecmp(next, sip_options[i].text)) {
01728 profile |= sip_options[i].id;
01729 found = TRUE;
01730 if (option_debug > 2 && sipdebug)
01731 ast_log(LOG_DEBUG, "Matched SIP option: %s\n", next);
01732 break;
01733 }
01734 }
01735 if (!found && option_debug > 2 && sipdebug) {
01736 if (!strncasecmp(next, "x-", 2))
01737 ast_log(LOG_DEBUG, "Found private SIP option, not supported: %s\n", next);
01738 else
01739 ast_log(LOG_DEBUG, "Found no match for SIP option: %s (Please file bug report!)\n", next);
01740 }
01741 }
01742
01743 if (pvt)
01744 pvt->sipoptions = profile;
01745 return profile;
01746 }
01747
01748
01749 static inline int sip_debug_test_addr(const struct sockaddr_in *addr)
01750 {
01751 if (!sipdebug)
01752 return 0;
01753 if (debugaddr.sin_addr.s_addr) {
01754 if (((ntohs(debugaddr.sin_port) != 0)
01755 && (debugaddr.sin_port != addr->sin_port))
01756 || (debugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
01757 return 0;
01758 }
01759 return 1;
01760 }
01761
01762
01763 static const struct sockaddr_in *sip_real_dst(const struct sip_pvt *p)
01764 {
01765 return ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE ? &p->recv : &p->sa;
01766 }
01767
01768
01769 static const char *sip_nat_mode(const struct sip_pvt *p)
01770 {
01771 return ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE ? "NAT" : "no NAT";
01772 }
01773
01774
01775 static inline int sip_debug_test_pvt(struct sip_pvt *p)
01776 {
01777 if (!sipdebug)
01778 return 0;
01779 return sip_debug_test_addr(sip_real_dst(p));
01780 }
01781
01782
01783 static int __sip_xmit(struct sip_pvt *p, char *data, int len)
01784 {
01785 int res;
01786 const struct sockaddr_in *dst = sip_real_dst(p);
01787
01788 if (ast_test_flag(&p->flags[1], SIP_PAGE2_TCP)) {
01789 if (!ast_test_flag(&p->flags[1], SIP_PAGE2_TCP_CONNECTED)) {
01790 if (connect(p->sockfd, (const struct sockaddr *)dst, sizeof(struct sockaddr_in)) == 0) {
01791 ast_set_flag(&p->flags[1], SIP_PAGE2_TCP_CONNECTED);
01792 } else if (errno == EISCONN) {
01793 ast_set_flag(&p->flags[1], SIP_PAGE2_TCP_CONNECTED);
01794 } else {
01795 ast_log(LOG_ERROR, "Connect Failed Sock: %i %s:%d %s\n",p->sockfd,ast_inet_ntoa(dst->sin_addr), ntohs(dst->sin_port), strerror(errno));
01796 }
01797 }
01798 res = write(p->sockfd, data, len);
01799 } else
01800 res = sendto(sipsock, data, len, 0, (const struct sockaddr *)dst, sizeof(struct sockaddr_in));
01801
01802 if (res == -1) {
01803 switch (errno) {
01804 case EBADF:
01805 case EHOSTUNREACH:
01806 case ENETDOWN:
01807 case ENETUNREACH:
01808 case ECONNREFUSED:
01809 res = XMIT_ERROR;
01810 }
01811 }
01812 if (res != len)
01813 ast_log(LOG_WARNING, "sip_xmit of %p (len %d) to %s:%d returned %d: %s\n", data, len, ast_inet_ntoa(dst->sin_addr), ntohs(dst->sin_port), res, strerror(errno));
01814 return res;
01815 }
01816
01817
01818
01819 static void build_via(struct sip_pvt *p)
01820 {
01821
01822 const char *rport = ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_RFC3581 ? ";rport" : "";
01823
01824
01825 ast_string_field_build(p, via, "SIP/2.0/%s %s:%d;branch=z9hG4bK%08x%s",
01826 ast_test_flag(&p->flags[1], SIP_PAGE2_TCP) ? "TCP" : "UDP", ast_inet_ntoa(p->ourip), ourport, p->branch, rport);
01827 }
01828
01829
01830
01831
01832
01833
01834
01835 static enum sip_result ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us)
01836 {
01837 struct sockaddr_in theirs, ours;
01838
01839
01840 ast_ouraddrfor(them, us);
01841 theirs.sin_addr = *them;
01842 ours.sin_addr = *us;
01843
01844 if (localaddr && externip.sin_addr.s_addr &&
01845 (ast_apply_ha(localaddr, &theirs)) &&
01846 (!global_matchexterniplocally || !ast_apply_ha(localaddr, &ours))) {
01847 if (externexpire && time(NULL) >= externexpire) {
01848 struct ast_hostent ahp;
01849 struct hostent *hp;
01850
01851 externexpire = time(NULL) + externrefresh;
01852 if ((hp = ast_gethostbyname(externhost, &ahp))) {
01853 memcpy(&externip.sin_addr, hp->h_addr, sizeof(externip.sin_addr));
01854 } else
01855 ast_log(LOG_NOTICE, "Warning: Re-lookup of '%s' failed!\n", externhost);
01856 }
01857 *us = externip.sin_addr;
01858 if (option_debug) {
01859 ast_log(LOG_DEBUG, "Target address %s is not local, substituting externip\n",
01860 ast_inet_ntoa(*(struct in_addr *)&them->s_addr));
01861 }
01862 } else if (bindaddr.sin_addr.s_addr)
01863 *us = bindaddr.sin_addr;
01864 return AST_SUCCESS;
01865 }
01866
01867
01868
01869 #define append_history(p, event, fmt , args... ) append_history_full(p, "%-15s " fmt, event, ## args)
01870
01871 static void append_history_full(struct sip_pvt *p, const char *fmt, ...)
01872 __attribute__ ((format (printf, 2, 3)));
01873
01874
01875 static void append_history_va(struct sip_pvt *p, const char *fmt, va_list ap)
01876 {
01877 char buf[80], *c = buf;
01878 struct sip_history *hist;
01879 int l;
01880
01881 vsnprintf(buf, sizeof(buf), fmt, ap);
01882 strsep(&c, "\r\n");
01883 l = strlen(buf) + 1;
01884 if (!(hist = ast_calloc(1, sizeof(*hist) + l)))
01885 return;
01886 if (!p->history && !(p->history = ast_calloc(1, sizeof(*p->history)))) {
01887 free(hist);
01888 return;
01889 }
01890 memcpy(hist->event, buf, l);
01891 if (p->history_entries == MAX_HISTORY_ENTRIES) {
01892 struct sip_history *oldest;
01893 oldest = AST_LIST_REMOVE_HEAD(p->history, list);
01894 p->history_entries--;
01895 free(oldest);
01896 }
01897 AST_LIST_INSERT_TAIL(p->history, hist, list);
01898 p->history_entries++;
01899 }
01900
01901
01902 static void append_history_full(struct sip_pvt *p, const char *fmt, ...)
01903 {
01904 va_list ap;
01905
01906 if (!p)
01907 return;
01908
01909 if (ast_test_flag(&p->flags[0], SIP_NO_HISTORY)
01910 && !recordhistory && !dumphistory) {
01911 return;
01912 }
01913
01914 va_start(ap, fmt);
01915 append_history_va(p, fmt, ap);
01916 va_end(ap);
01917
01918 return;
01919 }
01920
01921
01922 static int retrans_pkt(const void *data)
01923 {
01924 struct sip_pkt *pkt = (struct sip_pkt *)data, *prev, *cur = NULL;
01925 int reschedule = DEFAULT_RETRANS;
01926 int xmitres = 0;
01927
01928
01929 ast_mutex_lock(&pkt->owner->lock);
01930
01931 if (pkt->retrans < MAX_RETRANS) {
01932 pkt->retrans++;
01933 if (!pkt->timer_t1) {
01934 if (sipdebug && option_debug > 3)
01935 ast_log(LOG_DEBUG, "SIP TIMER: Not rescheduling id #%d:%s (Method %d) (No timer T1)\n", pkt->retransid, sip_methods[pkt->method].text, pkt->method);
01936 } else {
01937 int siptimer_a;
01938
01939 if (sipdebug && option_debug > 3)
01940 ast_log(LOG_DEBUG, "SIP TIMER: Rescheduling retransmission #%d (%d) %s - %d\n", pkt->retransid, pkt->retrans, sip_methods[pkt->method].text, pkt->method);
01941 if (!pkt->timer_a)
01942 pkt->timer_a = 2 ;
01943 else
01944 pkt->timer_a = 2 * pkt->timer_a;
01945
01946
01947 siptimer_a = pkt->timer_t1 * pkt->timer_a;
01948 if (pkt->method != SIP_INVITE && siptimer_a > 4000)
01949 siptimer_a = 4000;
01950
01951
01952 reschedule = siptimer_a;
01953 if (option_debug > 3)
01954 ast_log(LOG_DEBUG, "** SIP timers: Rescheduling retransmission %d to %d ms (t1 %d ms (Retrans id #%d)) \n", pkt->retrans +1, siptimer_a, pkt->timer_t1, pkt->retransid);
01955 }
01956
01957 if (sip_debug_test_pvt(pkt->owner)) {
01958 const struct sockaddr_in *dst = sip_real_dst(pkt->owner);
01959 ast_verbose("Retransmitting #%d (%s) to %s:%d:\n%s\n---\n",
01960 pkt->retrans, sip_nat_mode(pkt->owner),
01961 ast_inet_ntoa(dst->sin_addr),
01962 ntohs(dst->sin_port), pkt->data);
01963 }
01964
01965 append_history(pkt->owner, "ReTx", "%d %s", reschedule, pkt->data);
01966 xmitres = __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
01967 ast_mutex_unlock(&pkt->owner->lock);
01968 if (xmitres == XMIT_ERROR)
01969 ast_log(LOG_WARNING, "Network error on retransmit in dialog %s\n", pkt->owner->callid);
01970 else
01971 return reschedule;
01972 }
01973
01974 if (pkt->owner && pkt->method != SIP_OPTIONS && xmitres == 0) {
01975 if (ast_test_flag(pkt, FLAG_FATAL) || sipdebug)
01976 ast_log(LOG_WARNING, "Maximum retries exceeded on transmission %s from %s for packet seqno %d (%s %s %s)\n", pkt->owner->callid, pkt->owner->from, pkt->seqno, (ast_test_flag(pkt, FLAG_FATAL)) ? "Critical" : "Non-critical", (ast_test_flag(pkt, FLAG_RESPONSE)) ? "Response: " : "Request: ", sip_methods[pkt->method].text);
01977 } else if ((pkt->method == SIP_OPTIONS) && sipdebug) {
01978 ast_log(LOG_WARNING, "Cancelling retransmit of OPTIONs (call id %s) -- See doc/sip-retransmit.txt.\n", pkt->owner->callid);
01979 }
01980 if (xmitres == XMIT_ERROR) {
01981 ast_log(LOG_WARNING, "Transmit error :: Cancelling transmission of transaction in call id %s \n", pkt->owner->callid);
01982 append_history(pkt->owner, "XmitErr", "%s", (ast_test_flag(pkt, FLAG_FATAL)) ? "(Critical)" : "(Non-critical)");
01983 } else
01984 append_history(pkt->owner, "MaxRetries", "%s", (ast_test_flag(pkt, FLAG_FATAL)) ? "(Critical)" : "(Non-critical)");
01985
01986 pkt->retransid = -1;
01987
01988 if (ast_test_flag(pkt, FLAG_FATAL)) {
01989 while(pkt->owner->owner && ast_channel_trylock(pkt->owner->owner)) {
01990 DEADLOCK_AVOIDANCE(&pkt->owner->lock);
01991 }
01992
01993 if (pkt->owner->owner && !pkt->owner->owner->hangupcause)
01994 pkt->owner->owner->hangupcause = AST_CAUSE_NO_USER_RESPONSE;
01995
01996 if (pkt->owner->owner) {
01997 sip_alreadygone(pkt->owner);
01998 ast_log(LOG_WARNING, "Hanging up call %s from channel %s . No reply to our critical packet after %d retries (see doc/sip-retransmit.txt).\n", pkt->owner->callid, pkt->owner->owner->name, pkt->retrans);
01999 ast_queue_hangup(pkt->owner->owner);
02000 ast_channel_unlock(pkt->owner->owner);
02001 } else {
02002
02003
02004
02005 if (pkt->method != SIP_OPTIONS) {
02006 ast_set_flag(&pkt->owner->flags[0], SIP_NEEDDESTROY);
02007 sip_alreadygone(pkt->owner);
02008 if (option_debug)
02009 append_history(pkt->owner, "DialogKill", "Killing this failed dialog immediately");
02010 }
02011 }
02012 }
02013
02014 if (pkt->method == SIP_BYE) {
02015
02016 if (pkt->owner->owner)
02017 ast_channel_unlock(pkt->owner->owner);
02018 append_history(pkt->owner, "ByeFailure", "Remote peer doesn't respond to bye. Destroying call anyway.");
02019 ast_set_flag(&pkt->owner->flags[0], SIP_NEEDDESTROY);
02020 }
02021
02022
02023 for (prev = NULL, cur = pkt->owner->packets; cur; prev = cur, cur = cur->next) {
02024 if (cur == pkt)
02025 break;
02026 }
02027 if (cur) {
02028 if (prev)
02029 prev->next = cur->next;
02030 else
02031 pkt->owner->packets = cur->next;
02032 ast_mutex_unlock(&pkt->owner->lock);
02033 free(cur);
02034 pkt = NULL;
02035 } else
02036 ast_log(LOG_WARNING, "Weird, couldn't find packet owner!\n");
02037 if (pkt)
02038 ast_mutex_unlock(&pkt->owner->lock);
02039 return 0;
02040 }
02041
02042
02043
02044
02045 static enum sip_result __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal, int sipmethod)
02046 {
02047 struct sip_pkt *pkt;
02048 int siptimer_a = DEFAULT_RETRANS;
02049 int xmitres = 0;
02050
02051 if (!(pkt = ast_calloc(1, sizeof(*pkt) + len + 1)))
02052 return AST_FAILURE;
02053 memcpy(pkt->data, data, len);
02054 pkt->method = sipmethod;
02055 pkt->packetlen = len;
02056 pkt->next = p->packets;
02057 pkt->owner = p;
02058 pkt->seqno = seqno;
02059 if (resp)
02060 ast_set_flag(pkt, FLAG_RESPONSE);
02061 pkt->data[len] = '\0';
02062 pkt->timer_t1 = p->timer_t1;
02063 pkt->retransid = -1;
02064 if (fatal)
02065 ast_set_flag(pkt, FLAG_FATAL);
02066 if (pkt->timer_t1)
02067 siptimer_a = pkt->timer_t1 * 2;
02068
02069 if (option_debug > 3 && sipdebug)
02070 ast_log(LOG_DEBUG, "*** SIP TIMER: Initializing retransmit timer on packet: Id #%d\n", pkt->retransid);
02071 pkt->retransid = -1;
02072 pkt->next = p->packets;
02073 p->packets = pkt;
02074 if (sipmethod == SIP_INVITE) {
02075
02076 p->pendinginvite = seqno;
02077 }
02078
02079 xmitres = __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
02080
02081 if (xmitres == XMIT_ERROR) {
02082 append_history(pkt->owner, "XmitErr", "%s", (ast_test_flag(pkt, FLAG_FATAL)) ? "(Critical)" : "(Non-critical)");
02083 return AST_FAILURE;
02084 } else {
02085
02086 pkt->retransid = ast_sched_add_variable(sched, siptimer_a, retrans_pkt, pkt, 1);
02087 return AST_SUCCESS;
02088 }
02089 }
02090
02091
02092 static int __sip_autodestruct(const void *data)
02093 {
02094 struct sip_pvt *p = (struct sip_pvt *)data;
02095
02096
02097 if (p->subscribed) {
02098 transmit_state_notify(p, AST_EXTENSION_DEACTIVATED, 1, TRUE);
02099 p->subscribed = NONE;
02100 append_history(p, "Subscribestatus", "timeout");
02101 if (option_debug > 2)
02102 ast_log(LOG_DEBUG, "Re-scheduled destruction of SIP subsription %s\n", p->callid ? p->callid : "<unknown>");
02103 return 10000;
02104 }
02105
02106
02107 if (p->packets) {
02108 if (option_debug > 2)
02109 ast_log(LOG_DEBUG, "Re-scheduled destruction of SIP call %s\n", p->callid ? p->callid : "<unknown>");
02110 append_history(p, "ReliableXmit", "timeout");
02111 return 10000;
02112 }
02113
02114
02115 if (p->subscribed == MWI_NOTIFICATION && p->relatedpeer)
02116 ASTOBJ_UNREF(p->relatedpeer,sip_destroy_peer);
02117
02118
02119 p->autokillid = -1;
02120
02121 if (option_debug)
02122 ast_log(LOG_DEBUG, "Auto destroying SIP dialog '%s'\n", p->callid);
02123 append_history(p, "AutoDestroy", "%s", p->callid);
02124 if (p->owner) {
02125 ast_log(LOG_WARNING, "Autodestruct on dialog '%s' with owner in place (Method: %s)\n", p->callid, sip_methods[p->method].text);
02126 ast_queue_hangup(p->owner);
02127 } else if (p->refer && !ast_test_flag(&p->flags[0], SIP_ALREADYGONE)) {
02128 if (option_debug > 2)
02129 ast_log(LOG_DEBUG, "Finally hanging up channel after transfer: %s\n", p->callid);
02130 transmit_request_with_auth(p, SIP_BYE, 0, XMIT_RELIABLE, 1);
02131 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
02132 } else
02133 sip_destroy(p);
02134 return 0;
02135 }
02136
02137
02138 static void sip_scheddestroy(struct sip_pvt *p, int ms)
02139 {
02140 if (ms < 0) {
02141 if (p->timer_t1 == 0)
02142 p->timer_t1 = 500;
02143 ms = p->timer_t1 * 64;
02144 }
02145 if (sip_debug_test_pvt(p))
02146 ast_verbose("Scheduling destruction of SIP dialog '%s' in %d ms (Method: %s)\n", p->callid, ms, sip_methods[p->method].text);
02147 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
02148 append_history(p, "SchedDestroy", "%d ms", ms);
02149
02150 AST_SCHED_DEL(sched, p->autokillid);
02151 p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, p);
02152 }
02153
02154
02155 static int sip_cancel_destroy(struct sip_pvt *p)
02156 {
02157 int res = 0;
02158 if (p->autokillid > -1) {
02159 if (!(res = ast_sched_del(sched, p->autokillid))) {
02160 append_history(p, "CancelDestroy", "");
02161 p->autokillid = -1;
02162 }
02163 }
02164 return res;
02165 }
02166
02167
02168
02169 static void __sip_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
02170 {
02171 struct sip_pkt *cur, *prev = NULL;
02172
02173
02174 char *msg;
02175 int res = FALSE;
02176
02177 msg = sip_methods[sipmethod].text;
02178
02179 for (cur = p->packets; cur; prev = cur, cur = cur->next) {
02180 if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
02181 ((ast_test_flag(cur, FLAG_RESPONSE)) ||
02182 (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
02183 if (!resp && (seqno == p->pendinginvite)) {
02184 if (option_debug)
02185 ast_log(LOG_DEBUG, "Acked pending invite %d\n", p->pendinginvite);
02186 p->pendinginvite = 0;
02187 }
02188
02189 res = TRUE;
02190 UNLINK(cur, p->packets, prev);
02191 if (cur->retransid > -1) {
02192 if (sipdebug && option_debug > 3)
02193 ast_log(LOG_DEBUG, "** SIP TIMER: Cancelling retransmit of packet (reply received) Retransid #%d\n", cur->retransid);
02194 }
02195
02196
02197
02198
02199
02200
02201
02202
02203
02204
02205
02206
02207
02208
02209
02210
02211 while (cur->retransid > -1 && ast_sched_del(sched, cur->retransid)) {
02212 DEADLOCK_AVOIDANCE(&p->lock);
02213 }
02214 free(cur);
02215 break;
02216 }
02217 }
02218 if (option_debug)
02219 ast_log(LOG_DEBUG, "Stopping retransmission on '%s' of %s %d: Match %s\n", p->callid, resp ? "Response" : "Request", seqno, res == FALSE ? "Not Found" : "Found");
02220 }
02221
02222
02223
02224 static void __sip_pretend_ack(struct sip_pvt *p)
02225 {
02226 struct sip_pkt *cur = NULL;
02227
02228 while (p->packets) {
02229 int method;
02230 if (cur == p->packets) {
02231 ast_log(LOG_WARNING, "Have a packet that doesn't want to give up! %s\n", sip_methods[cur->method].text);
02232 return;
02233 }
02234 cur = p->packets;
02235 method = (cur->method) ? cur->method : find_sip_method(cur->data);
02236 __sip_ack(p, cur->seqno, ast_test_flag(cur, FLAG_RESPONSE), method);
02237 }
02238 }
02239
02240
02241 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
02242 {
02243 struct sip_pkt *cur;
02244 int res = -1;
02245
02246 for (cur = p->packets; cur; cur = cur->next) {
02247 if (cur->seqno == seqno && ast_test_flag(cur, FLAG_RESPONSE) == resp &&
02248 (ast_test_flag(cur, FLAG_RESPONSE) || method_match(sipmethod, cur->data))) {
02249
02250 if (cur->retransid > -1) {
02251 if (option_debug > 3 && sipdebug)
02252 ast_log(LOG_DEBUG, "*** SIP TIMER: Cancelling retransmission #%d - %s (got response)\n", cur->retransid, sip_methods[sipmethod].text);
02253 }
02254 AST_SCHED_DEL(sched, cur->retransid);
02255 res = 0;
02256 break;
02257 }
02258 }
02259 if (option_debug)
02260 ast_log(LOG_DEBUG, "(Provisional) Stopping retransmission (but retaining packet) on '%s' %s %d: %s\n", p->callid, resp ? "Response" : "Request", seqno, res == -1 ? "Not Found" : "Found");
02261 return res;
02262 }
02263
02264
02265
02266 static void parse_copy(struct sip_request *dst, const struct sip_request *src)
02267 {
02268 memset(dst, 0, sizeof(*dst));
02269 memcpy(dst->data, src->data, sizeof(dst->data));
02270 dst->len = src->len;
02271 parse_request(dst);
02272 }
02273
02274
02275 static void add_blank(struct sip_request *req)
02276 {
02277 if (!req->lines) {
02278
02279 snprintf(req->data + req->len, sizeof(req->data) - req->len, "\r\n");
02280 req->len += strlen(req->data + req->len);
02281 }
02282 }
02283
02284
02285 static int send_response(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno)
02286 {
02287 int res;
02288
02289 add_blank(req);
02290 if (sip_debug_test_pvt(p)) {
02291 const struct sockaddr_in *dst = sip_real_dst(p);
02292
02293 ast_verbose("\n<--- %sTransmitting (%s) to %s:%d --->\n%s\n<------------>\n",
02294 reliable ? "Reliably " : "", sip_nat_mode(p),
02295 ast_inet_ntoa(dst->sin_addr),
02296 ntohs(dst->sin_port), req->data);
02297 }
02298 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY)) {
02299 struct sip_request tmp;
02300 parse_copy(&tmp, req);
02301 append_history(p, reliable ? "TxRespRel" : "TxResp", "%s / %s - %s", tmp.data, get_header(&tmp, "CSeq"),
02302 (tmp.method == SIP_RESPONSE || tmp.method == SIP_UNKNOWN) ? tmp.rlPart2 : sip_methods[tmp.method].text);
02303 }
02304 res = (reliable) ?
02305 __sip_reliable_xmit(p, seqno, 1, req->data, req->len, (reliable == XMIT_CRITICAL), req->method) :
02306 __sip_xmit(p, req->data, req->len);
02307 if (res > 0)
02308 return 0;
02309 return res;
02310 }
02311
02312
02313 static int send_request(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno)
02314 {
02315 int res;
02316
02317 add_blank(req);
02318 if (sip_debug_test_pvt(p)) {
02319 if (ast_test_flag(&p->flags[0], SIP_NAT_ROUTE))
02320 ast_verbose("%sTransmitting (NAT) to %s:%d:\n%s\n---\n", reliable ? "Reliably " : "", ast_inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port), req->data);
02321 else
02322 ast_verbose("%sTransmitting (no NAT) to %s:%d:\n%s\n---\n", reliable ? "Reliably " : "", ast_inet_ntoa(p->sa.sin_addr), ntohs(p->sa.sin_port), req->data);
02323 }
02324 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY)) {
02325 struct sip_request tmp;
02326 parse_copy(&tmp, req);
02327 append_history(p, reliable ? "TxReqRel" : "TxReq", "%s / %s - %s", tmp.data, get_header(&tmp, "CSeq"), sip_methods[tmp.method].text);
02328 }
02329 res = (reliable) ?
02330 __sip_reliable_xmit(p, seqno, 0, req->data, req->len, (reliable == XMIT_CRITICAL), req->method) :
02331 __sip_xmit(p, req->data, req->len);
02332 return res;
02333 }
02334
02335
02336
02337
02338
02339 static const char *find_closing_quote(const char *start, const char *lim)
02340 {
02341 char last_char = '\0';
02342 const char *s;
02343 for (s = start; *s && s != lim; last_char = *s++) {
02344 if (*s == '"' && last_char != '\\')
02345 break;
02346 }
02347 return s;
02348 }
02349
02350
02351
02352
02353
02354
02355
02356
02357
02358
02359
02360
02361 static char *get_in_brackets(char *tmp)
02362 {
02363 const char *parse = tmp;
02364 char *first_bracket;
02365
02366
02367
02368
02369
02370 while ( (first_bracket = strchr(parse, '<')) ) {
02371 char *first_quote = strchr(parse, '"');
02372
02373 if (!first_quote || first_quote > first_bracket)
02374 break;
02375
02376 parse = find_closing_quote(first_quote + 1, NULL);
02377 if (!*parse) {
02378
02379 ast_log(LOG_WARNING, "No closing quote found in '%s'\n", tmp);
02380 break;
02381 }
02382 parse++;
02383 }
02384 if (first_bracket) {
02385 char *second_bracket = strchr(first_bracket + 1, '>');
02386 if (second_bracket) {
02387 *second_bracket = '\0';
02388 tmp = first_bracket + 1;
02389 } else {
02390 ast_log(LOG_WARNING, "No closing bracket found in '%s'\n", tmp);
02391 }
02392 }
02393 return tmp;
02394 }
02395
02396
02397
02398 static int sip_sendtext(struct ast_channel *ast, const char *text)
02399 {
02400 struct sip_pvt *p = ast->tech_pvt;
02401 int debug = sip_debug_test_pvt(p);
02402
02403 if (debug)
02404 ast_verbose("Sending text %s on %s\n", text, ast->name);
02405 if (!p)
02406 return -1;
02407 if (ast_strlen_zero(text))
02408 return 0;
02409 if (debug)
02410 ast_verbose("Really sending text %s on %s\n", text, ast->name);
02411 transmit_message_with_text(p, text);
02412 return 0;
02413 }
02414
02415
02416
02417
02418
02419
02420 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, const char *username, const char *fullcontact, int expirey)
02421 {
02422 char port[10];
02423 char ipaddr[INET_ADDRSTRLEN];
02424 char regseconds[20];
02425
02426 char *sysname = ast_config_AST_SYSTEM_NAME;
02427 char *syslabel = NULL;
02428
02429 time_t nowtime = time(NULL) + expirey;
02430 const char *fc = fullcontact ? "fullcontact" : NULL;
02431
02432 snprintf(regseconds, sizeof(regseconds), "%d", (int)nowtime);
02433 ast_copy_string(ipaddr, ast_inet_ntoa(sin->sin_addr), sizeof(ipaddr));
02434 snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
02435
02436 if (ast_strlen_zero(sysname))
02437 sysname = NULL;
02438 else if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTSAVE_SYSNAME))
02439 syslabel = "regserver";
02440
02441 if (fc)
02442 ast_update_realtime("sippeers", "name", peername, "ipaddr", ipaddr,
02443 "port", port, "regseconds", regseconds,
02444 "username", username, fc, fullcontact, syslabel, sysname, NULL);
02445 else
02446 ast_update_realtime("sippeers", "name", peername, "ipaddr", ipaddr,
02447 "port", port, "regseconds", regseconds,
02448 "username", username, syslabel, sysname, NULL);
02449 }
02450
02451
02452 static void register_peer_exten(struct sip_peer *peer, int onoff)
02453 {
02454 char multi[256];
02455 char *stringp, *ext, *context;
02456
02457
02458
02459
02460
02461 if (ast_strlen_zero(global_regcontext))
02462 return;
02463
02464 ast_copy_string(multi, S_OR(peer->regexten, peer->name), sizeof(multi));
02465 stringp = multi;
02466 while ((ext = strsep(&stringp, "&"))) {
02467 if ((context = strchr(ext, '@'))) {
02468 *context++ = '\0';
02469 if (!ast_context_find(context)) {
02470 ast_log(LOG_WARNING, "Context %s must exist in regcontext= in sip.conf!\n", context);
02471 continue;
02472 }
02473 } else {
02474 context = global_regcontext;
02475 }
02476 if (onoff)
02477 ast_add_extension(context, 1, ext, 1, NULL, NULL, "Noop",
02478 ast_strdup(peer->name), ast_free, "SIP");
02479 else
02480 ast_context_remove_extension(context, ext, 1, NULL);
02481 }
02482 }
02483
02484
02485 static void sip_destroy_peer(struct sip_peer *peer)
02486 {
02487 if (option_debug > 2)
02488 ast_log(LOG_DEBUG, "Destroying SIP peer %s\n", peer->name);
02489
02490
02491 if (peer->call)
02492 sip_destroy(peer->call);
02493
02494 if (peer->mwipvt)
02495 sip_destroy(peer->mwipvt);
02496
02497 if (peer->chanvars) {
02498 ast_variables_destroy(peer->chanvars);
02499 peer->chanvars = NULL;
02500 }
02501
02502 register_peer_exten(peer, FALSE);
02503 ast_free_ha(peer->ha);
02504 if (ast_test_flag(&peer->flags[1], SIP_PAGE2_SELFDESTRUCT))
02505 apeerobjs--;
02506 else if (ast_test_flag(&peer->flags[0], SIP_REALTIME))
02507 rpeerobjs--;
02508 else
02509 speerobjs--;
02510 clear_realm_authentication(peer->auth);
02511 peer->auth = NULL;
02512 free(peer);
02513 }
02514
02515
02516 static void update_peer(struct sip_peer *p, int expiry)
02517 {
02518 int rtcachefriends = ast_test_flag(&p->flags[1], SIP_PAGE2_RTCACHEFRIENDS);
02519 if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTUPDATE) &&
02520 (ast_test_flag(&p->flags[0], SIP_REALTIME) || rtcachefriends)) {
02521 realtime_update_peer(p->name, &p->addr, p->username, rtcachefriends ? p->fullcontact : NULL, expiry);
02522 }
02523 }
02524
02525
02526
02527
02528
02529
02530
02531 static struct sip_peer *realtime_peer(const char *newpeername, struct sockaddr_in *sin, int devstate_only)
02532 {
02533 struct sip_peer *peer=NULL;
02534 struct ast_variable *var = NULL;
02535 struct ast_config *peerlist = NULL;
02536 struct ast_variable *tmp;
02537 struct ast_flags flags = {0};
02538 const char *iabuf = NULL;
02539 char portstring[6];
02540 const char *insecure;
02541 char *cat = NULL;
02542 unsigned short portnum;
02543
02544
02545 if (newpeername) {
02546 var = ast_load_realtime("sippeers", "name", newpeername, "host", "dynamic", NULL);
02547 if (!var && sin)
02548 var = ast_load_realtime("sippeers", "name", newpeername, "host", ast_inet_ntoa(sin->sin_addr), NULL);
02549 if (!var) {
02550 var = ast_load_realtime("sippeers", "name", newpeername, NULL);
02551
02552
02553
02554
02555
02556
02557 if (var && sin) {
02558 for (tmp = var; tmp; tmp = tmp->next) {
02559 if (!strcasecmp(tmp->name, "host")) {
02560 struct hostent *hp;
02561 struct ast_hostent ahp;
02562 if (!(hp = ast_gethostbyname(tmp->value, &ahp)) || (memcmp(&hp->h_addr, &sin->sin_addr, sizeof(hp->h_addr)))) {
02563
02564 ast_variables_destroy(var);
02565 var = NULL;
02566 }
02567 break;
02568 }
02569 }
02570 }
02571 }
02572 }
02573
02574 if (!var && sin) {
02575 iabuf = ast_inet_ntoa(sin->sin_addr);
02576 portnum = ntohs(sin->sin_port);
02577 sprintf(portstring, "%d", portnum);
02578 var = ast_load_realtime("sippeers", "host", iabuf, "port", portstring, NULL);
02579 if (!var)
02580 var = ast_load_realtime("sippeers", "ipaddr", iabuf, "port", portstring, NULL);
02581 if (!var) {
02582 peerlist = ast_load_realtime_multientry("sippeers", "host", iabuf, NULL);
02583 if(peerlist){
02584 while((cat = ast_category_browse(peerlist, cat)))
02585 {
02586 insecure = ast_variable_retrieve(peerlist, cat, "insecure");
02587 set_insecure_flags(&flags, insecure, -1);
02588 if(ast_test_flag(&flags, SIP_INSECURE_PORT)) {
02589 var = ast_category_root(peerlist, cat);
02590 break;
02591 }
02592 }
02593 }
02594 if(!var) {
02595 ast_config_destroy(peerlist);
02596 peerlist = NULL;
02597 cat = NULL;
02598 peerlist = ast_load_realtime_multientry("sippeers", "ipaddr", iabuf, NULL);
02599 if(peerlist) {
02600 while((cat = ast_category_browse(peerlist, cat)))
02601 {
02602 insecure = ast_variable_retrieve(peerlist, cat, "insecure");
02603 set_insecure_flags(&flags, insecure, -1);
02604 if(ast_test_flag(&flags, SIP_INSECURE_PORT)) {
02605 var = ast_category_root(peerlist, cat);
02606 break;
02607 }
02608 }
02609 }
02610 }
02611 }
02612 }
02613
02614 if (!var) {
02615 if(peerlist)
02616 ast_config_destroy(peerlist);
02617 return NULL;
02618 }
02619
02620 for (tmp = var; tmp; tmp = tmp->next) {
02621
02622 if (!strcasecmp(tmp->name, "type") &&
02623 !strcasecmp(tmp->value, "user")) {
02624 ast_variables_destroy(var);
02625 return NULL;
02626 } else if (!newpeername && !strcasecmp(tmp->name, "name")) {
02627 newpeername = tmp->value;
02628 }
02629 }
02630
02631 if (!newpeername) {
02632 ast_log(LOG_WARNING, "Cannot Determine peer name ip=%s\n", iabuf);
02633 if(peerlist)
02634 ast_config_destroy(peerlist);
02635 else
02636 ast_variables_destroy(var);
02637 return NULL;
02638 }
02639
02640
02641 peer = build_peer(newpeername, var, NULL, 1);
02642 if (!peer) {
02643 if(peerlist)
02644 ast_config_destroy(peerlist);
02645 else
02646 ast_variables_destroy(var);
02647 return NULL;
02648 }
02649
02650 if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS) && !devstate_only) {
02651
02652 ast_copy_flags(&peer->flags[1],&global_flags[1], SIP_PAGE2_RTAUTOCLEAR|SIP_PAGE2_RTCACHEFRIENDS);
02653 if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTAUTOCLEAR)) {
02654 if (!AST_SCHED_DEL(sched, peer->expire)) {
02655 struct sip_peer *peer_ptr = peer;
02656 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
02657 }
02658 peer->expire = ast_sched_add(sched, (global_rtautoclear) * 1000, expire_register, ASTOBJ_REF(peer));
02659 if (peer->expire == -1) {
02660 struct sip_peer *peer_ptr = peer;
02661 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
02662 }
02663 }
02664 ASTOBJ_CONTAINER_LINK(&peerl,peer);
02665 }
02666 ast_set_flag(&peer->flags[0], SIP_REALTIME);
02667 if(peerlist)
02668 ast_config_destroy(peerlist);
02669 else
02670 ast_variables_destroy(var);
02671 return peer;
02672 }
02673
02674
02675 static int sip_addrcmp(char *name, struct sockaddr_in *sin)
02676 {
02677
02678 struct sip_peer *p = (struct sip_peer *) name;
02679 return !(!inaddrcmp(&p->addr, sin) ||
02680 (ast_test_flag(&p->flags[0], SIP_INSECURE_PORT) &&
02681 (p->addr.sin_addr.s_addr == sin->sin_addr.s_addr)));
02682 }
02683
02684
02685
02686
02687 static struct sip_peer *find_peer(const char *peer, struct sockaddr_in *sin, int realtime, int devstate_only)
02688 {
02689 struct sip_peer *p = NULL;
02690
02691 if (peer)
02692 p = ASTOBJ_CONTAINER_FIND(&peerl, peer);
02693 else
02694 p = ASTOBJ_CONTAINER_FIND_FULL(&peerl, sin, name, sip_addr_hashfunc, 1, sip_addrcmp);
02695
02696 if (!p && (realtime || devstate_only))
02697 p = realtime_peer(peer, sin, devstate_only);
02698
02699 return p;
02700 }
02701
02702
02703 static void sip_destroy_user(struct sip_user *user)
02704 {
02705 if (option_debug > 2)
02706 ast_log(LOG_DEBUG, "Destroying user object from memory: %s\n", user->name);
02707 ast_free_ha(user->ha);
02708 if (user->chanvars) {
02709 ast_variables_destroy(user->chanvars);
02710 user->chanvars = NULL;
02711 }
02712 if (ast_test_flag(&user->flags[0], SIP_REALTIME))
02713 ruserobjs--;
02714 else
02715 suserobjs--;
02716 free(user);
02717 }
02718
02719
02720
02721
02722 static struct sip_user *realtime_user(const char *username)
02723 {
02724 struct ast_variable *var;
02725 struct ast_variable *tmp;
02726 struct sip_user *user = NULL;
02727
02728 var = ast_load_realtime("sipusers", "name", username, NULL);
02729
02730 if (!var)
02731 return NULL;
02732
02733 for (tmp = var; tmp; tmp = tmp->next) {
02734 if (!strcasecmp(tmp->name, "type") &&
02735 !strcasecmp(tmp->value, "peer")) {
02736 ast_variables_destroy(var);
02737 return NULL;
02738 }
02739 }
02740
02741 user = build_user(username, var, NULL, !ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS));
02742
02743 if (!user) {
02744 ast_variables_destroy(var);
02745 return NULL;
02746 }
02747
02748 if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
02749 ast_set_flag(&user->flags[1], SIP_PAGE2_RTCACHEFRIENDS);
02750 suserobjs++;
02751 ASTOBJ_CONTAINER_LINK(&userl,user);
02752 } else {
02753
02754 suserobjs--;
02755 ruserobjs++;
02756 }
02757 ast_set_flag(&user->flags[0], SIP_REALTIME);
02758 ast_variables_destroy(var);
02759 return user;
02760 }
02761
02762
02763
02764
02765
02766 static struct sip_user *find_user(const char *name, int realtime)
02767 {
02768 struct sip_user *u = ASTOBJ_CONTAINER_FIND(&userl, name);
02769 if (!u && realtime)
02770 u = realtime_user(name);
02771 return u;
02772 }
02773
02774
02775 static void do_setnat(struct sip_pvt *p, int natflags)
02776 {
02777 const char *mode = natflags ? "On" : "Off";
02778
02779 if (p->rtp) {
02780 if (option_debug)
02781 ast_log(LOG_DEBUG, "Setting NAT on RTP to %s\n", mode);
02782 ast_rtp_setnat(p->rtp, natflags);
02783 }
02784 if (p->vrtp) {
02785 if (option_debug)
02786 ast_log(LOG_DEBUG, "Setting NAT on VRTP to %s\n", mode);
02787 ast_rtp_setnat(p->vrtp, natflags);
02788 }
02789 if (p->udptl) {
02790 if (option_debug)
02791 ast_log(LOG_DEBUG, "Setting NAT on UDPTL to %s\n", mode);
02792 ast_udptl_setnat(p->udptl, natflags);
02793 }
02794 }
02795
02796
02797
02798
02799 static int create_addr_from_peer(struct sip_pvt *dialog, struct sip_peer *peer)
02800 {
02801 if ((peer->addr.sin_addr.s_addr || peer->defaddr.sin_addr.s_addr) &&
02802 (!peer->maxms || ((peer->lastms >= 0) && (peer->lastms <= peer->maxms)))) {
02803 dialog->sa = (peer->addr.sin_addr.s_addr) ? peer->addr : peer->defaddr;
02804 dialog->recv = dialog->sa;
02805 } else
02806 return -1;
02807
02808 ast_copy_flags(&dialog->flags[0], &peer->flags[0], SIP_FLAGS_TO_COPY);
02809 ast_copy_flags(&dialog->flags[1], &peer->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
02810 ast_copy_flags(&dialog->flags[1], &peer->flags[1], SIP_PAGE2_TCP | SIP_PAGE2_TCP_CONNECTED);
02811 dialog->sockfd = peer->sockfd;
02812 dialog->capability = peer->capability;
02813 if ((!ast_test_flag(&dialog->flags[1], SIP_PAGE2_VIDEOSUPPORT) || !(dialog->capability & AST_FORMAT_VIDEO_MASK)) && dialog->vrtp) {
02814 ast_rtp_destroy(dialog->vrtp);
02815 dialog->vrtp = NULL;
02816 }
02817 dialog->prefs = peer->prefs;
02818 if (ast_test_flag(&dialog->flags[1], SIP_PAGE2_T38SUPPORT)) {
02819 dialog->t38.capability = global_t38_capability;
02820 if (dialog->udptl) {
02821 if (ast_udptl_get_error_correction_scheme(dialog->udptl) == UDPTL_ERROR_CORRECTION_FEC )
02822 dialog->t38.capability |= T38FAX_UDP_EC_FEC;
02823 else if (ast_udptl_get_error_correction_scheme(dialog->udptl) == UDPTL_ERROR_CORRECTION_REDUNDANCY )
02824 dialog->t38.capability |= T38FAX_UDP_EC_REDUNDANCY;
02825 else if (ast_udptl_get_error_correction_scheme(dialog->udptl) == UDPTL_ERROR_CORRECTION_NONE )
02826 dialog->t38.capability |= T38FAX_UDP_EC_NONE;
02827 dialog->t38.capability |= T38FAX_RATE_MANAGEMENT_TRANSFERED_TCF;
02828 if (option_debug > 1)
02829 ast_log(LOG_DEBUG,"Our T38 capability (%d)\n", dialog->t38.capability);
02830 }
02831 dialog->t38.jointcapability = dialog->t38.capability;
02832 } else if (dialog->udptl) {
02833 ast_udptl_destroy(dialog->udptl);
02834 dialog->udptl = NULL;
02835 }
02836 do_setnat(dialog, ast_test_flag(&dialog->flags[0], SIP_NAT) & SIP_NAT_ROUTE );
02837
02838 if (dialog->rtp) {
02839 ast_rtp_setdtmf(dialog->rtp, ast_test_flag(&dialog->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833);
02840 ast_rtp_setdtmfcompensate(dialog->rtp, ast_test_flag(&dialog->flags[1], SIP_PAGE2_RFC2833_COMPENSATE));
02841 ast_rtp_set_rtptimeout(dialog->rtp, peer->rtptimeout);
02842 ast_rtp_set_rtpholdtimeout(dialog->rtp, peer->rtpholdtimeout);
02843 ast_rtp_set_rtpkeepalive(dialog->rtp, peer->rtpkeepalive);
02844
02845 ast_rtp_codec_setpref(dialog->rtp, &dialog->prefs);
02846 dialog->autoframing = peer->autoframing;
02847 }
02848 if (dialog->vrtp) {
02849 ast_rtp_setdtmf(dialog->vrtp, 0);
02850 ast_rtp_setdtmfcompensate(dialog->vrtp, 0);
02851 ast_rtp_set_rtptimeout(dialog->vrtp, peer->rtptimeout);
02852 ast_rtp_set_rtpholdtimeout(dialog->vrtp, peer->rtpholdtimeout);
02853 ast_rtp_set_rtpkeepalive(dialog->vrtp, peer->rtpkeepalive);
02854 }
02855
02856 ast_string_field_set(dialog, peername, peer->name);
02857 ast_string_field_set(dialog, authname, peer->username);
02858 ast_string_field_set(dialog, username, peer->username);
02859 ast_string_field_set(dialog, peersecret, peer->secret);
02860 ast_string_field_set(dialog, peermd5secret, peer->md5secret);
02861 ast_string_field_set(dialog, mohsuggest, peer->mohsuggest);
02862 ast_string_field_set(dialog, mohinterpret, peer->mohinterpret);
02863 ast_string_field_set(dialog, tohost, peer->tohost);
02864 ast_string_field_set(dialog, fullcontact, peer->fullcontact);
02865 if (!dialog->initreq.headers && !ast_strlen_zero(peer->fromdomain)) {
02866 char *tmpcall;
02867 char *c;
02868 tmpcall = ast_strdupa(dialog->callid);
02869 c = strchr(tmpcall, '@');
02870 if (c) {
02871 *c = '\0';
02872 ast_string_field_build(dialog, callid, "%s@%s", tmpcall, peer->fromdomain);
02873 }
02874 }
02875 if (ast_strlen_zero(dialog->tohost))
02876 ast_string_field_set(dialog, tohost, ast_inet_ntoa(dialog->sa.sin_addr));
02877 if (!ast_strlen_zero(peer->fromdomain))
02878 ast_string_field_set(dialog, fromdomain, peer->fromdomain);
02879 if (!ast_strlen_zero(peer->fromuser))
02880 ast_string_field_set(dialog, fromuser, peer->fromuser);
02881 if (!ast_strlen_zero(peer->language))
02882 ast_string_field_set(dialog, language, peer->language);
02883 dialog->maxtime = peer->maxms;
02884 dialog->callgroup = peer->callgroup;
02885 dialog->pickupgroup = peer->pickupgroup;
02886 dialog->peerauth = peer->auth;
02887 dialog->allowtransfer = peer->allowtransfer;
02888
02889
02890 if (peer->maxms && peer->lastms)
02891 dialog->timer_t1 = peer->lastms < global_t1min ? global_t1min : peer->lastms;
02892 if ((ast_test_flag(&dialog->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
02893 (ast_test_flag(&dialog->flags[0], SIP_DTMF) == SIP_DTMF_AUTO))
02894 dialog->noncodeccapability |= AST_RTP_DTMF;
02895 else
02896 dialog->noncodeccapability &= ~AST_RTP_DTMF;
02897 dialog->jointnoncodeccapability = dialog->noncodeccapability;
02898 ast_string_field_set(dialog, context, peer->context);
02899 dialog->rtptimeout = peer->rtptimeout;
02900 if (peer->call_limit)
02901 ast_set_flag(&dialog->flags[0], SIP_CALL_LIMIT);
02902 dialog->maxcallbitrate = peer->maxcallbitrate;
02903
02904 return 0;
02905 }
02906
02907
02908
02909
02910 static int create_addr(struct sip_pvt *dialog, const char *opeer)
02911 {
02912 struct hostent *hp;
02913 struct ast_hostent ahp;
02914 struct sip_peer *p;
02915 char *port;
02916 int portno;
02917 char host[MAXHOSTNAMELEN], *hostn;
02918 char peer[256];
02919
02920 ast_copy_string(peer, opeer, sizeof(peer));
02921 port = strchr(peer, ':');
02922 if (port)
02923 *port++ = '\0';
02924 dialog->sa.sin_family = AF_INET;
02925 dialog->timer_t1 = 500;
02926 p = find_peer(peer, NULL, 1, 0);
02927
02928 if (p) {
02929 int res = create_addr_from_peer(dialog, p);
02930 if (port) {
02931 portno = atoi(port);
02932 dialog->sa.sin_port = dialog->recv.sin_port = htons(portno);
02933 }
02934 ASTOBJ_UNREF(p, sip_destroy_peer);
02935 return res;
02936 }
02937 hostn = peer;
02938 portno = port ? atoi(port) : STANDARD_SIP_PORT;
02939 if (srvlookup) {
02940 char service[MAXHOSTNAMELEN];
02941 int tportno;
02942 int ret;
02943
02944 snprintf(service, sizeof(service), "_sip._udp.%s", peer);
02945 ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service);
02946 if (ret > 0) {
02947 hostn = host;
02948 portno = tportno;
02949 }
02950 }
02951 hp = ast_gethostbyname(hostn, &ahp);
02952 if (!hp) {
02953 ast_log(LOG_WARNING, "No such host: %s\n", peer);
02954 return -1;
02955 }
02956 ast_string_field_set(dialog, tohost, peer);
02957 memcpy(&dialog->sa.sin_addr, hp->h_addr, sizeof(dialog->sa.sin_addr));
02958 dialog->sa.sin_port = htons(portno);
02959 dialog->recv = dialog->sa;
02960 return 0;
02961 }
02962
02963
02964 static int auto_congest(const void *nothing)
02965 {
02966 struct sip_pvt *p = (struct sip_pvt *)nothing;
02967
02968 ast_mutex_lock(&p->lock);
02969 p->initid = -1;
02970 if (p->owner) {
02971
02972 if (!ast_channel_trylock(p->owner)) {
02973 ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name);
02974 append_history(p, "Cong", "Auto-congesting (timer)");
02975 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
02976 ast_channel_unlock(p->owner);
02977 }
02978 }
02979 ast_mutex_unlock(&p->lock);
02980 return 0;
02981 }
02982
02983
02984
02985
02986 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
02987 {
02988 int res, xmitres = 0;
02989 struct sip_pvt *p;
02990 struct varshead *headp;
02991 struct ast_var_t *current;
02992 const char *referer = NULL;
02993
02994 p = ast->tech_pvt;
02995 if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
02996 ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
02997 return -1;
02998 }
02999
03000
03001 headp=&ast->varshead;
03002 AST_LIST_TRAVERSE(headp,current,entries) {
03003
03004 if (!p->options->vxml_url && !strcasecmp(ast_var_name(current), "VXML_URL")) {
03005 p->options->vxml_url = ast_var_value(current);
03006 } else if (!p->options->uri_options && !strcasecmp(ast_var_name(current), "SIP_URI_OPTIONS")) {
03007 p->options->uri_options = ast_var_value(current);
03008 } else if (!p->options->distinctive_ring && !strcasecmp(ast_var_name(current), "ALERT_INFO")) {
03009
03010 p->options->distinctive_ring = ast_var_value(current);
03011 } else if (!p->options->addsipheaders && !strncasecmp(ast_var_name(current), "SIPADDHEADER", strlen("SIPADDHEADER"))) {
03012
03013 p->options->addsipheaders = 1;
03014 } else if (!strcasecmp(ast_var_name(current), "SIPTRANSFER")) {
03015
03016 p->options->transfer = 1;
03017 } else if (!strcasecmp(ast_var_name(current), "SIPTRANSFER_REFERER")) {
03018
03019 referer = ast_var_value(current);
03020 } else if (!strcasecmp(ast_var_name(current), "SIPTRANSFER_REPLACES")) {
03021
03022 p->options->replaces = ast_var_value(current);
03023 } else if (!strcasecmp(ast_var_name(current), "T38CALL")) {
03024 p->t38.state = T38_LOCAL_DIRECT;
03025 if (option_debug)
03026 ast_log(LOG_DEBUG,"T38State change to %d on channel %s\n", p->t38.state, ast->name);
03027 }
03028
03029 }
03030
03031 res = 0;
03032 ast_set_flag(&p->flags[0], SIP_OUTGOING);
03033
03034 if (p->options->transfer) {
03035 char buf[SIPBUFSIZE/2];
03036
03037 if (referer) {
03038 if (sipdebug && option_debug > 2)
03039 ast_log(LOG_DEBUG, "Call for %s transfered by %s\n", p->username, referer);
03040 snprintf(buf, sizeof(buf)-1, "-> %s (via %s)", p->cid_name, referer);
03041 } else
03042 snprintf(buf, sizeof(buf)-1, "-> %s", p->cid_name);
03043 ast_string_field_set(p, cid_name, buf);
03044 }
03045 if (option_debug)
03046 ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);
03047
03048 res = update_call_counter(p, INC_CALL_RINGING);
03049 if ( res != -1 ) {
03050 p->callingpres = ast->cid.cid_pres;
03051 p->jointcapability = ast_translate_available_formats(p->capability, p->prefcodec);
03052 p->jointnoncodeccapability = p->noncodeccapability;
03053
03054
03055 if (!(p->jointcapability & AST_FORMAT_AUDIO_MASK)) {
03056 ast_log(LOG_WARNING, "No audio format found to offer. Cancelling call to %s\n", p->username);
03057 res = -1;
03058 } else {
03059 p->t38.jointcapability = p->t38.capability;
03060 if (option_debug > 1)
03061 ast_log(LOG_DEBUG,"Our T38 capability (%d), joint T38 capability (%d)\n", p->t38.capability, p->t38.jointcapability);
03062 xmitres = transmit_invite(p, SIP_INVITE, 1, 2);
03063 if (xmitres == XMIT_ERROR)
03064 return -1;
03065
03066 p->invitestate = INV_CALLING;
03067
03068
03069 AST_SCHED_DEL(sched, p->initid);
03070 p->initid = ast_sched_add(sched, p->maxtime ? (p->maxtime * 4) : SIP_TRANS_TIMEOUT, auto_congest, p);
03071 }
03072 }
03073 return res;
03074 }
03075
03076
03077
03078 static void sip_registry_destroy(struct sip_registry *reg)
03079 {
03080
03081 if (option_debug > 2)
03082 ast_log(LOG_DEBUG, "Destroying registry entry for %s@%s\n", reg->username, reg->hostname);
03083
03084 if (reg->call) {
03085
03086
03087 reg->call->registry = NULL;
03088 if (option_debug > 2)
03089 ast_log(LOG_DEBUG, "Destroying active SIP dialog for registry %s@%s\n", reg->username, reg->hostname);
03090 sip_destroy(reg->call);
03091 }
03092 AST_SCHED_DEL(sched, reg->expire);
03093 AST_SCHED_DEL(sched, reg->timeout);
03094 ast_string_field_free_memory(reg);
03095 regobjs--;
03096 free(reg);
03097
03098 }
03099
03100
03101 static int __sip_destroy(struct sip_pvt *p, int lockowner)
03102 {
03103 struct sip_pvt *cur, *prev = NULL;
03104 struct sip_pkt *cp;
03105
03106
03107 if (p->rtp && ast_rtp_get_bridged(p->rtp)) {
03108 ast_verbose("Bridge still active. Delaying destroy of SIP dialog '%s' Method: %s\n", p->callid, sip_methods[p->method].text);
03109 return -1;
03110 }
03111
03112 if (p->vrtp && ast_rtp_get_bridged(p->vrtp)) {
03113 ast_verbose("Bridge still active. Delaying destroy of SIP dialog '%s' Method: %s\n", p->callid, sip_methods[p->method].text);
03114 return -1;
03115 }
03116
03117 if (sip_debug_test_pvt(p) || option_debug > 2)
03118 ast_verbose("Really destroying SIP dialog '%s' Method: %s\n", p->callid, sip_methods[p->method].text);
03119
03120 if (ast_test_flag(&p->flags[0], SIP_INC_COUNT) || ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD)) {
03121 update_call_counter(p, DEC_CALL_LIMIT);
03122 if (option_debug > 1)
03123 ast_log(LOG_DEBUG, "This call did not properly clean up call limits. Call ID %s\n", p->callid);
03124 }
03125
03126
03127 if (p->owner) {
03128 if (lockowner)
03129 ast_channel_lock(p->owner);
03130 if (option_debug)
03131 ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
03132 p->owner->tech_pvt = NULL;
03133
03134 p->owner->_softhangup |= AST_SOFTHANGUP_DEV;
03135 if (lockowner)
03136 ast_channel_unlock(p->owner);
03137
03138 usleep(1);
03139 }
03140
03141
03142 if (p->relatedpeer) {
03143 if (p->relatedpeer->mwipvt == p) {
03144 p->relatedpeer->mwipvt = NULL;
03145 }
03146 ASTOBJ_UNREF(p->relatedpeer, sip_destroy_peer);
03147 }
03148
03149 if (dumphistory)
03150 sip_dump_history(p);
03151
03152 if (p->options)
03153 free(p->options);
03154
03155 if (p->stateid > -1)
03156 ast_extension_state_del(p->stateid, NULL);
03157 AST_SCHED_DEL(sched, p->initid);
03158 AST_SCHED_DEL(sched, p->waitid);
03159 AST_SCHED_DEL(sched, p->autokillid);
03160
03161 if (p->rtp) {
03162 ast_rtp_destroy(p->rtp);
03163 }
03164 if (p->vrtp) {
03165 ast_rtp_destroy(p->vrtp);
03166 }
03167 if (p->udptl)
03168 ast_udptl_destroy(p->udptl);
03169 if (p->refer)
03170 free(p->refer);
03171 if (p->route) {
03172 free_old_route(p->route);
03173 p->route = NULL;
03174 }
03175 if (p->registry) {
03176 if (p->registry->call == p)
03177 p->registry->call = NULL;
03178 ASTOBJ_UNREF(p->registry, sip_registry_destroy);
03179 }
03180
03181
03182 if (p->history) {
03183 struct sip_history *hist;
03184 while ( (hist = AST_LIST_REMOVE_HEAD(p->history, list)) ) {
03185 free(hist);
03186 p->history_entries--;
03187 }
03188 free(p->history);
03189 p->history = NULL;
03190 }
03191
03192 for (prev = NULL, cur = iflist; cur; prev = cur, cur = cur->next) {
03193 if (cur == p) {
03194 UNLINK(cur, iflist, prev);
03195 break;
03196 }
03197 }
03198 if (!cur) {
03199 ast_log(LOG_WARNING, "Trying to destroy \"%s\", not found in dialog list?!?! \n", p->callid);
03200 return 0;
03201 }
03202
03203
03204 while((cp = p->packets)) {
03205 p->packets = p->packets->next;
03206 AST_SCHED_DEL(sched, cp->retransid);
03207 free(cp);
03208 }
03209 if (p->chanvars) {
03210 ast_variables_destroy(p->chanvars);
03211 p->chanvars = NULL;
03212 }
03213 ast_mutex_destroy(&p->lock);
03214
03215 ast_string_field_free_memory(p);
03216
03217 free(p);
03218 return 0;
03219 }
03220
03221
03222
03223
03224
03225
03226
03227
03228
03229
03230
03231
03232
03233
03234
03235 static int update_call_counter(struct sip_pvt *fup, int event)
03236 {
03237 char name[256];
03238 int *inuse = NULL, *call_limit = NULL, *inringing = NULL;
03239 int outgoing = ast_test_flag(&fup->flags[1], SIP_PAGE2_OUTGOING_CALL);
03240 struct sip_user *u = NULL;
03241 struct sip_peer *p = NULL;
03242
03243 if (option_debug > 2)
03244 ast_log(LOG_DEBUG, "Updating call counter for %s call\n", outgoing ? "outgoing" : "incoming");
03245
03246
03247
03248 if (!ast_test_flag(&fup->flags[0], SIP_CALL_LIMIT) && !ast_test_flag(&fup->flags[1], SIP_PAGE2_CALL_ONHOLD))
03249 return 0;
03250
03251 ast_copy_string(name, fup->username, sizeof(name));
03252
03253
03254 if (global_limitonpeers == FALSE && !outgoing && (u = find_user(name, 1))) {
03255 inuse = &u->inUse;
03256 call_limit = &u->call_limit;
03257 inringing = NULL;
03258 } else if ( (p = find_peer(ast_strlen_zero(fup->peername) ? name : fup->peername, NULL, 1, 0) ) ) {
03259 inuse = &p->inUse;
03260 call_limit = &p->call_limit;
03261 inringing = &p->inRinging;
03262 ast_copy_string(name, fup->peername, sizeof(name));
03263 }
03264 if (!p && !u) {
03265 if (option_debug > 1)
03266 ast_log(LOG_DEBUG, "%s is not a local device, no call limit\n", name);
03267 return 0;
03268 }
03269
03270 switch(event) {
03271
03272 case DEC_CALL_LIMIT:
03273 if ( *inuse > 0 ) {
03274 if (ast_test_flag(&fup->flags[0], SIP_INC_COUNT)) {
03275 (*inuse)--;
03276 ast_clear_flag(&fup->flags[0], SIP_INC_COUNT);
03277 }
03278 } else {
03279 *inuse = 0;
03280 }
03281 if (inringing) {
03282 if (ast_test_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING)) {
03283 if (*inringing > 0)
03284 (*inringing)--;
03285 else if (!ast_test_flag(&p->flags[0], SIP_REALTIME) || ast_test_flag(&p->flags[1], SIP_PAGE2_RTCACHEFRIENDS))
03286 ast_log(LOG_WARNING, "Inringing for peer '%s' < 0?\n", fup->peername);
03287 ast_clear_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING);
03288 }
03289 }
03290 if (ast_test_flag(&fup->flags[1], SIP_PAGE2_CALL_ONHOLD) && global_notifyhold) {
03291 ast_clear_flag(&fup->flags[1], SIP_PAGE2_CALL_ONHOLD);
03292 sip_peer_hold(fup, 0);
03293 }
03294 if (option_debug > 1 || sipdebug) {
03295 ast_log(LOG_DEBUG, "Call %s %s '%s' removed from call limit %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *call_limit);
03296 }
03297 break;
03298
03299 case INC_CALL_RINGING:
03300 case INC_CALL_LIMIT:
03301 if (*call_limit > 0 ) {
03302
03303 if (outgoing && (*inuse >= *call_limit)) {
03304 ast_log(LOG_ERROR, "Call %s %s '%s' rejected due to usage limit of %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *call_limit);
03305 if (u)
03306 ASTOBJ_UNREF(u, sip_destroy_user);
03307 else
03308 ASTOBJ_UNREF(p, sip_destroy_peer);
03309 return -1;
03310 }
03311 }
03312 if (inringing && (event == INC_CALL_RINGING)) {
03313 if (!ast_test_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING)) {
03314 (*inringing)++;
03315 ast_set_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING);
03316 }
03317 }
03318
03319 (*inuse)++;
03320 ast_set_flag(&fup->flags[0], SIP_INC_COUNT);
03321 if (option_debug > 1 || sipdebug) {
03322 ast_log(LOG_DEBUG, "Call %s %s '%s' is %d out of %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *inuse, *call_limit);
03323 }
03324 break;
03325
03326 case DEC_CALL_RINGING:
03327 if (inringing) {
03328 if (ast_test_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING)) {
03329 if (*inringing > 0)
03330 (*inringing)--;
03331 else if (!ast_test_flag(&p->flags[0], SIP_REALTIME) || ast_test_flag(&p->flags[1], SIP_PAGE2_RTCACHEFRIENDS))
03332 ast_log(LOG_WARNING, "Inringing for peer '%s' < 0?\n", p->name);
03333 ast_clear_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING);
03334 }
03335 }
03336 break;
03337
03338 default:
03339 ast_log(LOG_ERROR, "update_call_counter(%s, %d) called with no event!\n", name, event);
03340 }
03341 if (p) {
03342 ast_device_state_changed("SIP/%s", p->name);
03343 ASTOBJ_UNREF(p, sip_destroy_peer);
03344 } else
03345 ASTOBJ_UNREF(u, sip_destroy_user);
03346 return 0;
03347 }
03348
03349
03350 static void sip_destroy(struct sip_pvt *p)
03351 {
03352 ast_mutex_lock(&iflock);
03353 if (option_debug > 2)
03354 ast_log(LOG_DEBUG, "Destroying SIP dialog %s\n", p->callid);
03355 __sip_destroy(p, 1);
03356 ast_mutex_unlock(&iflock);
03357 }
03358
03359
03360 static int hangup_sip2cause(int cause)
03361 {
03362
03363
03364 switch(cause) {
03365 case 401:
03366 return AST_CAUSE_CALL_REJECTED;
03367 case 403:
03368 return AST_CAUSE_CALL_REJECTED;
03369 case 404:
03370 return AST_CAUSE_UNALLOCATED;
03371 case 405:
03372 return AST_CAUSE_INTERWORKING;
03373 case 407:
03374 return AST_CAUSE_CALL_REJECTED;
03375 case 408:
03376 return AST_CAUSE_NO_USER_RESPONSE;
03377 case 409:
03378 return AST_CAUSE_NORMAL_TEMPORARY_FAILURE;
03379 case 410:
03380 return AST_CAUSE_UNALLOCATED;
03381 case 411:
03382 return AST_CAUSE_INTERWORKING;
03383 case 413:
03384 return AST_CAUSE_INTERWORKING;
03385 case 414:
03386 return AST_CAUSE_INTERWORKING;
03387 case 415:
03388 return AST_CAUSE_INTERWORKING;
03389 case 420:
03390 return AST_CAUSE_NO_ROUTE_DESTINATION;
03391 case 480:
03392 return AST_CAUSE_NO_ANSWER;
03393 case 481:
03394 return AST_CAUSE_INTERWORKING;
03395 case 482:
03396 return AST_CAUSE_INTERWORKING;
03397 case 483:
03398 return AST_CAUSE_NO_ANSWER;
03399 case 484:
03400 return AST_CAUSE_INVALID_NUMBER_FORMAT;
03401 case 485:
03402 return AST_CAUSE_UNALLOCATED;
03403 case 486:
03404 return AST_CAUSE_BUSY;
03405 case 487:
03406 return AST_CAUSE_INTERWORKING;
03407 case 488:
03408 return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
03409 case 491:
03410 return AST_CAUSE_INTERWORKING;
03411 case 493:
03412 return AST_CAUSE_INTERWORKING;
03413 case 500:
03414 return AST_CAUSE_FAILURE;
03415 case 501:
03416 return AST_CAUSE_FACILITY_REJECTED;
03417 case 502:
03418 return AST_CAUSE_DESTINATION_OUT_OF_ORDER;
03419 case 503:
03420 return AST_CAUSE_CONGESTION;
03421 case 504:
03422 return AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE;
03423 case 505:
03424 return AST_CAUSE_INTERWORKING;
03425 case 600:
03426 return AST_CAUSE_USER_BUSY;
03427 case 603:
03428 return AST_CAUSE_CALL_REJECTED;
03429 case 604:
03430 return AST_CAUSE_UNALLOCATED;
03431 case 606:
03432 return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
03433 default:
03434 return AST_CAUSE_NORMAL;
03435 }
03436
03437 return 0;
03438 }
03439
03440
03441
03442
03443
03444
03445
03446
03447
03448
03449
03450
03451
03452
03453
03454
03455
03456
03457
03458
03459
03460
03461
03462
03463
03464
03465
03466
03467
03468
03469
03470
03471
03472 static const char *hangup_cause2sip(int cause)
03473 {
03474 switch (cause) {
03475 case AST_CAUSE_UNALLOCATED:
03476 case AST_CAUSE_NO_ROUTE_DESTINATION:
03477 case AST_CAUSE_NO_ROUTE_TRANSIT_NET:
03478 return "404 Not Found";
03479 case AST_CAUSE_CONGESTION:
03480 case AST_CAUSE_SWITCH_CONGESTION:
03481 return "503 Service Unavailable";
03482 case AST_CAUSE_NO_USER_RESPONSE:
03483 return "408 Request Timeout";
03484 case AST_CAUSE_NO_ANSWER:
03485 case AST_CAUSE_UNREGISTERED:
03486 return "480 Temporarily unavailable";
03487 case AST_CAUSE_CALL_REJECTED:
03488 return "403 Forbidden";
03489 case AST_CAUSE_NUMBER_CHANGED:
03490 return "410 Gone";
03491 case AST_CAUSE_NORMAL_UNSPECIFIED:
03492 return "480 Temporarily unavailable";
03493 case AST_CAUSE_INVALID_NUMBER_FORMAT:
03494 return "484 Address incomplete";
03495 case AST_CAUSE_USER_BUSY:
03496 return "486 Busy here";
03497 case AST_CAUSE_FAILURE:
03498 return "500 Server internal failure";
03499 case AST_CAUSE_FACILITY_REJECTED:
03500 return "501 Not Implemented";
03501 case AST_CAUSE_CHAN_NOT_IMPLEMENTED:
03502 return "503 Service Unavailable";
03503
03504 case AST_CAUSE_DESTINATION_OUT_OF_ORDER:
03505 return "502 Bad Gateway";
03506 case AST_CAUSE_BEARERCAPABILITY_NOTAVAIL:
03507 return "488 Not Acceptable Here";
03508
03509 case AST_CAUSE_NOTDEFINED:
03510 default:
03511 if (option_debug)
03512 ast_log(LOG_DEBUG, "AST hangup cause %d (no match found in SIP)\n", cause);
03513 return NULL;
03514 }
03515
03516
03517 return 0;
03518 }
03519
03520
03521
03522
03523 static int sip_hangup(struct ast_channel *ast)
03524 {
03525 struct sip_pvt *p = ast->tech_pvt;
03526 int needcancel = FALSE;
03527 int needdestroy = 0;
03528 struct ast_channel *oldowner = ast;
03529
03530 if (!p) {
03531 if (option_debug)
03532 ast_log(LOG_DEBUG, "Asked to hangup channel that was not connected\n");
03533 return 0;
03534 }
03535
03536 if (ast_test_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER)) {
03537 if (ast_test_flag(&p->flags[0], SIP_INC_COUNT) || ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD)) {
03538 if (option_debug && sipdebug)
03539 ast_log(LOG_DEBUG, "update_call_counter(%s) - decrement call limit counter on hangup\n", p->username);
03540 update_call_counter(p, DEC_CALL_LIMIT);
03541 }
03542 if (option_debug >3)
03543 ast_log(LOG_DEBUG, "SIP Transfer: Not hanging up right now... Rescheduling hangup for %s.\n", p->callid);
03544 if (p->autokillid > -1 && sip_cancel_destroy(p))
03545 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
03546 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
03547 ast_clear_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER);
03548 ast_clear_flag(&p->flags[0], SIP_NEEDDESTROY);
03549 p->owner->tech_pvt = NULL;
03550 p->owner = NULL;
03551 return 0;
03552 }
03553 if (option_debug) {
03554 if (ast_test_flag(ast, AST_FLAG_ZOMBIE) && p->refer && option_debug)
03555 ast_log(LOG_DEBUG, "SIP Transfer: Hanging up Zombie channel %s after transfer ... Call-ID: %s\n", ast->name, p->callid);
03556 else {
03557 if (option_debug)
03558 ast_log(LOG_DEBUG, "Hangup call %s, SIP callid %s)\n", ast->name, p->callid);
03559 }
03560 }
03561 if (option_debug && ast_test_flag(ast, AST_FLAG_ZOMBIE))
03562 ast_log(LOG_DEBUG, "Hanging up zombie call. Be scared.\n");
03563
03564 ast_mutex_lock(&p->lock);
03565 if (ast_test_flag(&p->flags[0], SIP_INC_COUNT) || ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD)) {
03566 if (option_debug && sipdebug)
03567 ast_log(LOG_DEBUG, "update_call_counter(%s) - decrement call limit counter on hangup\n", p->username);
03568 update_call_counter(p, DEC_CALL_LIMIT);
03569 }
03570
03571
03572 if (p->owner != ast) {
03573 ast_log(LOG_WARNING, "Huh? We aren't the owner? Can't hangup call.\n");
03574 ast_mutex_unlock(&p->lock);
03575 return 0;
03576 }
03577
03578 if (ast->_state == AST_STATE_RING || ast->_state == AST_STATE_RINGING || (p->invitestate < INV_COMPLETED && ast->_state != AST_STATE_UP)) {
03579 needcancel = TRUE;
03580 if (option_debug > 3)
03581 ast_log(LOG_DEBUG, "Hanging up channel in state %s (not UP)\n", ast_state2str(ast->_state));
03582 }
03583
03584 stop_media_flows(p);
03585
03586 append_history(p, needcancel ? "Cancel" : "Hangup", "Cause %s", p->owner ? ast_cause2str(p->owner->hangupcause) : "Unknown");
03587
03588
03589 if (p->vad)
03590 ast_dsp_free(p->vad);
03591
03592 p->owner = NULL;
03593 ast->tech_pvt = NULL;
03594
03595 ast_module_unref(ast_module_info->self);
03596
03597
03598
03599
03600
03601
03602
03603 if (ast_test_flag(&p->flags[0], SIP_ALREADYGONE))
03604 needdestroy = 1;
03605 else if (p->invitestate != INV_CALLING)
03606 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
03607
03608
03609 if (!ast_test_flag(&p->flags[0], SIP_ALREADYGONE) && !ast_strlen_zero(p->initreq.data)) {
03610 if (needcancel) {
03611 if (ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
03612
03613 __sip_pretend_ack(p);
03614 p->invitestate = INV_CANCELLED;
03615
03616
03617 if (p->invitestate == INV_CALLING) {
03618
03619 ast_set_flag(&p->flags[0], SIP_PENDINGBYE);
03620
03621 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
03622 append_history(p, "DELAY", "Not sending cancel, waiting for timeout");
03623 } else {
03624
03625 transmit_request(p, SIP_CANCEL, p->lastinvite, XMIT_RELIABLE, FALSE);
03626
03627
03628 needdestroy = 0;
03629 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
03630 }
03631 if ( p->initid != -1 ) {
03632
03633
03634 update_call_counter(p, INC_CALL_LIMIT);
03635 }
03636 } else {
03637 const char *res;
03638 if (ast->hangupcause && (res = hangup_cause2sip(ast->hangupcause)))
03639 transmit_response_reliable(p, res, &p->initreq);
03640 else
03641 transmit_response_reliable(p, "603 Declined", &p->initreq);
03642 p->invitestate = INV_TERMINATED;
03643 }
03644 } else {
03645 if (!p->pendinginvite) {
03646 char *audioqos = "";
03647 char *videoqos = "";
03648 if (p->rtp)
03649 audioqos = ast_rtp_get_quality(p->rtp, NULL);
03650 if (p->vrtp)
03651 videoqos = ast_rtp_get_quality(p->vrtp, NULL);
03652
03653 transmit_request_with_auth(p, SIP_BYE, 0, XMIT_RELIABLE, 1);
03654
03655
03656 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY)) {
03657 if (p->rtp)
03658 append_history(p, "RTCPaudio", "Quality:%s", audioqos);
03659 if (p->vrtp)
03660 append_history(p, "RTCPvideo", "Quality:%s", videoqos);
03661 }
03662 if (p->rtp && oldowner)
03663 pbx_builtin_setvar_helper(oldowner, "RTPAUDIOQOS", audioqos);
03664 if (p->vrtp && oldowner)
03665 pbx_builtin_setvar_helper(oldowner, "RTPVIDEOQOS", videoqos);
03666 } else {
03667
03668
03669 ast_set_flag(&p->flags[0], SIP_PENDINGBYE);
03670 ast_clear_flag(&p->flags[0], SIP_NEEDREINVITE);
03671 AST_SCHED_DEL(sched, p->waitid);
03672 if (sip_cancel_destroy(p))
03673 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
03674 }
03675 }
03676 }
03677 if (needdestroy)
03678 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
03679 ast_mutex_unlock(&p->lock);
03680 return 0;
03681 }
03682
03683
03684 static void try_suggested_sip_codec(struct sip_pvt *p)
03685 {
03686 int fmt;
03687 const char *codec;
03688
03689 codec = pbx_builtin_getvar_helper(p->owner, "SIP_CODEC");
03690 if (!codec)
03691 return;
03692
03693 fmt = ast_getformatbyname(codec);
03694 if (fmt) {
03695 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC} variable\n", codec);
03696 if (p->jointcapability & fmt) {
03697 p->jointcapability &= fmt;
03698 p->capability &= fmt;
03699 } else
03700 ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because it is not shared by both ends.\n");
03701 } else
03702 ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n", codec);
03703 return;
03704 }
03705
03706
03707
03708 static int sip_answer(struct ast_channel *ast)
03709 {
03710 int res = 0;
03711 struct sip_pvt *p = ast->tech_pvt;
03712
03713 ast_mutex_lock(&p->lock);
03714 if (ast->_state != AST_STATE_UP) {
03715 try_suggested_sip_codec(p);
03716
03717 ast_setstate(ast, AST_STATE_UP);
03718 if (option_debug)
03719 ast_log(LOG_DEBUG, "SIP answering channel: %s\n", ast->name);
03720 if (p->t38.state == T38_PEER_DIRECT) {
03721 p->t38.state = T38_ENABLED;
03722 if (option_debug > 1)
03723 ast_log(LOG_DEBUG,"T38State change to %d on channel %s\n", p->t38.state, ast->name);
03724 res = transmit_response_with_t38_sdp(p, "200 OK", &p->initreq, XMIT_CRITICAL);
03725 ast_set_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
03726 } else {
03727 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, XMIT_CRITICAL);
03728 ast_set_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
03729 }
03730 }
03731 ast_mutex_unlock(&p->lock);
03732 return res;
03733 }
03734
03735
03736 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
03737 {
03738 struct sip_pvt *p = ast->tech_pvt;
03739 int res = 0;
03740
03741 switch (frame->frametype) {
03742 case AST_FRAME_VOICE:
03743 if (!(frame->subclass & ast->nativeformats)) {
03744 char s1[512], s2[512], s3[512];
03745 ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %s(%d) read/write = %s(%d)/%s(%d)\n",
03746 frame->subclass,
03747 ast_getformatname_multiple(s1, sizeof(s1) - 1, ast->nativeformats & AST_FORMAT_AUDIO_MASK),
03748 ast->nativeformats & AST_FORMAT_AUDIO_MASK,
03749 ast_getformatname_multiple(s2, sizeof(s2) - 1, ast->readformat),
03750 ast->readformat,
03751 ast_getformatname_multiple(s3, sizeof(s3) - 1, ast->writeformat),
03752 ast->writeformat);
03753 return 0;
03754 }
03755 if (p) {
03756 ast_mutex_lock(&p->lock);
03757 if (p->rtp) {
03758
03759 if ((ast->_state != AST_STATE_UP) &&
03760 !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
03761 !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
03762 ast_rtp_new_source(p->rtp);
03763 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, XMIT_UNRELIABLE);
03764 ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);
03765 }
03766 p->lastrtptx = time(NULL);
03767 res = ast_rtp_write(p->rtp, frame);
03768 }
03769 ast_mutex_unlock(&p->lock);
03770 }
03771 break;
03772 case AST_FRAME_VIDEO:
03773 if (p) {
03774 ast_mutex_lock(&p->lock);
03775 if (p->vrtp) {
03776
03777 if ((ast->_state != AST_STATE_UP) &&
03778 !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
03779 !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
03780 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, XMIT_UNRELIABLE);
03781 ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);
03782 }
03783 p->lastrtptx = time(NULL);
03784 res = ast_rtp_write(p->vrtp, frame);
03785 }
03786 ast_mutex_unlock(&p->lock);
03787 }
03788 break;
03789 case AST_FRAME_IMAGE:
03790 return 0;
03791 break;
03792 case AST_FRAME_MODEM:
03793 if (p) {
03794 ast_mutex_lock(&p->lock);
03795
03796
03797
03798
03799 if (p->udptl && ast->_state == AST_STATE_UP)
03800 res = ast_udptl_write(p->udptl, frame);
03801 ast_mutex_unlock(&p->lock);
03802 }
03803 break;
03804 default:
03805 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
03806 return 0;
03807 }
03808
03809 return res;
03810 }
03811
03812
03813
03814 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
03815 {
03816 int ret = -1;
03817 struct sip_pvt *p;
03818
03819 if (newchan && ast_test_flag(newchan, AST_FLAG_ZOMBIE) && option_debug)
03820 ast_log(LOG_DEBUG, "New channel is zombie\n");
03821 if (oldchan && ast_test_flag(oldchan, AST_FLAG_ZOMBIE) && option_debug)
03822 ast_log(LOG_DEBUG, "Old channel is zombie\n");
03823
03824 if (!newchan || !newchan->tech_pvt) {
03825 if (!newchan)
03826 ast_log(LOG_WARNING, "No new channel! Fixup of %s failed.\n", oldchan->name);
03827 else
03828 ast_log(LOG_WARNING, "No SIP tech_pvt! Fixup of %s failed.\n", oldchan->name);
03829 return -1;
03830 }
03831 p = newchan->tech_pvt;
03832
03833 if (!p) {
03834 ast_log(LOG_WARNING, "No pvt after masquerade. Strange things may happen\n");
03835 return -1;
03836 }
03837
03838 ast_mutex_lock(&p->lock);
03839 append_history(p, "Masq", "Old channel: %s\n", oldchan->name);
03840 append_history(p, "Masq (cont)", "...new owner: %s\n", newchan->name);
03841 if (p->owner != oldchan)
03842 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
03843 else {
03844 p->owner = newchan;
03845
03846
03847
03848
03849
03850
03851 sip_set_rtp_peer(newchan, NULL, NULL, 0, 0);
03852 ret = 0;
03853 }
03854 if (option_debug > 2)
03855 ast_log(LOG_DEBUG, "SIP Fixup: New owner for dialogue %s: %s (Old parent: %s)\n", p->callid, p->owner->name, oldchan->name);
03856
03857 ast_mutex_unlock(&p->lock);
03858 return ret;
03859 }
03860
03861 static int sip_senddigit_begin(struct ast_channel *ast, char digit)
03862 {
03863 struct sip_pvt *p = ast->tech_pvt;
03864 int res = 0;
03865
03866 ast_mutex_lock(&p->lock);
03867 switch (ast_test_flag(&p->flags[0], SIP_DTMF)) {
03868 case SIP_DTMF_INBAND:
03869 res = -1;
03870 break;
03871 case SIP_DTMF_RFC2833:
03872 if (p->rtp)
03873 ast_rtp_senddigit_begin(p->rtp, digit);
03874 break;
03875 default:
03876 break;
03877 }
03878 ast_mutex_unlock(&p->lock);
03879
03880 return res;
03881 }
03882
03883
03884
03885 static int sip_senddigit_end(struct ast_channel *ast, char digit, unsigned int duration)
03886 {
03887 struct sip_pvt *p = ast->tech_pvt;
03888 int res = 0;
03889
03890 ast_mutex_lock(&p->lock);
03891 switch (ast_test_flag(&p->flags[0], SIP_DTMF)) {
03892 case SIP_DTMF_INFO:
03893 transmit_info_with_digit(p, digit, duration);
03894 break;
03895 case SIP_DTMF_RFC2833:
03896 if (p->rtp)
03897 ast_rtp_senddigit_end(p->rtp, digit);
03898 break;
03899 case SIP_DTMF_INBAND:
03900 res = -1;
03901 break;
03902 }
03903 ast_mutex_unlock(&p->lock);
03904
03905 return res;
03906 }
03907
03908
03909 static int sip_transfer(struct ast_channel *ast, const char *dest)
03910 {
03911 struct sip_pvt *p = ast->tech_pvt;
03912 int res;
03913
03914 if (dest == NULL)
03915 dest = "";
03916 ast_mutex_lock(&p->lock);
03917 if (ast->_state == AST_STATE_RING)
03918 res = sip_sipredirect(p, dest);
03919 else
03920 res = transmit_refer(p, dest);
03921 ast_mutex_unlock(&p->lock);
03922 return res;
03923 }
03924
03925
03926
03927
03928
03929
03930 static int sip_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen)
03931 {
03932 struct sip_pvt *p = ast->tech_pvt;
03933 int res = 0;
03934
03935 ast_mutex_lock(&p->lock);
03936 switch(condition) {
03937 case AST_CONTROL_RINGING:
03938 if (ast->_state == AST_STATE_RING) {
03939 p->invitestate = INV_EARLY_MEDIA;
03940 if (!ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) ||
03941 (ast_test_flag(&p->flags[0], SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER)) {
03942
03943 transmit_response(p, "180 Ringing", &p->initreq);
03944 ast_set_flag(&p->flags[0], SIP_RINGING);
03945 if (ast_test_flag(&p->flags[0], SIP_PROG_INBAND) != SIP_PROG_INBAND_YES)
03946 break;
03947 } else {
03948
03949 }
03950 }
03951 res = -1;
03952 break;
03953 case AST_CONTROL_BUSY:
03954 if (ast->_state != AST_STATE_UP) {
03955 transmit_response_reliable(p, "486 Busy Here", &p->initreq);
03956 p->invitestate = INV_COMPLETED;
03957 sip_alreadygone(p);
03958 ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
03959 break;
03960 }
03961 res = -1;
03962 break;
03963 case AST_CONTROL_CONGESTION:
03964 if (ast->_state != AST_STATE_UP) {
03965 transmit_response_reliable(p, "503 Service Unavailable", &p->initreq);
03966 p->invitestate = INV_COMPLETED;
03967 sip_alreadygone(p);
03968 ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
03969 break;
03970 }
03971 res = -1;
03972 break;
03973 case AST_CONTROL_PROCEEDING:
03974 if ((ast->_state != AST_STATE_UP) &&
03975 !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
03976 !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
03977 transmit_response(p, "100 Trying", &p->initreq);
03978 p->invitestate = INV_PROCEEDING;
03979 break;
03980 }
03981 res = -1;
03982 break;
03983 case AST_CONTROL_PROGRESS:
03984 if ((ast->_state != AST_STATE_UP) &&
03985 !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
03986 !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
03987 p->invitestate = INV_EARLY_MEDIA;
03988 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, XMIT_UNRELIABLE);
03989 ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);
03990 break;
03991 }
03992 res = -1;
03993 break;
03994 case AST_CONTROL_HOLD:
03995 ast_rtp_new_source(p->rtp);
03996 ast_moh_start(ast, data, p->mohinterpret);
03997 break;
03998 case AST_CONTROL_UNHOLD:
03999 ast_rtp_new_source(p->rtp);
04000 ast_moh_stop(ast);
04001 break;
04002 case AST_CONTROL_VIDUPDATE:
04003 if (p->vrtp && !ast_test_flag(&p->flags[0], SIP_NOVIDEO)) {
04004 transmit_info_with_vidupdate(p);
04005
04006 } else
04007 res = -1;
04008 break;
04009 case AST_CONTROL_SRCUPDATE:
04010 ast_rtp_new_source(p->rtp);
04011 break;
04012 case -1:
04013 res = -1;
04014 break;
04015 default:
04016 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
04017 res = -1;
04018 break;
04019 }
04020 ast_mutex_unlock(&p->lock);
04021 return res;
04022 }
04023
04024
04025
04026
04027
04028
04029
04030 static struct ast_channel *sip_new(struct sip_pvt *i, int state, const char *title)
04031 {
04032 struct ast_channel *tmp;
04033 struct ast_variable *v = NULL;
04034 int fmt;
04035 int what;
04036 int needvideo = 0, video = 0;
04037 char *decoded_exten;
04038
04039 if (option_debug != 0) {
04040 ast_verbose(VERBOSE_PREFIX_3 "NEW SIP CHANNEL, title: <%s>\n", title?title:"Null");
04041 ast_verbose(VERBOSE_PREFIX_3 "from: %s\n", i->from);
04042 ast_verbose(VERBOSE_PREFIX_3 "username: <%s>\n", i->username);
04043 ast_verbose(VERBOSE_PREFIX_3 "peername: <%s>\n", i->peername);
04044 ast_verbose(VERBOSE_PREFIX_3 "fromdomain: %s\n", i->fromdomain);
04045 ast_verbose(VERBOSE_PREFIX_3 "fromuser: %s\n", i->fromuser);
04046 ast_verbose(VERBOSE_PREFIX_3 "fromname: %s\n", i->fromname);
04047 ast_verbose(VERBOSE_PREFIX_3 "fullcontact: %s\n", i->fullcontact);
04048 }
04049
04050 {
04051 char my_name[128];
04052 const char *f, *fromdomain = NULL;
04053
04054 if (!ast_strlen_zero(i->fromdomain) && strchr(i->fromdomain,':'))
04055 fromdomain = strchr(i->fromdomain,':') + 1;
04056 else
04057 fromdomain = i->fromdomain;
04058
04059 if (!ast_strlen_zero(i->username)) {
04060 if (!ast_strlen_zero(title) && strcmp(i->username, title)) {
04061
04062 snprintf(my_name, sizeof(my_name), "%s@%s", i->username, title);
04063 } else {
04064
04065 snprintf(my_name, sizeof(my_name), "%s", i->username);
04066 }
04067 } else {
04068 if (!ast_strlen_zero(i->peername)) {
04069
04070 snprintf(my_name, sizeof(my_name), "%s", i->peername);
04071 } else {
04072 if (!ast_strlen_zero(title)) {
04073 snprintf(my_name, sizeof(my_name), "%s", title);
04074 } else if (!ast_strlen_zero(i->from)) {
04075 f = i->from;
04076 if (!strncmp(f, "sip:", 4))
04077 f += 4;
04078 snprintf(my_name, sizeof(my_name), "%s", f);
04079 } else {
04080 snprintf(my_name, sizeof(my_name), "%s", fromdomain);
04081 }
04082 }
04083 }
04084 ast_mutex_unlock(&i->lock);
04085
04086 tmp = ast_channel_alloc(1, state, i->cid_num, i->cid_name, i->accountcode, i->exten, i->context, i->amaflags, "SIP/%s-%08x", my_name, (int)(long) i);
04087
04088 }
04089 if (!tmp) {
04090 ast_log(LOG_WARNING, "Unable to allocate AST channel structure for SIP channel\n");
04091 ast_mutex_lock(&i->lock);
04092 return NULL;
04093 }
04094 ast_mutex_lock(&i->lock);
04095
04096 if (ast_test_flag(&i->flags[0], SIP_DTMF) == SIP_DTMF_INFO)
04097 tmp->tech = &sip_tech_info;
04098 else
04099 tmp->tech = &sip_tech;
04100
04101
04102
04103 if (i->jointcapability) {
04104 what = i->jointcapability;
04105 video = i->jointcapability & AST_FORMAT_VIDEO_MASK;
04106 } else if (i->capability) {
04107 what = i->capability;
04108 video = i->capability & AST_FORMAT_VIDEO_MASK;
04109 } else {
04110 what = global_capability;
04111 video = global_capability & AST_FORMAT_VIDEO_MASK;
04112 }
04113
04114
04115 tmp->nativeformats = ast_codec_choose(&i->prefs, what, 1) | video;
04116 if (option_debug > 2) {
04117 char buf[SIPBUFSIZE];
04118 ast_log(LOG_DEBUG, "*** Our native formats are %s \n", ast_getformatname_multiple(buf, SIPBUFSIZE, tmp->nativeformats));
04119 ast_log(LOG_DEBUG, "*** Joint capabilities are %s \n", ast_getformatname_multiple(buf, SIPBUFSIZE, i->jointcapability));
04120 ast_log(LOG_DEBUG, "*** Our capabilities are %s \n", ast_getformatname_multiple(buf, SIPBUFSIZE, i->capability));
04121 ast_log(LOG_DEBUG, "*** AST_CODEC_CHOOSE formats are %s \n", ast_getformatname_multiple(buf, SIPBUFSIZE, ast_codec_choose(&i->prefs, what, 1)));
04122 if (i->prefcodec)
04123 ast_log(LOG_DEBUG, "*** Our preferred formats from the incoming channel are %s \n", ast_getformatname_multiple(buf, SIPBUFSIZE, i->prefcodec));
04124 }
04125
04126
04127 fmt = ast_best_codec(tmp->nativeformats);
04128
04129
04130
04131
04132
04133 if (i->vrtp) {
04134 if (i->prefcodec)
04135 needvideo = i->prefcodec & AST_FORMAT_VIDEO_MASK;
04136 else
04137 needvideo = i->jointcapability & AST_FORMAT_VIDEO_MASK;
04138 }
04139
04140 if (option_debug > 2) {
04141 if (needvideo)
04142 ast_log(LOG_DEBUG, "This channel can handle video! HOLLYWOOD next!\n");
04143 else
04144 ast_log(LOG_DEBUG, "This channel will not be able to handle video.\n");
04145 }
04146
04147
04148
04149 if (ast_test_flag(&i->flags[0], SIP_DTMF) == SIP_DTMF_INBAND) {
04150 i->vad = ast_dsp_new();
04151 ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
04152 if (global_relaxdtmf)
04153 ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
04154 }
04155 if (i->rtp) {
04156 tmp->fds[0] = ast_rtp_fd(i->rtp);
04157 tmp->fds[1] = ast_rtcp_fd(i->rtp);
04158 }
04159 if (needvideo && i->vrtp) {
04160 tmp->fds[2] = ast_rtp_fd(i->vrtp);
04161 tmp->fds[3] = ast_rtcp_fd(i->vrtp);
04162 }
04163 if (i->udptl) {
04164 tmp->fds[5] = ast_udptl_fd(i->udptl);
04165 }
04166 if (state == AST_STATE_RING)
04167 tmp->rings = 1;
04168 tmp->adsicpe = AST_ADSI_UNAVAILABLE;
04169 tmp->writeformat = fmt;
04170 tmp->rawwriteformat = fmt;
04171 tmp->readformat = fmt;
04172 tmp->rawreadformat = fmt;
04173 tmp->tech_pvt = i;
04174
04175 tmp->callgroup = i->callgroup;
04176 tmp->pickupgroup = i->pickupgroup;
04177 tmp->cid.cid_pres = i->callingpres;
04178 if (!ast_strlen_zero(i->accountcode))
04179 ast_string_field_set(tmp, accountcode, i->accountcode);
04180 if (i->amaflags)
04181 tmp->amaflags = i->amaflags;
04182 if (!ast_strlen_zero(i->language))
04183 ast_string_field_set(tmp, language, i->language);
04184 i->owner = tmp;
04185 ast_module_ref(ast_module_info->self);
04186 ast_copy_string(tmp->context, i->context, sizeof(tmp->context));
04187
04188
04189
04190
04191 decoded_exten = ast_strdupa(i->exten);
04192 ast_uri_decode(decoded_exten);
04193 ast_copy_string(tmp->exten, decoded_exten, sizeof(tmp->exten));
04194
04195
04196
04197 tmp->cid.cid_ani = ast_strdup(i->cid_num);
04198 if (!ast_strlen_zero(i->rdnis))
04199 tmp->cid.cid_rdnis = ast_strdup(i->rdnis);
04200
04201 if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
04202 tmp->cid.cid_dnid = ast_strdup(i->exten);
04203
04204 tmp->priority = 1;
04205 if (!ast_strlen_zero(i->uri))
04206 pbx_builtin_setvar_helper(tmp, "SIPURI", i->uri);
04207 if (!ast_strlen_zero(i->domain))
04208 pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
04209 if (!ast_strlen_zero(i->useragent))
04210 pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
04211 if (!ast_strlen_zero(i->callid))
04212 pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
04213 if (i->rtp)
04214 ast_jb_configure(tmp, &global_jbconf);
04215
04216
04217 if (i->udptl && i->t38.state == T38_PEER_DIRECT)
04218 pbx_builtin_setvar_helper(tmp, "_T38CALL", "1");
04219
04220
04221 for (v = i->chanvars ; v ; v = v->next)
04222 pbx_builtin_setvar_helper(tmp, v->name, v->value);
04223
04224 if (state != AST_STATE_DOWN && ast_pbx_start(tmp)) {
04225 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
04226 tmp->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
04227 ast_hangup(tmp);
04228 tmp = NULL;
04229 }
04230
04231 if (!ast_test_flag(&i->flags[0], SIP_NO_HISTORY))
04232 append_history(i, "NewChan", "Channel %s - from %s", tmp->name, i->callid);
04233
04234 return tmp;
04235 }
04236
04237
04238 static char *get_body_by_line(const char *line, const char *name, int nameLen)
04239 {
04240 if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=')
04241 return ast_skip_blanks(line + nameLen + 1);
04242
04243 return "";
04244 }
04245
04246
04247
04248
04249
04250 static const char *get_sdp_iterate(int *start, struct sip_request *req, const char *name)
04251 {
04252 int len = strlen(name);
04253
04254 while (*start < req->sdp_end) {
04255 const char *r = get_body_by_line(req->line[(*start)++], name, len);
04256 if (r[0] != '\0')
04257 return r;
04258 }
04259
04260 return "";
04261 }
04262
04263
04264 static const char *get_sdp(struct sip_request *req, const char *name)
04265 {
04266 int dummy = 0;
04267
04268 return get_sdp_iterate(&dummy, req, name);
04269 }
04270
04271
04272 static char *get_body(struct sip_request *req, char *name)
04273 {
04274 int x;
04275 int len = strlen(name);
04276 char *r;
04277
04278 for (x = 0; x < req->lines; x++) {
04279 r = get_body_by_line(req->line[x], name, len);
04280 if (r[0] != '\0')
04281 return r;
04282 }
04283
04284 return "";
04285 }
04286
04287
04288 static const char *find_alias(const char *name, const char *_default)
04289 {
04290
04291 static const struct cfalias {
04292 char * const fullname;
04293 char * const shortname;
04294 } aliases[] = {
04295 { "Content-Type", "c" },
04296 { "Content-Encoding", "e" },
04297 { "From", "f" },
04298 { "Call-ID", "i" },
04299 { "Contact", "m" },
04300 { "Content-Length", "l" },
04301 { "Subject", "s" },
04302 { "To", "t" },
04303 { "Supported", "k" },
04304 { "Refer-To", "r" },
04305 { "Referred-By", "b" },
04306 { "Allow-Events", "u" },
04307 { "Event", "o" },
04308 { "Via", "v" },
04309 { "Accept-Contact", "a" },
04310 { "Reject-Contact", "j" },
04311 { "Request-Disposition", "d" },
04312 { "Session-Expires", "x" },
04313 { "Identity", "y" },
04314 { "Identity-Info", "n" },
04315 };
04316 int x;
04317
04318 for (x=0; x<sizeof(aliases) / sizeof(aliases[0]); x++)
04319 if (!strcasecmp(aliases[x].fullname, name))
04320 return aliases[x].shortname;
04321
04322 return _default;
04323 }
04324
04325 static const char *__get_header(const struct sip_request *req, const char *name, int *start)
04326 {
04327 int pass;
04328
04329
04330
04331
04332
04333
04334
04335
04336
04337
04338 for (pass = 0; name && pass < 2;pass++) {
04339 int x, len = strlen(name);
04340 for (x=*start; x<req->headers; x++) {
04341 if (!strncasecmp(req->header[x], name, len)) {
04342 char *r = req->header[x] + len;
04343 if (pedanticsipchecking)
04344 r = ast_skip_blanks(r);
04345
04346 if (*r == ':') {
04347 *start = x+1;
04348 return ast_skip_blanks(r+1);
04349 }
04350 }
04351 }
04352 if (pass == 0)
04353 name = find_alias(name, NULL);
04354 }
04355
04356
04357 return "";
04358 }
04359
04360
04361 static const char *get_header(const struct sip_request *req, const char *name)
04362 {
04363 int start = 0;
04364 return __get_header(req, name, &start);
04365 }
04366
04367
04368 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p, int *faxdetect)
04369 {
04370
04371 struct ast_frame *f;
04372
04373 if (!p->rtp) {
04374
04375 return &ast_null_frame;
04376 }
04377
04378 switch(ast->fdno) {
04379 case 0:
04380 f = ast_rtp_read(p->rtp);
04381 break;
04382 case 1:
04383 f = ast_rtcp_read(p->rtp);
04384 break;
04385 case 2:
04386 f = ast_rtp_read(p->vrtp);
04387 break;
04388 case 3:
04389 f = ast_rtcp_read(p->vrtp);
04390 break;
04391 case 5:
04392 f = ast_udptl_read(p->udptl);
04393 break;
04394 default:
04395 f = &ast_null_frame;
04396 }
04397
04398 if (f && (f->frametype == AST_FRAME_DTMF) &&
04399 (ast_test_flag(&p->flags[0], SIP_DTMF) != SIP_DTMF_RFC2833))
04400 return &ast_null_frame;
04401
04402
04403 if (!p->owner || (f && f->frametype != AST_FRAME_VOICE))
04404 return f;
04405
04406 if (f && f->subclass != (p->owner->nativeformats & AST_FORMAT_AUDIO_MASK)) {
04407 if (!(f->subclass & p->jointcapability)) {
04408 if (option_debug) {
04409 ast_log(LOG_DEBUG, "Bogus frame of format '%s' received from '%s'!\n",
04410 ast_getformatname(f->subclass), p->owner->name);
04411 }
04412 return &ast_null_frame;
04413 }
04414 if (option_debug)
04415 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
04416 p->owner->nativeformats = (p->owner->nativeformats & AST_FORMAT_VIDEO_MASK) | f->subclass;
04417 ast_set_read_format(p->owner, p->owner->readformat);
04418 ast_set_write_format(p->owner, p->owner->writeformat);
04419 }
04420
04421 if (f && (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_INBAND) && p->vad) {
04422 f = ast_dsp_process(p->owner, p->vad, f);
04423 if (f && f->frametype == AST_FRAME_DTMF) {
04424 if (ast_test_flag(&p->t38.t38support, SIP_PAGE2_T38SUPPORT_UDPTL) && f->subclass == 'f') {
04425 if (option_debug)
04426 ast_log(LOG_DEBUG, "Fax CNG detected on %s\n", ast->name);
04427 *faxdetect = 1;
04428 } else if (option_debug) {
04429 ast_log(LOG_DEBUG, "* Detected inband DTMF '%c'\n", f->subclass);
04430 }
04431 }
04432 }
04433
04434 return f;
04435 }
04436
04437
04438 static struct ast_frame *sip_read(struct ast_channel *ast)
04439 {
04440 struct ast_frame *fr;
04441 struct sip_pvt *p = ast->tech_pvt;
04442 int faxdetected = FALSE;
04443
04444 ast_mutex_lock(&p->lock);
04445 fr = sip_rtp_read(ast, p, &faxdetected);
04446 p->lastrtprx = time(NULL);
04447
04448
04449
04450 if (faxdetected && ast_test_flag(&p->t38.t38support, SIP_PAGE2_T38SUPPORT_UDPTL) && (p->t38.state == T38_DISABLED) && !(ast_bridged_channel(ast))) {
04451 if (!ast_test_flag(&p->flags[0], SIP_GOTREFER)) {
04452 if (!p->pendinginvite) {
04453 if (option_debug > 2)
04454 ast_log(LOG_DEBUG, "Sending reinvite on SIP (%s) for T.38 negotiation.\n",ast->name);
04455 p->t38.state = T38_LOCAL_REINVITE;
04456 transmit_reinvite_with_t38_sdp(p);
04457 if (option_debug > 1)
04458 ast_log(LOG_DEBUG, "T38 state changed to %d on channel %s\n", p->t38.state, ast->name);
04459 }
04460 } else if (!ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
04461 if (option_debug > 2)
04462 ast_log(LOG_DEBUG, "Deferring reinvite on SIP (%s) - it will be re-negotiated for T.38\n", ast->name);
04463 ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
04464 }
04465 }
04466
04467
04468 if (fr && fr->frametype == AST_FRAME_VOICE && p->invitestate != INV_EARLY_MEDIA && ast->_state != AST_STATE_UP) {
04469 fr = &ast_null_frame;
04470 }
04471
04472 ast_mutex_unlock(&p->lock);
04473 return fr;
04474 }
04475
04476
04477
04478 static char *generate_random_string(char *buf, size_t size)
04479 {
04480 long val[4];
04481 int x;
04482
04483 for (x=0; x<4; x++)
04484 val[x] = ast_random();
04485 snprintf(buf, size, "%08lx%08lx%08lx%08lx", val[0], val[1], val[2], val[3]);
04486
04487 return buf;
04488 }
04489
04490
04491 static void build_callid_pvt(struct sip_pvt *pvt)
04492 {
04493 char buf[33];
04494
04495 const char *host = S_OR(pvt->fromdomain, ast_inet_ntoa(pvt->ourip));
04496
04497 ast_string_field_build(pvt, callid, "%s@%s", generate_random_string(buf, sizeof(buf)), host);
04498
04499 }
04500
04501
04502 static void build_callid_registry(struct sip_registry *reg, struct in_addr ourip, const char *fromdomain)
04503 {
04504 char buf[33];
04505
04506 const char *host = S_OR(fromdomain, ast_inet_ntoa(ourip));
04507
04508 ast_string_field_build(reg, callid, "%s@%s", generate_random_string(buf, sizeof(buf)), host);
04509 }
04510
04511
04512 static void make_our_tag(char *tagbuf, size_t len)
04513 {
04514 snprintf(tagbuf, len, "as%08lx", ast_random());
04515 }
04516
04517
04518 static struct sip_pvt *sip_alloc(ast_string_field callid, struct sockaddr_in *sin,
04519 int useglobal_nat, const int intended_method)
04520 {
04521 struct sip_pvt *p;
04522
04523 if (!(p = ast_calloc(1, sizeof(*p))))
04524 return NULL;
04525
04526 if (ast_string_field_init(p, 512)) {
04527 free(p);
04528 return NULL;
04529 }
04530
04531 ast_mutex_init(&p->lock);
04532
04533 p->method = intended_method;
04534 p->initid = -1;
04535 p->waitid = -1;
04536 p->autokillid = -1;
04537 p->subscribed = NONE;
04538 p->stateid = -1;
04539 p->sockfd=-1;
04540 p->prefs = default_prefs;
04541
04542 if (intended_method != SIP_OPTIONS)
04543 p->timer_t1 = 500;
04544
04545 if (sin) {
04546 p->sa = *sin;
04547 if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
04548 p->ourip = __ourip;
04549 } else
04550 p->ourip = __ourip;
04551
04552
04553 ast_copy_flags(&p->flags[0], &global_flags[0], SIP_FLAGS_TO_COPY);
04554 ast_copy_flags(&p->flags[1], &global_flags[1], SIP_PAGE2_FLAGS_TO_COPY);
04555
04556 ast_set2_flag(&p->flags[0], !recordhistory, SIP_NO_HISTORY);
04557
04558 p->branch = ast_random();
04559 make_our_tag(p->tag, sizeof(p->tag));
04560 p->ocseq = INITIAL_CSEQ;
04561
04562 if (sip_methods[intended_method].need_rtp) {
04563 p->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
04564
04565 if (ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT))
04566 p->vrtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
04567 if (ast_test_flag(&p->flags[1], SIP_PAGE2_T38SUPPORT))
04568 p->udptl = ast_udptl_new_with_bindaddr(sched, io, 0, bindaddr.sin_addr);
04569 if (!p->rtp || (ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT) && !p->vrtp)) {
04570 ast_log(LOG_WARNING, "Unable to create RTP audio %s session: %s\n",
04571 ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT) ? "and video" : "", strerror(errno));
04572 ast_mutex_destroy(&p->lock);
04573 if (p->chanvars) {
04574 ast_variables_destroy(p->chanvars);
04575 p->chanvars = NULL;
04576 }
04577 free(p);
04578 return NULL;
04579 }
04580 ast_rtp_setdtmf(p->rtp, ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833);
04581 ast_rtp_setdtmfcompensate(p->rtp, ast_test_flag(&p->flags[1], SIP_PAGE2_RFC2833_COMPENSATE));
04582 ast_rtp_settos(p->rtp, global_tos_audio);
04583 ast_rtp_set_rtptimeout(p->rtp, global_rtptimeout);
04584 ast_rtp_set_rtpholdtimeout(p->rtp, global_rtpholdtimeout);
04585 ast_rtp_set_rtpkeepalive(p->rtp, global_rtpkeepalive);
04586 if (p->vrtp) {
04587 ast_rtp_settos(p->vrtp, global_tos_video);
04588 ast_rtp_setdtmf(p->vrtp, 0);
04589 ast_rtp_setdtmfcompensate(p->vrtp, 0);
04590 ast_rtp_set_rtptimeout(p->vrtp, global_rtptimeout);
04591 ast_rtp_set_rtpholdtimeout(p->vrtp, global_rtpholdtimeout);
04592 ast_rtp_set_rtpkeepalive(p->vrtp, global_rtpkeepalive);
04593 }
04594 if (p->udptl)
04595 ast_udptl_settos(p->udptl, global_tos_audio);
04596 p->maxcallbitrate = default_maxcallbitrate;
04597 p->autoframing = global_autoframing;
04598 ast_rtp_codec_setpref(p->rtp, &p->prefs);
04599 }
04600
04601 if (useglobal_nat && sin) {
04602
04603 ast_copy_flags(&p->flags[0], &global_flags[0], SIP_NAT);
04604 p->recv = *sin;
04605 do_setnat(p, ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE);
04606 }
04607
04608 if (p->method != SIP_REGISTER)
04609 ast_string_field_set(p, fromdomain, default_fromdomain);
04610 build_via(p);
04611 if (!callid)
04612 build_callid_pvt(p);
04613 else
04614 ast_string_field_set(p, callid, callid);
04615
04616 ast_string_field_set(p, mohinterpret, default_mohinterpret);
04617 ast_string_field_set(p, mohsuggest, default_mohsuggest);
04618 p->capability = global_capability;
04619 p->allowtransfer = global_allowtransfer;
04620 if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
04621 (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO))
04622 p->noncodeccapability |= AST_RTP_DTMF;
04623 if (p->udptl) {
04624 p->t38.capability = global_t38_capability;
04625 if (ast_udptl_get_error_correction_scheme(p->udptl) == UDPTL_ERROR_CORRECTION_REDUNDANCY)
04626 p->t38.capability |= T38FAX_UDP_EC_REDUNDANCY;
04627 else if (ast_udptl_get_error_correction_scheme(p->udptl) == UDPTL_ERROR_CORRECTION_FEC)
04628 p->t38.capability |= T38FAX_UDP_EC_FEC;
04629 else if (ast_udptl_get_error_correction_scheme(p->udptl) == UDPTL_ERROR_CORRECTION_NONE)
04630 p->t38.capability |= T38FAX_UDP_EC_NONE;
04631 p->t38.capability |= T38FAX_RATE_MANAGEMENT_TRANSFERED_TCF;
04632 p->t38.jointcapability = p->t38.capability;
04633 }
04634 ast_string_field_set(p, context, default_context);
04635
04636
04637 ast_mutex_lock(&iflock);
04638 p->next = iflist;
04639 iflist = p;
04640 ast_mutex_unlock(&iflock);
04641 if (option_debug)
04642 ast_log(LOG_DEBUG, "Allocating new SIP dialog for %s - %s (%s)\n", callid ? callid : "(No Call-ID)", sip_methods[intended_method].text, p->rtp ? "With RTP" : "No RTP");
04643 return p;
04644 }
04645
04646
04647
04648 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin, const int intended_method)
04649 {
04650 struct sip_pvt *p = NULL;
04651 char *tag = "";
04652 char totag[128];
04653 char fromtag[128];
04654 const char *callid = get_header(req, "Call-ID");
04655 const char *from = get_header(req, "From");
04656 const char *to = get_header(req, "To");
04657 const char *cseq = get_header(req, "Cseq");
04658
04659
04660
04661 if (ast_strlen_zero(callid) || ast_strlen_zero(to) ||
04662 ast_strlen_zero(from) || ast_strlen_zero(cseq))
04663 return NULL;
04664
04665 if (pedanticsipchecking) {
04666
04667
04668
04669
04670
04671
04672 if (gettag(req, "To", totag, sizeof(totag)))
04673 ast_set_flag(req, SIP_PKT_WITH_TOTAG);
04674 gettag(req, "From", fromtag, sizeof(fromtag));
04675
04676 tag = (req->method == SIP_RESPONSE) ? totag : fromtag;
04677
04678 if (option_debug > 4 )
04679 ast_log(LOG_DEBUG, "= Looking for Call ID: %s (Checking %s) --From tag %s --To-tag %s \n", callid, req->method==SIP_RESPONSE ? "To" : "From", fromtag, totag);
04680 }
04681
04682 ast_mutex_lock(&iflock);
04683 for (p = iflist; p; p = p->next) {
04684
04685 int found = FALSE;
04686 if (ast_strlen_zero(p->callid))
04687 continue;
04688 if (req->method == SIP_REGISTER)
04689 found = (!strcmp(p->callid, callid));
04690 else {
04691 found = !strcmp(p->callid, callid);
04692 if (pedanticsipchecking && found) {
04693 found = ast_strlen_zero(tag) || ast_strlen_zero(p->theirtag) || !ast_test_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED) || !strcmp(p->theirtag, tag);
04694 }
04695 }
04696
04697 if (option_debug > 4)
04698 ast_log(LOG_DEBUG, "= %s Their Call ID: %s Their Tag %s Our tag: %s\n", found ? "Found" : "No match", p->callid, p->theirtag, p->tag);
04699
04700
04701 if (pedanticsipchecking && found && req->method != SIP_RESPONSE) {
04702 if (p->tag[0] == '\0' && totag[0]) {
04703
04704 found = FALSE;
04705 } else if (totag[0]) {
04706 if (strcmp(totag, p->tag)) {
04707 found = FALSE;
04708 }
04709 }
04710 if (!found && option_debug > 4)
04711 ast_log(LOG_DEBUG, "= Being pedantic: This is not our match on request: Call ID: %s Ourtag <null> Totag %s Method %s\n", p->callid, totag, sip_methods[req->method].text);
04712 }
04713 if (found) {
04714
04715 ast_mutex_lock(&p->lock);
04716 ast_mutex_unlock(&iflock);
04717 return p;
04718 }
04719 }
04720 ast_mutex_unlock(&iflock);
04721
04722
04723 if (sip_methods[intended_method].can_create == CAN_CREATE_DIALOG) {
04724 if (intended_method == SIP_REFER) {
04725
04726 transmit_response_using_temp(callid, sin, 1, intended_method, req, "603 Declined (no dialog)");
04727 } else if (intended_method == SIP_NOTIFY) {
04728
04729
04730 transmit_response_using_temp(callid, sin, 1, intended_method, req, "489 Bad event");
04731 } else {
04732
04733 if ((p = sip_alloc(callid, sin, 1, intended_method))) {
04734
04735 ast_mutex_lock(&p->lock);
04736 } else {
04737
04738
04739
04740
04741
04742
04743
04744
04745 transmit_response_using_temp(callid, sin, 1, intended_method, req, "500 Server internal error");
04746 if (option_debug > 3)
04747 ast_log(LOG_DEBUG, "Failed allocating SIP dialog, sending 500 Server internal error and giving up\n");
04748 }
04749 }
04750 return p;
04751 } else if( sip_methods[intended_method].can_create == CAN_CREATE_DIALOG_UNSUPPORTED_METHOD) {
04752
04753 transmit_response_using_temp(callid, sin, 1, intended_method, req, "501 Method Not Implemented");
04754 } else if (intended_method != SIP_RESPONSE && intended_method != SIP_ACK) {
04755
04756
04757
04758 transmit_response_using_temp(callid, sin, 1, intended_method, req, "481 Call leg/transaction does not exist");
04759 }
04760
04761
04762
04763 return p;
04764 }
04765
04766
04767 static int sip_register(char *value, int lineno)
04768 {
04769 struct sip_registry *reg;
04770 int portnum = 0;
04771 char username[256] = "";
04772 char *hostname=NULL, *secret=NULL, *authuser=NULL;
04773 char *porta=NULL;
04774 char *contact=NULL;
04775
04776 if (!value)
04777 return -1;
04778 ast_copy_string(username, value, sizeof(username));
04779
04780 hostname = strrchr(username, '@');
04781 if (hostname)
04782 *hostname++ = '\0';
04783 if (ast_strlen_zero(username) || ast_strlen_zero(hostname)) {
04784 ast_log(LOG_WARNING, "Format for registration is user[:secret[:authuser]]@host[:port][/contact] at line %d\n", lineno);
04785 return -1;
04786 }
04787
04788 secret = strchr(username, ':');
04789 if (secret) {
04790 *secret++ = '\0';
04791 authuser = strchr(secret, ':');
04792 if (authuser)
04793 *authuser++ = '\0';
04794 }
04795
04796 contact = strchr(hostname, '/');
04797 if (contact)
04798 *contact++ = '\0';
04799 if (ast_strlen_zero(contact))
04800 contact = "s";
04801 porta = strchr(hostname, ':');
04802 if (porta) {
04803 *porta++ = '\0';
04804 portnum = atoi(porta);
04805 if (portnum == 0) {
04806 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
04807 return -1;
04808 }
04809 }
04810 if (!(reg = ast_calloc(1, sizeof(*reg)))) {
04811 ast_log(LOG_ERROR, "Out of memory. Can't allocate SIP registry entry\n");
04812 return -1;
04813 }
04814
04815 if (ast_string_field_init(reg, 256)) {
04816 ast_log(LOG_ERROR, "Out of memory. Can't allocate SIP registry strings\n");
04817 free(reg);
04818 return -1;
04819 }
04820
04821 regobjs++;
04822 ASTOBJ_INIT(reg);
04823 ast_string_field_set(reg, contact, contact);
04824 if (!ast_strlen_zero(username))
04825 ast_string_field_set(reg, username, username);
04826 if (hostname)
04827 ast_string_field_set(reg, hostname, hostname);
04828 if (authuser)
04829 ast_string_field_set(reg, authuser, authuser);
04830 if (secret)
04831 ast_string_field_set(reg, secret, secret);
04832 reg->expire = -1;
04833 reg->timeout = -1;
04834 reg->refresh = default_expiry;
04835 reg->portno = portnum;
04836 reg->callid_valid = FALSE;
04837 reg->ocseq = INITIAL_CSEQ;
04838 ASTOBJ_CONTAINER_LINK(®l, reg);
04839 ASTOBJ_UNREF(reg,sip_registry_destroy);
04840 return 0;
04841 }
04842
04843
04844
04845 static int lws2sws(char *msgbuf, int len)
04846 {
04847 int h = 0, t = 0;
04848 int lws = 0;
04849
04850 for (; h < len;) {
04851
04852 if (msgbuf[h] == '\r') {
04853 h++;
04854 continue;
04855 }
04856
04857 if (msgbuf[h] == '\n') {
04858
04859 if (h + 1 == len)
04860 break;
04861
04862 if (msgbuf[h + 1] == ' ' || msgbuf[h + 1] == '\t') {
04863
04864 h++;
04865 continue;
04866 }
04867
04868 msgbuf[t++] = msgbuf[h++];
04869 lws = 0;
04870 continue;
04871 }
04872 if (msgbuf[h] == ' ' || msgbuf[h] == '\t') {
04873 if (lws) {
04874 h++;
04875 continue;
04876 }
04877 msgbuf[t++] = msgbuf[h++];
04878 lws = 1;
04879 continue;
04880 }
04881 msgbuf[t++] = msgbuf[h++];
04882 if (lws)
04883 lws = 0;
04884 }
04885 msgbuf[t] = '\0';
04886 return t;
04887 }
04888
04889
04890
04891
04892 static int parse_request(struct sip_request *req)
04893 {
04894
04895 char *c;
04896 int f = 0;
04897
04898 c = req->data;
04899
04900
04901 req->header[f] = c;
04902 while(*c) {
04903 if (*c == '\n') {
04904
04905 *c = 0;
04906
04907 if (sipdebug && option_debug > 3)
04908 ast_log(LOG_DEBUG, "Header %d: %s (%d)\n", f, req->header[f], (int) strlen(req->header[f]));
04909 if (ast_strlen_zero(req->header[f])) {
04910
04911 c++;
04912 break;
04913 }
04914 if (f >= SIP_MAX_HEADERS - 1) {
04915 ast_log(LOG_WARNING, "Too many SIP headers. Ignoring.\n");
04916 } else
04917 f++;
04918 req->header[f] = c + 1;
04919 } else if (*c == '\r') {
04920
04921 *c = 0;
04922 }
04923 c++;
04924 }
04925
04926 if (!ast_strlen_zero(req->header[f])) {
04927 if (sipdebug && option_debug > 3)
04928 ast_log(LOG_DEBUG, "Header %d: %s (%d)\n", f, req->header[f], (int) strlen(req->header[f]));
04929 f++;
04930 }
04931 req->headers = f;
04932
04933 f = 0;
04934 req->line[f] = c;
04935 while(*c) {
04936 if (*c == '\n') {
04937
04938 *c = 0;
04939 if (sipdebug && option_debug > 3)
04940 ast_log(LOG_DEBUG, "Line: %s (%d)\n", req->line[f], (int) strlen(req->line[f]));
04941 if (f >= SIP_MAX_LINES - 1) {
04942 ast_log(LOG_WARNING, "Too many SDP lines. Ignoring.\n");
04943 } else
04944 f++;
04945 req->line[f] = c + 1;
04946 } else if (*c == '\r') {
04947
04948 *c = 0;
04949 }
04950 c++;
04951 }
04952
04953 if (!ast_strlen_zero(req->line[f]))
04954 f++;
04955 req->lines = f;
04956 if (*c)
04957 ast_log(LOG_WARNING, "Odd content, extra stuff left over ('%s')\n", c);
04958
04959 return determine_firstline_parts(req);
04960 }
04961
04962
04963
04964
04965
04966
04967
04968
04969
04970 static int find_sdp(struct sip_request *req)
04971 {
04972 const char *content_type;
04973 const char *content_length;
04974 const char *search;
04975 char *boundary;
04976 unsigned int x;
04977 int boundaryisquoted = FALSE;
04978 int found_application_sdp = FALSE;
04979 int found_end_of_headers = FALSE;
04980
04981 content_length = get_header(req, "Content-Length");
04982
04983 if (!ast_strlen_zero(content_length)) {
04984 if (sscanf(content_length, "%ud", &x) != 1) {
04985 ast_log(LOG_WARNING, "Invalid Content-Length: %s\n", content_length);
04986 return 0;
04987 }
04988
04989
04990
04991 if (x == 0)
04992 return 0;
04993 }
04994
04995 content_type = get_header(req, "Content-Type");
04996
04997
04998 if (!strncasecmp(content_type, "application/sdp", 15)) {
04999 req->sdp_start = 0;
05000 req->sdp_end = req->lines;
05001 return req->lines ? 1 : 0;
05002 }
05003
05004
05005 if (strncasecmp(content_type, "multipart/mixed", 15))
05006 return 0;
05007
05008
05009 if ((search = strcasestr(content_type, ";boundary=")))
05010 search += 10;
05011 else if ((search = strcasestr(content_type, "; boundary=")))
05012 search += 11;
05013 else
05014 return 0;
05015
05016 if (ast_strlen_zero(search))
05017 return 0;
05018
05019
05020 if (*search == '\"') {
05021 search++;
05022 boundaryisquoted = TRUE;
05023 }
05024
05025
05026
05027 boundary = ast_strdupa(search - 2);
05028 boundary[0] = boundary[1] = '-';
05029
05030 if (boundaryisquoted)
05031 boundary[strlen(boundary) - 1] = '\0';
05032
05033
05034
05035
05036 for (x = 0; x < (req->lines ); x++) {
05037 if(!strncasecmp(req->line[x], boundary, strlen(boundary))){
05038 if(found_application_sdp && found_end_of_headers){
05039 req->sdp_end = x-1;
05040 return 1;
05041 }
05042 found_application_sdp = FALSE;
05043 }
05044 if(!strcasecmp(req->line[x], "Content-Type: application/sdp"))
05045 found_application_sdp = TRUE;
05046
05047 if(strlen(req->line[x]) == 0 ){
05048 if(found_application_sdp && !found_end_of_headers){
05049 req->sdp_start = x;
05050 found_end_of_headers = TRUE;
05051 }
05052 }
05053 }
05054 if(found_application_sdp && found_end_of_headers) {
05055 req->sdp_end = x;
05056 return TRUE;
05057 }
05058 return FALSE;
05059 }
05060
05061
05062 static void change_hold_state(struct sip_pvt *dialog, struct sip_request *req, int holdstate, int sendonly)
05063 {
05064 if (global_notifyhold && (!holdstate || !ast_test_flag(&dialog->flags[1], SIP_PAGE2_CALL_ONHOLD)))
05065 sip_peer_hold(dialog, holdstate);
05066 if (global_callevents)
05067 manager_event(EVENT_FLAG_CALL, holdstate ? "Hold" : "Unhold",
05068 "Channel: %s\r\n"
05069 "Uniqueid: %s\r\n",
05070 dialog->owner->name,
05071 dialog->owner->uniqueid);
05072 append_history(dialog, holdstate ? "Hold" : "Unhold", "%s", req->data);
05073 if (!holdstate) {
05074 ast_clear_flag(&dialog->flags[1], SIP_PAGE2_CALL_ONHOLD);
05075 return;
05076 }
05077
05078
05079 if (sendonly == 1)
05080 ast_set_flag(&dialog->flags[1], SIP_PAGE2_CALL_ONHOLD_ONEDIR);
05081 else if (sendonly == 2)
05082 ast_set_flag(&dialog->flags[1], SIP_PAGE2_CALL_ONHOLD_INACTIVE);
05083 else
05084 ast_set_flag(&dialog->flags[1], SIP_PAGE2_CALL_ONHOLD_ACTIVE);
05085 return;
05086 }
05087
05088
05089
05090
05091
05092
05093 static int process_sdp(struct sip_pvt *p, struct sip_request *req)
05094 {
05095 const char *m;
05096 const char *c;
05097 const char *a;
05098 char host[258];
05099 int len = -1;
05100 int portno = -1;
05101 int vportno = -1;
05102 int udptlportno = -1;
05103 int peert38capability = 0;
05104 char s[256];
05105 int old = 0;
05106
05107
05108 int peercapability = 0, peernoncodeccapability = 0;
05109 int vpeercapability = 0, vpeernoncodeccapability = 0;
05110 struct sockaddr_in sin;
05111 struct sockaddr_in vsin;
05112
05113 const char *codecs;
05114 struct hostent *hp;
05115 struct hostent *vhp = NULL;
05116 struct ast_hostent audiohp;
05117 struct ast_hostent videohp;
05118 int codec;
05119 int destiterator = 0;
05120 int iterator;
05121 int sendonly = -1;
05122 int numberofports;
05123 struct ast_rtp *newaudiortp, *newvideortp;
05124 int newjointcapability;
05125 int newpeercapability;
05126 int newnoncodeccapability;
05127 int numberofmediastreams = 0;
05128 int debug = sip_debug_test_pvt(p);
05129
05130 int found_rtpmap_codecs[SDP_MAX_RTPMAP_CODECS];
05131 int last_rtpmap_codec=0;
05132
05133 if (!p->rtp) {
05134 ast_log(LOG_ERROR, "Got SDP but have no RTP session allocated.\n");
05135 return -1;
05136 }
05137
05138
05139 #ifdef LOW_MEMORY
05140 newaudiortp = ast_threadstorage_get(&ts_audio_rtp, ast_rtp_alloc_size());
05141 #else
05142 newaudiortp = alloca(ast_rtp_alloc_size());
05143 #endif
05144 memset(newaudiortp, 0, ast_rtp_alloc_size());
05145 ast_rtp_new_init(newaudiortp);
05146 ast_rtp_pt_clear(newaudiortp);
05147
05148 #ifdef LOW_MEMORY
05149 newvideortp = ast_threadstorage_get(&ts_video_rtp, ast_rtp_alloc_size());
05150 #else
05151 newvideortp = alloca(ast_rtp_alloc_size());
05152 #endif
05153 memset(newvideortp, 0, ast_rtp_alloc_size());
05154 ast_rtp_new_init(newvideortp);
05155 ast_rtp_pt_clear(newvideortp);
05156
05157
05158 p->lastrtprx = p->lastrtptx = time(NULL);
05159
05160
05161
05162 m = get_sdp(req, "m");
05163 destiterator = req->sdp_start;
05164 c = get_sdp_iterate(&destiterator, req, "c");
05165 if (ast_strlen_zero(m) || ast_strlen_zero(c)) {
05166 ast_log(LOG_WARNING, "Insufficient information for SDP (m = '%s', c = '%s')\n", m, c);
05167 return -1;
05168 }
05169
05170
05171 if (sscanf(c, "IN IP4 %256s", host) != 1) {
05172 ast_log(LOG_WARNING, "Invalid host in c= line, '%s'\n", c);
05173 return -1;
05174 }
05175
05176
05177 hp = ast_gethostbyname(host, &audiohp);
05178 if (!hp) {
05179 ast_log(LOG_WARNING, "Unable to lookup host in c= line, '%s'\n", c);
05180 return -1;
05181 }
05182 vhp = hp;
05183
05184 iterator = req->sdp_start;
05185 ast_set_flag(&p->flags[0], SIP_NOVIDEO);
05186
05187
05188
05189 while ((m = get_sdp_iterate(&iterator, req, "m"))[0] != '\0') {
05190 int x;
05191 int audio = FALSE;
05192
05193 numberofports = 1;
05194 if ((sscanf(m, "audio %d/%d RTP/AVP %n", &x, &numberofports, &len) == 2) ||
05195 (sscanf(m, "audio %d RTP/AVP %n", &x, &len) == 1)) {
05196 audio = TRUE;
05197 numberofmediastreams++;
05198
05199 portno = x;
05200
05201 for (codecs = m + len; !ast_strlen_zero(codecs); codecs = ast_skip_blanks(codecs + len)) {
05202 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
05203 ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
05204 return -1;
05205 }
05206 if (debug)
05207 ast_verbose("Found RTP audio format %d\n", codec);
05208 ast_rtp_set_m_type(newaudiortp, codec);
05209 }
05210 } else if ((sscanf(m, "video %d/%d RTP/AVP %n", &x, &numberofports, &len) == 2) ||
05211 (sscanf(m, "video %d RTP/AVP %n", &x, &len) == 1)) {
05212
05213 ast_clear_flag(&p->flags[0], SIP_NOVIDEO);
05214 numberofmediastreams++;
05215 vportno = x;
05216
05217 for (codecs = m + len; !ast_strlen_zero(codecs); codecs = ast_skip_blanks(codecs + len)) {
05218 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
05219 ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
05220 return -1;
05221 }
05222 if (debug)
05223 ast_verbose("Found RTP video format %d\n", codec);
05224 ast_rtp_set_m_type(newvideortp, codec);
05225 }
05226 } else if (p->udptl && ( (sscanf(m, "image %d udptl t38%n", &x, &len) == 1) ||
05227 (sscanf(m, "image %d UDPTL t38%n", &x, &len) == 1) )) {
05228 if (debug)
05229 ast_verbose("Got T.38 offer in SDP in dialog %s\n", p->callid);
05230 udptlportno = x;
05231 numberofmediastreams++;
05232
05233 if (p->owner && p->lastinvite) {
05234 p->t38.state = T38_PEER_REINVITE;
05235 if (option_debug > 1)
05236 ast_log(LOG_DEBUG, "T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>" );
05237 } else {
05238 p->t38.state = T38_PEER_DIRECT;
05239 if (option_debug > 1)
05240 ast_log(LOG_DEBUG, "T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
05241 }
05242 } else
05243 ast_log(LOG_WARNING, "Unsupported SDP media type in offer: %s\n", m);
05244 if (numberofports > 1)
05245 ast_log(LOG_WARNING, "SDP offered %d ports for media, not supported by Asterisk. Will try anyway...\n", numberofports);
05246
05247
05248
05249 c = get_sdp_iterate(&destiterator, req, "c");
05250 if (!ast_strlen_zero(c)) {
05251 if (sscanf(c, "IN IP4 %256s", host) != 1) {
05252 ast_log(LOG_WARNING, "Invalid secondary host in c= line, '%s'\n", c);
05253 } else {
05254
05255 if (audio) {
05256 if ( !(hp = ast_gethostbyname(host, &audiohp))) {
05257 ast_log(LOG_WARNING, "Unable to lookup RTP Audio host in secondary c= line, '%s'\n", c);
05258 return -2;
05259 }
05260 } else if (!(vhp = ast_gethostbyname(host, &videohp))) {
05261 ast_log(LOG_WARNING, "Unable to lookup RTP video host in secondary c= line, '%s'\n", c);
05262 return -2;
05263 }
05264 }
05265
05266 }
05267 }
05268 if (portno == -1 && vportno == -1 && udptlportno == -1)
05269
05270
05271 return -2;
05272
05273 if (numberofmediastreams > 2)
05274
05275 return -3;
05276
05277
05278 sin.sin_family = AF_INET;
05279 vsin.sin_family = AF_INET;
05280 memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
05281 if (vhp)
05282 memcpy(&vsin.sin_addr, vhp->h_addr, sizeof(vsin.sin_addr));
05283
05284
05285 if (p->udptl) {
05286 if (udptlportno > 0) {
05287 sin.sin_port = htons(udptlportno);
05288 if (ast_test_flag(&p->flags[0], SIP_NAT) && ast_test_flag(&p->flags[1], SIP_PAGE2_UDPTL_DESTINATION)) {
05289 struct sockaddr_in peer;
05290 ast_rtp_get_peer(p->rtp, &peer);
05291 if (peer.sin_addr.s_addr) {
05292 memcpy(&sin.sin_addr, &peer.sin_addr, sizeof(&sin.sin_addr));
05293 if (debug) {
05294 ast_log(LOG_DEBUG, "Peer T.38 UDPTL is set behind NAT and with destination, destination address now %s\n", ast_inet_ntoa(sin.sin_addr));
05295 }
05296 }
05297 }
05298 ast_udptl_set_peer(p->udptl, &sin);
05299 if (debug)
05300 ast_log(LOG_DEBUG,"Peer T.38 UDPTL is at port %s:%d\n",ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
05301 } else {
05302 ast_udptl_stop(p->udptl);
05303 if (debug)
05304 ast_log(LOG_DEBUG, "Peer doesn't provide T.38 UDPTL\n");
05305 }
05306 }
05307
05308
05309 if (p->rtp) {
05310 if (portno > 0) {
05311 sin.sin_port = htons(portno);
05312 ast_rtp_set_peer(p->rtp, &sin);
05313 if (debug)
05314 ast_verbose("Peer audio RTP is at port %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
05315 } else {
05316 if (udptlportno > 0) {
05317 if (debug)
05318 ast_verbose("Got T.38 Re-invite without audio. Keeping RTP active during T.38 session. Callid %s\n", p->callid);
05319 } else {
05320 ast_rtp_stop(p->rtp);
05321 if (debug)
05322 ast_verbose("Peer doesn't provide audio. Callid %s\n", p->callid);
05323 }
05324 }
05325 }
05326
05327 if (vportno != -1)
05328 vsin.sin_port = htons(vportno);
05329
05330
05331
05332
05333
05334 iterator = req->sdp_start;
05335 while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
05336 char* mimeSubtype = ast_strdupa(a);
05337 if (option_debug > 1) {
05338 int breakout = FALSE;
05339
05340
05341 if (!strncasecmp(a, "rtcp:", (size_t) 5)) {
05342 if (debug)
05343 ast_verbose("Got unsupported a:rtcp in SDP offer \n");
05344 breakout = TRUE;
05345 } else if (!strncasecmp(a, "fmtp:", (size_t) 5)) {
05346
05347
05348
05349
05350 if (debug)
05351 ast_verbose("Got unsupported a:fmtp in SDP offer \n");
05352 breakout = TRUE;
05353 } else if (!strncasecmp(a, "framerate:", (size_t) 10)) {
05354
05355 if (debug)
05356 ast_verbose("Got unsupported a:framerate in SDP offer \n");
05357 breakout = TRUE;
05358 } else if (!strncasecmp(a, "maxprate:", (size_t) 9)) {
05359
05360 if (debug)
05361 ast_verbose("Got unsupported a:maxprate in SDP offer \n");
05362 breakout = TRUE;
05363 } else if (!strncasecmp(a, "crypto:", (size_t) 7)) {
05364
05365 if (debug)
05366 ast_verbose("Got unsupported a:crypto in SDP offer \n");
05367 breakout = TRUE;
05368 }
05369 if (breakout)
05370 continue;
05371 }
05372 if (!strcasecmp(a, "sendonly")) {
05373 if (sendonly == -1)
05374 sendonly = 1;
05375 continue;
05376 } else if (!strcasecmp(a, "inactive")) {
05377 if (sendonly == -1)
05378 sendonly = 2;
05379 continue;
05380 } else if (!strcasecmp(a, "sendrecv")) {
05381 if (sendonly == -1)
05382 sendonly = 0;
05383 continue;
05384 } else if (strlen(a) > 5 && !strncasecmp(a, "ptime", 5)) {
05385 char *tmp = strrchr(a, ':');
05386 long int framing = 0;
05387 if (tmp) {
05388 tmp++;
05389 framing = strtol(tmp, NULL, 10);
05390 if (framing == LONG_MIN || framing == LONG_MAX) {
05391 framing = 0;
05392 if (option_debug)
05393 ast_log(LOG_DEBUG, "Can't read framing from SDP: %s\n", a);
05394 }
05395 }
05396 if (framing && p->autoframing) {
05397 struct ast_codec_pref *pref = ast_rtp_codec_getpref(p->rtp);
05398 int codec_n;
05399 int format = 0;
05400 for (codec_n = 0; codec_n < MAX_RTP_PT; codec_n++) {
05401 format = ast_rtp_codec_getformat(codec_n);
05402 if (!format)
05403 continue;
05404 if (option_debug)
05405 ast_log(LOG_DEBUG, "Setting framing for %d to %ld\n", format, framing);
05406 ast_codec_pref_setsize(pref, format, framing);
05407 }
05408 ast_rtp_codec_setpref(p->rtp, pref);
05409 }
05410 continue;
05411 } else if (sscanf(a, "rtpmap: %u %[^/]/", &codec, mimeSubtype) == 2) {
05412
05413 int found = FALSE;
05414
05415
05416
05417 if (last_rtpmap_codec < SDP_MAX_RTPMAP_CODECS) {
05418
05419 if(ast_rtp_set_rtpmap_type(newaudiortp, codec, "audio", mimeSubtype,
05420 ast_test_flag(&p->flags[0], SIP_G726_NONSTANDARD) ? AST_RTP_OPT_G726_NONSTANDARD : 0) != -1) {
05421 if (debug)
05422 ast_verbose("Found audio description format %s for ID %d\n", mimeSubtype, codec);
05423 found_rtpmap_codecs[last_rtpmap_codec] = codec;
05424 last_rtpmap_codec++;
05425 found = TRUE;
05426
05427 } else if (p->vrtp) {
05428 if(ast_rtp_set_rtpmap_type(newvideortp, codec, "video", mimeSubtype, 0) != -1) {
05429 if (debug)
05430 ast_verbose("Found video description format %s for ID %d\n", mimeSubtype, codec);
05431 found_rtpmap_codecs[last_rtpmap_codec] = codec;
05432 last_rtpmap_codec++;
05433 found = TRUE;
05434 }
05435 }
05436 } else {
05437 if (debug)
05438 ast_verbose("Discarded description format %s for ID %d\n", mimeSubtype, codec);
05439 }
05440
05441 if (!found) {
05442
05443
05444
05445 ast_rtp_unset_m_type(newaudiortp, codec);
05446 ast_rtp_unset_m_type(newvideortp, codec);
05447 if (debug)
05448 ast_verbose("Found unknown media description format %s for ID %d\n", mimeSubtype, codec);
05449 }
05450 }
05451 }
05452
05453 if (udptlportno != -1) {
05454 int found = 0, x;
05455
05456 old = 0;
05457
05458
05459 iterator = req->sdp_start;
05460 while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
05461 if ((sscanf(a, "T38FaxMaxBuffer:%d", &x) == 1)) {
05462 found = 1;
05463 if (option_debug > 2)
05464 ast_log(LOG_DEBUG, "MaxBufferSize:%d\n",x);
05465 } else if ((sscanf(a, "T38MaxBitRate:%d", &x) == 1)) {
05466 found = 1;
05467 if (option_debug > 2)
05468 ast_log(LOG_DEBUG,"T38MaxBitRate: %d\n",x);
05469 switch (x) {
05470 case 14400:
05471 peert38capability |= T38FAX_RATE_14400 | T38FAX_RATE_12000 | T38FAX_RATE_9600 | T38FAX_RATE_7200 | T38FAX_RATE_4800 | T38FAX_RATE_2400;
05472 break;
05473 case 12000:
05474 peert38capability |= T38FAX_RATE_12000 | T38FAX_RATE_9600 | T38FAX_RATE_7200 | T38FAX_RATE_4800 | T38FAX_RATE_2400;
05475 break;
05476 case 9600:
05477 peert38capability |= T38FAX_RATE_9600 | T38FAX_RATE_7200 | T38FAX_RATE_4800 | T38FAX_RATE_2400;
05478 break;
05479 case 7200:
05480 peert38capability |= T38FAX_RATE_7200 | T38FAX_RATE_4800 | T38FAX_RATE_2400;
05481 break;
05482 case 4800:
05483 peert38capability |= T38FAX_RATE_4800 | T38FAX_RATE_2400;
05484 break;
05485 case 2400:
05486 peert38capability |= T38FAX_RATE_2400;
05487 break;
05488 }
05489 } else if ((sscanf(a, "T38FaxVersion:%d", &x) == 1)) {
05490 found = 1;
05491 if (option_debug > 2)
05492 ast_log(LOG_DEBUG, "FaxVersion: %d\n",x);
05493 if (x == 0)
05494 peert38capability |= T38FAX_VERSION_0;
05495 else if (x == 1)
05496 peert38capability |= T38FAX_VERSION_1;
05497 } else if ((sscanf(a, "T38FaxMaxDatagram:%d", &x) == 1)) {
05498 found = 1;
05499 if (option_debug > 2)
05500 ast_log(LOG_DEBUG, "FaxMaxDatagram: %d\n",x);
05501 ast_udptl_set_far_max_datagram(p->udptl, x);
05502 ast_udptl_set_local_max_datagram(p->udptl, x);
05503 } else if ((sscanf(a, "T38FaxFillBitRemoval:%d", &x) == 1)) {
05504 found = 1;
05505 if (option_debug > 2)
05506 ast_log(LOG_DEBUG, "FillBitRemoval: %d\n",x);
05507 if (x == 1)
05508 peert38capability |= T38FAX_FILL_BIT_REMOVAL;
05509 } else if ((sscanf(a, "T38FaxTranscodingMMR:%d", &x) == 1)) {
05510 found = 1;
05511 if (option_debug > 2)
05512 ast_log(LOG_DEBUG, "Transcoding MMR: %d\n",x);
05513 if (x == 1)
05514 peert38capability |= T38FAX_TRANSCODING_MMR;
05515 }
05516 if ((sscanf(a, "T38FaxTranscodingJBIG:%d", &x) == 1)) {
05517 found = 1;
05518 if (option_debug > 2)
05519 ast_log(LOG_DEBUG, "Transcoding JBIG: %d\n",x);
05520 if (x == 1)
05521 peert38capability |= T38FAX_TRANSCODING_JBIG;
05522 } else if ((sscanf(a, "T38FaxRateManagement:%255s", s) == 1)) {
05523 found = 1;
05524 if (option_debug > 2)
05525 ast_log(LOG_DEBUG, "RateManagement: %s\n", s);
05526 if (!strcasecmp(s, "localTCF"))
05527 peert38capability |= T38FAX_RATE_MANAGEMENT_LOCAL_TCF;
05528 else if (!strcasecmp(s, "transferredTCF"))
05529 peert38capability |= T38FAX_RATE_MANAGEMENT_TRANSFERED_TCF;
05530 } else if ((sscanf(a, "T38FaxUdpEC:%255s", s) == 1)) {
05531 found = 1;
05532 if (option_debug > 2)
05533 ast_log(LOG_DEBUG, "UDP EC: %s\n", s);
05534 if (!strcasecmp(s, "t38UDPRedundancy")) {
05535 peert38capability |= T38FAX_UDP_EC_REDUNDANCY;
05536 ast_udptl_set_error_correction_scheme(p->udptl, UDPTL_ERROR_CORRECTION_REDUNDANCY);
05537 } else if (!strcasecmp(s, "t38UDPFEC")) {
05538 peert38capability |= T38FAX_UDP_EC_FEC;
05539 ast_udptl_set_error_correction_scheme(p->udptl, UDPTL_ERROR_CORRECTION_FEC);
05540 } else {
05541 peert38capability |= T38FAX_UDP_EC_NONE;
05542 ast_udptl_set_error_correction_scheme(p->udptl, UDPTL_ERROR_CORRECTION_NONE);
05543 }
05544 }
05545 }
05546 if (found) {
05547 p->t38.peercapability = peert38capability;
05548 p->t38.jointcapability = (peert38capability & 255);
05549 peert38capability &= (T38FAX_RATE_14400 | T38FAX_RATE_12000 | T38FAX_RATE_9600 | T38FAX_RATE_7200 | T38FAX_RATE_4800 | T38FAX_RATE_2400);
05550 p->t38.jointcapability |= (peert38capability & p->t38.capability);
05551 }
05552 if (debug)
05553 ast_log(LOG_DEBUG, "Our T38 capability = (%d), peer T38 capability (%d), joint T38 capability (%d)\n",
05554 p->t38.capability,
05555 p->t38.peercapability,
05556 p->t38.jointcapability);
05557 } else {
05558 p->t38.state = T38_DISABLED;
05559 if (option_debug > 2)
05560 ast_log(LOG_DEBUG, "T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
05561 }
05562
05563
05564 ast_rtp_get_current_formats(newaudiortp, &peercapability, &peernoncodeccapability);
05565 ast_rtp_get_current_formats(newvideortp, &vpeercapability, &vpeernoncodeccapability);
05566
05567 newjointcapability = p->capability & (peercapability | vpeercapability);
05568 newpeercapability = (peercapability | vpeercapability);
05569 newnoncodeccapability = p->noncodeccapability & peernoncodeccapability;
05570
05571
05572 if (debug) {
05573
05574 char s1[SIPBUFSIZE], s2[SIPBUFSIZE], s3[SIPBUFSIZE], s4[SIPBUFSIZE];
05575
05576 ast_verbose("Capabilities: us - %s, peer - audio=%s/video=%s, combined - %s\n",
05577 ast_getformatname_multiple(s1, SIPBUFSIZE, p->capability),
05578 ast_getformatname_multiple(s2, SIPBUFSIZE, newpeercapability),
05579 ast_getformatname_multiple(s3, SIPBUFSIZE, vpeercapability),
05580 ast_getformatname_multiple(s4, SIPBUFSIZE, newjointcapability));
05581
05582 ast_verbose("Non-codec capabilities (dtmf): us - %s, peer - %s, combined - %s\n",
05583 ast_rtp_lookup_mime_multiple(s1, SIPBUFSIZE, p->noncodeccapability, 0, 0),
05584 ast_rtp_lookup_mime_multiple(s2, SIPBUFSIZE, peernoncodeccapability, 0, 0),
05585 ast_rtp_lookup_mime_multiple(s3, SIPBUFSIZE, newnoncodeccapability, 0, 0));
05586 }
05587 if (!newjointcapability) {
05588
05589 if (!p->t38.jointcapability || !udptlportno) {
05590 ast_log(LOG_NOTICE, "No compatible codecs, not accepting this offer!\n");
05591
05592 return -1;
05593 } else {
05594 if (option_debug > 2)
05595 ast_log(LOG_DEBUG, "Have T.38 but no audio codecs, accepting offer anyway\n");
05596 return 0;
05597 }
05598 }
05599
05600
05601
05602 p->jointcapability = newjointcapability;
05603 p->peercapability = newpeercapability;
05604 p->jointnoncodeccapability = newnoncodeccapability;
05605
05606 ast_rtp_pt_copy(p->rtp, newaudiortp);
05607 if (p->vrtp)
05608 ast_rtp_pt_copy(p->vrtp, newvideortp);
05609
05610 if (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO) {
05611 ast_clear_flag(&p->flags[0], SIP_DTMF);
05612 if (newnoncodeccapability & AST_RTP_DTMF) {
05613
05614 ast_set_flag(&p->flags[0], SIP_DTMF_RFC2833);
05615
05616 ast_rtp_setdtmf(p->rtp, 1);
05617 ast_rtp_setdtmfcompensate(p->rtp, ast_test_flag(&p->flags[1], SIP_PAGE2_RFC2833_COMPENSATE));
05618 } else {
05619 ast_set_flag(&p->flags[0], SIP_DTMF_INBAND);
05620 }
05621 }
05622
05623
05624 if (p->rtp && sin.sin_port) {
05625 ast_rtp_set_peer(p->rtp, &sin);
05626 if (debug)
05627 ast_verbose("Peer audio RTP is at port %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
05628 }
05629
05630
05631 if (p->vrtp && vsin.sin_port) {
05632 ast_rtp_set_peer(p->vrtp, &vsin);
05633 if (debug)
05634 ast_verbose("Peer video RTP is at port %s:%d\n", ast_inet_ntoa(vsin.sin_addr), ntohs(vsin.sin_port));
05635 }
05636
05637
05638 if (option_debug > 1) {
05639 char buf[SIPBUFSIZE];
05640 ast_log(LOG_DEBUG, "We're settling with these formats: %s\n", ast_getformatname_multiple(buf, SIPBUFSIZE, p->jointcapability));
05641 }
05642
05643 if (!p->owner)
05644 return 0;
05645
05646 if (option_debug > 3)
05647 ast_log(LOG_DEBUG, "We have an owner, now see if we need to change this call\n");
05648
05649 if (!(p->owner->nativeformats & p->jointcapability) && (p->jointcapability & AST_FORMAT_AUDIO_MASK)) {
05650 if (debug) {
05651 char s1[SIPBUFSIZE], s2[SIPBUFSIZE];
05652 ast_log(LOG_DEBUG, "Oooh, we need to change our audio formats since our peer supports only %s and not %s\n",
05653 ast_getformatname_multiple(s1, SIPBUFSIZE, p->jointcapability),
05654 ast_getformatname_multiple(s2, SIPBUFSIZE, p->owner->nativeformats));
05655 }
05656 p->owner->nativeformats = ast_codec_choose(&p->prefs, p->jointcapability, 1) | (p->capability & vpeercapability);
05657 ast_set_read_format(p->owner, p->owner->readformat);
05658 ast_set_write_format(p->owner, p->owner->writeformat);
05659 }
05660
05661 if (ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD) && sin.sin_addr.s_addr && (!sendonly || sendonly == -1)) {
05662 ast_queue_control(p->owner, AST_CONTROL_UNHOLD);
05663
05664 ast_queue_frame(p->owner, &ast_null_frame);
05665 } else if (!sin.sin_addr.s_addr || (sendonly && sendonly != -1)) {
05666 ast_queue_control_data(p->owner, AST_CONTROL_HOLD,
05667 S_OR(p->mohsuggest, NULL),
05668 !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0);
05669 if (sendonly)
05670 ast_rtp_stop(p->rtp);
05671
05672
05673 ast_queue_frame(p->owner, &ast_null_frame);
05674 }
05675
05676
05677 if (ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD) && sin.sin_addr.s_addr && (!sendonly || sendonly == -1))
05678 change_hold_state(p, req, FALSE, sendonly);
05679 else if (!sin.sin_addr.s_addr || (sendonly && sendonly != -1))
05680 change_hold_state(p, req, TRUE, sendonly);
05681 return 0;
05682 }
05683
05684 #ifdef LOW_MEMORY
05685 static void ts_ast_rtp_destroy(void *data)
05686 {
05687 struct ast_rtp *tmp = data;
05688 ast_rtp_destroy(tmp);
05689 }
05690 #endif
05691
05692
05693 static int add_header(struct sip_request *req, const char *var, const char *value)
05694 {
05695 int maxlen = sizeof(req->data) - 4 - req->len;
05696
05697 if (req->headers == SIP_MAX_HEADERS) {
05698 ast_log(LOG_WARNING, "Out of SIP header space\n");
05699 return -1;
05700 }
05701
05702 if (req->lines) {
05703 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
05704 return -1;
05705 }
05706
05707 if (maxlen <= 0) {
05708 ast_log(LOG_WARNING, "Out of space, can't add anymore (%s:%s)\n", var, value);
05709 return -1;
05710 }
05711
05712 req->header[req->headers] = req->data + req->len;
05713
05714 if (compactheaders)
05715 var = find_alias(var, var);
05716
05717 snprintf(req->header[req->headers], maxlen, "%s: %s\r\n", var, value);
05718 req->len += strlen(req->header[req->headers]);
05719 req->headers++;
05720
05721 return 0;
05722 }
05723
05724
05725 static int add_header_contentLength(struct sip_request *req, int len)
05726 {
05727 char clen[10];
05728
05729 snprintf(clen, sizeof(clen), "%d", len);
05730 return add_header(req, "Content-Length", clen);
05731 }
05732
05733
05734 static int add_line(struct sip_request *req, const char *line)
05735 {
05736 if (req->lines == SIP_MAX_LINES) {
05737 ast_log(LOG_WARNING, "Out of SIP line space\n");
05738 return -1;
05739 }
05740 if (!req->lines) {
05741
05742 snprintf(req->data + req->len, sizeof(req->data) - req->len, "\r\n");
05743 req->len += strlen(req->data + req->len);
05744 }
05745 if (req->len >= sizeof(req->data) - 4) {
05746 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
05747 return -1;
05748 }
05749 req->line[req->lines] = req->data + req->len;
05750 snprintf(req->line[req->lines], sizeof(req->data) - req->len, "%s", line);
05751 req->len += strlen(req->line[req->lines]);
05752 req->lines++;
05753 return 0;
05754 }
05755
05756
05757 static int copy_header(struct sip_request *req, const struct sip_request *orig, const char *field)
05758 {
05759 const char *tmp = get_header(orig, field);
05760
05761 if (!ast_strlen_zero(tmp))
05762 return add_header(req, field, tmp);
05763 ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
05764 return -1;
05765 }
05766
05767
05768 static int copy_all_header(struct sip_request *req, const struct sip_request *orig, const char *field)
05769 {
05770 int start = 0;
05771 int copied = 0;
05772 for (;;) {
05773 const char *tmp = __get_header(orig, field, &start);
05774
05775 if (ast_strlen_zero(tmp))
05776 break;
05777
05778 add_header(req, field, tmp);
05779 copied++;
05780 }
05781 return copied ? 0 : -1;
05782 }
05783
05784
05785
05786
05787
05788
05789
05790 static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, const struct sip_request *orig, const char *field)
05791 {
05792 int copied = 0;
05793 int start = 0;
05794
05795 for (;;) {
05796 char new[512];
05797 const char *oh = __get_header(orig, field, &start);
05798
05799 if (ast_strlen_zero(oh))
05800 break;
05801
05802 if (!copied) {
05803 char leftmost[512], *others, *rport;
05804
05805
05806 ast_copy_string(leftmost, oh, sizeof(leftmost));
05807 others = strchr(leftmost, ',');
05808 if (others)
05809 *others++ = '\0';
05810
05811
05812 rport = strstr(leftmost, ";rport");
05813 if (rport && *(rport+6) == '=')
05814 rport = NULL;
05815
05816
05817 if (rport && ((ast_test_flag(&p->flags[0], SIP_NAT) == SIP_NAT_ALWAYS) || (ast_test_flag(&p->flags[0], SIP_NAT) == SIP_NAT_RFC3581))) {
05818
05819 char *end;
05820
05821 rport = strstr(leftmost, ";rport");
05822
05823 if (rport) {
05824 end = strchr(rport + 1, ';');
05825 if (end)
05826 memmove(rport, end, strlen(end) + 1);
05827 else
05828 *rport = '\0';
05829 }
05830
05831
05832 snprintf(new, sizeof(new), "%s;received=%s;rport=%d%s%s",
05833 leftmost, ast_inet_ntoa(p->recv.sin_addr),
05834 ntohs(p->recv.sin_port),
05835 others ? "," : "", others ? others : "");
05836 } else {
05837
05838 snprintf(new, sizeof(new), "%s;received=%s%s%s",
05839 leftmost, ast_inet_ntoa(p->recv.sin_addr),
05840 others ? "," : "", others ? others : "");
05841 }
05842 oh = new;
05843 }
05844 add_header(req, field, oh);
05845 copied++;
05846 }
05847 if (!copied) {
05848 ast_log(LOG_NOTICE, "No header field '%s' present to copy\n", field);
05849 return -1;
05850 }
05851 return 0;
05852 }
05853
05854
05855 static void add_route(struct sip_request *req, struct sip_route *route)
05856 {
05857 char r[SIPBUFSIZE*2], *p;
05858 int n, rem = sizeof(r);
05859
05860 if (!route)
05861 return;
05862
05863 p = r;
05864 for (;route ; route = route->next) {
05865 n = strlen(route->hop);
05866 if (rem < n+3)
05867 break;
05868 if (p != r) {
05869 *p++ = ',';
05870 --rem;
05871 }
05872 *p++ = '<';
05873 ast_copy_string(p, route->hop, rem);
05874 p += n;
05875 *p++ = '>';
05876 rem -= (n+2);
05877 }
05878 *p = '\0';
05879 add_header(req, "Route", r);
05880 }
05881
05882
05883 static void set_destination(struct sip_pvt *p, char *uri)
05884 {
05885 char *h, *maddr, hostname[256];
05886 int port, hn;
05887 struct hostent *hp;
05888 struct ast_hostent ahp;
05889 int debug=sip_debug_test_pvt(p);
05890
05891
05892
05893
05894 if (debug)
05895 ast_verbose("set_destination: Parsing <%s> for address/port to send to\n", uri);
05896
05897
05898 h = strchr(uri, '@');
05899 if (h)
05900 ++h;
05901 else {
05902 h = uri;
05903 if (strncasecmp(h, "sip:", 4) == 0)
05904 h += 4;
05905 else if (strncasecmp(h, "sips:", 5) == 0)
05906 h += 5;
05907 }
05908 hn = strcspn(h, ":;>") + 1;
05909 if (hn > sizeof(hostname))
05910 hn = sizeof(hostname);
05911 ast_copy_string(hostname, h, hn);
05912
05913 h += hn - 1;
05914
05915
05916 if (*h == ':') {
05917
05918 ++h;
05919 port = strtol(h, &h, 10);
05920 }
05921 else
05922 port = STANDARD_SIP_PORT;
05923
05924
05925 maddr = strstr(h, "maddr=");
05926 if (maddr) {
05927 maddr += 6;
05928 hn = strspn(maddr, "0123456789.") + 1;
05929 if (hn > sizeof(hostname))
05930 hn = sizeof(hostname);
05931 ast_copy_string(hostname, maddr, hn);
05932 }
05933
05934 hp = ast_gethostbyname(hostname, &ahp);
05935 if (hp == NULL) {
05936 ast_log(LOG_WARNING, "Can't find address for host '%s'\n", hostname);
05937 return;
05938 }
05939 p->sa.sin_family = AF_INET;
05940 memcpy(&p->sa.sin_addr, hp->h_addr, sizeof(p->sa.sin_addr));
05941 p->sa.sin_port = htons(port);
05942 if (debug)
05943 ast_verbose("set_destination: set destination to %s, port %d\n", ast_inet_ntoa(p->sa.sin_addr), port);
05944 }
05945
05946
05947 static int init_resp(struct sip_request *resp, const char *msg)
05948 {
05949
05950 memset(resp, 0, sizeof(*resp));
05951 resp->method = SIP_RESPONSE;
05952 resp->header[0] = resp->data;
05953 snprintf(resp->header[0], sizeof(resp->data), "SIP/2.0 %s\r\n", msg);
05954 resp->len = strlen(resp->header[0]);
05955 resp->headers++;
05956 return 0;
05957 }
05958
05959
05960 static int init_req(struct sip_request *req, int sipmethod, const char *recip)
05961 {
05962
05963 memset(req, 0, sizeof(*req));
05964 req->method = sipmethod;
05965 req->header[0] = req->data;
05966 snprintf(req->header[0], sizeof(req->data), "%s %s SIP/2.0\r\n", sip_methods[sipmethod].text, recip);
05967 req->len = strlen(req->header[0]);
05968 req->headers++;
05969 return 0;
05970 }
05971
05972
05973
05974 static int respprep(struct sip_request *resp, struct sip_pvt *p, const char *msg, const struct sip_request *req)
05975 {
05976 char newto[256];
05977 const char *ot;
05978
05979 init_resp(resp, msg);
05980 copy_via_headers(p, resp, req, "Via");
05981 if (msg[0] == '1' || msg[0] == '2')
05982 copy_all_header(resp, req, "Record-Route");
05983 copy_header(resp, req, "From");
05984 ot = get_header(req, "To");
05985 if (!strcasestr(ot, "tag=") && strncmp(msg, "100", 3)) {
05986
05987
05988 if (!ast_strlen_zero(p->theirtag) && ast_test_flag(&p->flags[0], SIP_OUTGOING))
05989 snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
05990 else if (p->tag && !ast_test_flag(&p->flags[0], SIP_OUTGOING))
05991 snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->tag);
05992 else
05993 ast_copy_string(newto, ot, sizeof(newto));
05994 ot = newto;
05995 }
05996 add_header(resp, "To", ot);
05997 copy_header(resp, req, "Call-ID");
05998 copy_header(resp, req, "CSeq");
05999 if (!ast_strlen_zero(global_useragent))
06000 add_header(resp, "User-Agent", global_useragent);
06001 add_header(resp, "Allow", ALLOWED_METHODS);
06002 add_header(resp, "Supported", SUPPORTED_EXTENSIONS);
06003 if (msg[0] == '2' && (p->method == SIP_SUBSCRIBE || p->method == SIP_REGISTER)) {
06004
06005
06006 char tmp[256];
06007
06008 snprintf(tmp, sizeof(tmp), "%d", p->expiry);
06009 add_header(resp, "Expires", tmp);
06010 if (p->expiry) {
06011 char contact[SIPBUFSIZE];
06012 snprintf(contact, sizeof(contact), "%s;expires=%d", p->our_contact, p->expiry);
06013 add_header(resp, "Contact", contact);
06014 }
06015 } else if (msg[0] != '4' && !ast_strlen_zero(p->our_contact)) {
06016 add_header(resp, "Contact", p->our_contact);
06017 }
06018 return 0;
06019 }
06020
06021
06022 static int reqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod, int seqno, int newbranch)
06023 {
06024 struct sip_request *orig = &p->initreq;
06025 char stripped[80];
06026 char tmp[80];
06027 char newto[256];
06028 const char *c;
06029 const char *ot, *of;
06030 int is_strict = FALSE;
06031
06032 memset(req, 0, sizeof(struct sip_request));
06033
06034 snprintf(p->lastmsg, sizeof(p->lastmsg), "Tx: %s", sip_methods[sipmethod].text);
06035
06036 if (!seqno) {
06037 p->ocseq++;
06038 seqno = p->ocseq;
06039 }
06040
06041 if (newbranch) {
06042 p->branch ^= ast_random();
06043 build_via(p);
06044 }
06045
06046
06047 if (p->route && !ast_strlen_zero(p->route->hop) && strstr(p->route->hop,";lr") == NULL) {
06048 is_strict = TRUE;
06049 if (sipdebug)
06050 ast_log(LOG_DEBUG, "Strict routing enforced for session %s\n", p->callid);
06051 }
06052
06053 if (sipmethod == SIP_CANCEL)
06054 c = p->initreq.rlPart2;
06055 else if (sipmethod == SIP_ACK) {
06056
06057
06058 if (!ast_strlen_zero(p->okcontacturi))
06059 c = is_strict ? p->route->hop : p->okcontacturi;
06060 else
06061 c = p->initreq.rlPart2;
06062 } else if (!ast_strlen_zero(p->okcontacturi))
06063 c = is_strict ? p->route->hop : p->okcontacturi;
06064 else if (!ast_strlen_zero(p->uri))
06065 c = p->uri;
06066 else {
06067 char *n;
06068
06069 ast_copy_string(stripped, get_header(orig, (ast_test_flag(&p->flags[0], SIP_OUTGOING)) ? "To" : "From"),
06070 sizeof(stripped));
06071 n = get_in_brackets(stripped);
06072 c = strsep(&n, ";");
06073 }
06074 init_req(req, sipmethod, c);
06075
06076 snprintf(tmp, sizeof(tmp), "%d %s", seqno, sip_methods[sipmethod].text);
06077
06078 add_header(req, "Via", p->via);
06079 if (p->route) {
06080 set_destination(p, p->route->hop);
06081 add_route(req, is_strict ? p->route->next : p->route);
06082 }
06083
06084 ot = get_header(orig, "To");
06085 of = get_header(orig, "From");
06086
06087
06088
06089 if (!strcasestr(ot, "tag=") && sipmethod != SIP_CANCEL) {
06090
06091
06092 if (ast_test_flag(&p->flags[0], SIP_OUTGOING) && !ast_strlen_zero(p->theirtag))
06093 snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
06094 else if (!ast_test_flag(&p->flags[0], SIP_OUTGOING))
06095 snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->tag);
06096 else
06097 snprintf(newto, sizeof(newto), "%s", ot);
06098 ot = newto;
06099 }
06100
06101 if (ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
06102 add_header(req, "From", of);
06103 add_header(req, "To", ot);
06104 } else {
06105 add_header(req, "From", ot);
06106 add_header(req, "To", of);
06107 }
06108
06109 if (sipmethod != SIP_BYE && sipmethod != SIP_CANCEL && sipmethod != SIP_MESSAGE)
06110 add_header(req, "Contact", p->our_contact);
06111
06112 copy_header(req, orig, "Call-ID");
06113 add_header(req, "CSeq", tmp);
06114
06115 if (!ast_strlen_zero(global_useragent))
06116 add_header(req, "User-Agent", global_useragent);
06117 add_header(req, "Max-Forwards", DEFAULT_MAX_FORWARDS);
06118
06119 if (!ast_strlen_zero(p->rpid))
06120 add_header(req, "Remote-Party-ID", p->rpid);
06121
06122 return 0;
06123 }
06124
06125
06126 static int __transmit_response(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable)
06127 {
06128 struct sip_request resp;
06129 int seqno = 0;
06130
06131 if (reliable && (sscanf(get_header(req, "CSeq"), "%d ", &seqno) != 1)) {
06132 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
06133 return -1;
06134 }
06135 respprep(&resp, p, msg, req);
06136 add_header_contentLength(&resp, 0);
06137
06138
06139 if (p->method == SIP_INVITE && msg[0] != '1' && p->owner && p->owner->hangupcause) {
06140 char buf[10];
06141
06142 add_header(&resp, "X-Asterisk-HangupCause", ast_cause2str(p->owner->hangupcause));
06143 snprintf(buf, sizeof(buf), "%d", p->owner->hangupcause);
06144 add_header(&resp, "X-Asterisk-HangupCauseCode", buf);
06145 }
06146 return send_response(p, &resp, reliable, seqno);
06147 }
06148
06149 static void temp_pvt_cleanup(void *data)
06150 {
06151 struct sip_pvt *p = data;
06152
06153 ast_string_field_free_memory(p);
06154
06155 free(data);
06156 }
06157
06158
06159 static int transmit_response_using_temp(ast_string_field callid, struct sockaddr_in *sin, int useglobal_nat, const int intended_method, const struct sip_request *req, const char *msg)
06160 {
06161 struct sip_pvt *p = NULL;
06162
06163 if (!(p = ast_threadstorage_get(&ts_temp_pvt, sizeof(*p)))) {
06164 ast_log(LOG_NOTICE, "Failed to get temporary pvt\n");
06165 return -1;
06166 }
06167
06168
06169 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY)) {
06170 ast_set_flag(&p->flags[0], SIP_NO_HISTORY);
06171 if (ast_string_field_init(p, 512))
06172 return -1;
06173 }
06174
06175
06176 p->method = intended_method;
06177
06178 if (sin) {
06179 p->sa = *sin;
06180 if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
06181 p->ourip = __ourip;
06182 } else
06183 p->ourip = __ourip;
06184
06185 p->branch = ast_random();
06186 make_our_tag(p->tag, sizeof(p->tag));
06187 p->ocseq = INITIAL_CSEQ;
06188
06189 if (useglobal_nat && sin) {
06190 ast_copy_flags(&p->flags[0], &global_flags[0], SIP_NAT);
06191 p->recv = *sin;
06192 do_setnat(p, ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE);
06193 }
06194 check_via(p, req);
06195
06196 ast_string_field_set(p, fromdomain, default_fromdomain);
06197 build_via(p);
06198 ast_string_field_set(p, callid, callid);
06199
06200
06201 __transmit_response(p, msg, req, XMIT_UNRELIABLE);
06202
06203
06204 ast_string_field_reset_all(p);
06205
06206 return 0;
06207 }
06208
06209
06210 static int transmit_response(struct sip_pvt *p, const char *msg, const struct sip_request *req)
06211 {
06212 return __transmit_response(p, msg, req, XMIT_UNRELIABLE);
06213 }
06214
06215
06216 static int transmit_response_with_unsupported(struct sip_pvt *p, const char *msg, const struct sip_request *req, const char *unsupported)
06217 {
06218 struct sip_request resp;
06219 respprep(&resp, p, msg, req);
06220 append_date(&resp);
06221 add_header(&resp, "Unsupported", unsupported);
06222 add_header_contentLength(&resp, 0);
06223 return send_response(p, &resp, XMIT_UNRELIABLE, 0);
06224 }
06225
06226
06227
06228
06229 static int transmit_response_reliable(struct sip_pvt *p, const char *msg, const struct sip_request *req)
06230 {
06231 return __transmit_response(p, msg, req, XMIT_CRITICAL);
06232 }
06233
06234
06235 static void append_date(struct sip_request *req)
06236 {
06237 char tmpdat[256];
06238 struct tm tm;
06239 time_t t = time(NULL);
06240
06241 gmtime_r(&t, &tm);
06242 strftime(tmpdat, sizeof(tmpdat), "%a, %d %b %Y %T GMT", &tm);
06243 add_header(req, "Date", tmpdat);
06244 }
06245
06246
06247 static int transmit_response_with_date(struct sip_pvt *p, const char *msg, const struct sip_request *req)
06248 {
06249 struct sip_request resp;
06250 respprep(&resp, p, msg, req);
06251 append_date(&resp);
06252 add_header_contentLength(&resp, 0);
06253 return send_response(p, &resp, XMIT_UNRELIABLE, 0);
06254 }
06255
06256
06257 static int transmit_response_with_allow(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable)
06258 {
06259 struct sip_request resp;
06260 respprep(&resp, p, msg, req);
06261 add_header(&resp, "Accept", "application/sdp");
06262 add_header_contentLength(&resp, 0);
06263 return send_response(p, &resp, reliable, 0);
06264 }
06265
06266
06267 static int transmit_response_with_auth(struct sip_pvt *p, const char *msg, const struct sip_request *req, const char *randdata, enum xmittype reliable, const char *header, int stale)
06268 {
06269 struct sip_request resp;
06270 char tmp[512];
06271 int seqno = 0;
06272
06273 if (reliable && (sscanf(get_header(req, "CSeq"), "%d ", &seqno) != 1)) {
06274 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
06275 return -1;
06276 }
06277
06278
06279 snprintf(tmp, sizeof(tmp), "Digest algorithm=MD5, realm=\"%s\", nonce=\"%s\"%s", global_realm, randdata, stale ? ", stale=true" : "");
06280 respprep(&resp, p, msg, req);
06281 add_header(&resp, header, tmp);
06282 add_header_contentLength(&resp, 0);
06283 append_history(p, "AuthChal", "Auth challenge sent for %s - nc %d", p->username, p->noncecount);
06284 return send_response(p, &resp, reliable, seqno);
06285 }
06286
06287
06288 static int add_text(struct sip_request *req, const char *text)
06289 {
06290
06291 add_header(req, "Content-Type", "text/plain");
06292 add_header_contentLength(req, strlen(text));
06293 add_line(req, text);
06294 return 0;
06295 }
06296
06297
06298
06299 static int add_digit(struct sip_request *req, char digit, unsigned int duration)
06300 {
06301 char tmp[256];
06302
06303 snprintf(tmp, sizeof(tmp), "Signal=%c\r\nDuration=%u\r\n", digit, duration);
06304 add_header(req, "Content-Type", "application/dtmf-relay");
06305 add_header_contentLength(req, strlen(tmp));
06306 add_line(req, tmp);
06307 return 0;
06308 }
06309
06310
06311
06312 static int add_vidupdate(struct sip_request *req)
06313 {
06314 const char *xml_is_a_huge_waste_of_space =
06315 "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\r\n"
06316 " <media_control>\r\n"
06317 " <vc_primitive>\r\n"
06318 " <to_encoder>\r\n"
06319 " <picture_fast_update>\r\n"
06320 " </picture_fast_update>\r\n"
06321 " </to_encoder>\r\n"
06322 " </vc_primitive>\r\n"
06323 " </media_control>\r\n";
06324 add_header(req, "Content-Type", "application/media_control+xml");
06325 add_header_contentLength(req, strlen(xml_is_a_huge_waste_of_space));
06326 add_line(req, xml_is_a_huge_waste_of_space);
06327 return 0;
06328 }
06329
06330
06331 static void add_codec_to_sdp(const struct sip_pvt *p, int codec, int sample_rate,
06332 char **m_buf, size_t *m_size, char **a_buf, size_t *a_size,
06333 int debug, int *min_packet_size)
06334 {
06335 int rtp_code;
06336 struct ast_format_list fmt;
06337
06338
06339 if (debug)
06340 ast_verbose("Adding codec 0x%x (%s) to SDP\n", codec, ast_getformatname(codec));
06341 if ((rtp_code = ast_rtp_lookup_code(p->rtp, 1, codec)) == -1)
06342 return;
06343
06344 if (p->rtp) {
06345 struct ast_codec_pref *pref = ast_rtp_codec_getpref(p->rtp);
06346 fmt = ast_codec_pref_getsize(pref, codec);
06347 } else
06348 return;
06349 ast_build_string(m_buf, m_size, " %d", rtp_code);
06350 ast_build_string(a_buf, a_size, "a=rtpmap:%d %s/%d\r\n", rtp_code,
06351 ast_rtp_lookup_mime_subtype(1, codec,
06352 ast_test_flag(&p->flags[0], SIP_G726_NONSTANDARD) ? AST_RTP_OPT_G726_NONSTANDARD : 0),
06353 sample_rate);
06354 if (codec == AST_FORMAT_G729A) {
06355
06356 ast_build_string(a_buf, a_size, "a=fmtp:%d annexb=no\r\n", rtp_code);
06357 } else if (codec == AST_FORMAT_G723_1) {
06358
06359 ast_build_string(a_buf, a_size, "a=fmtp:%d annexa=no\r\n", rtp_code);
06360 } else if (codec == AST_FORMAT_ILBC) {
06361
06362 ast_build_string(a_buf, a_size, "a=fmtp:%d mode=%d\r\n", rtp_code, fmt.cur_ms);
06363 }
06364
06365 if (fmt.cur_ms && (fmt.cur_ms < *min_packet_size))
06366 *min_packet_size = fmt.cur_ms;
06367
06368
06369 if ((*min_packet_size) == 0 && fmt.cur_ms)
06370 *min_packet_size = fmt.cur_ms;
06371 }
06372
06373
06374 static int t38_get_rate(int t38cap)
06375 {
06376 int maxrate = (t38cap & (T38FAX_RATE_14400 | T38FAX_RATE_12000 | T38FAX_RATE_9600 | T38FAX_RATE_7200 | T38FAX_RATE_4800 | T38FAX_RATE_2400));
06377
06378 if (maxrate & T38FAX_RATE_14400) {
06379 if (option_debug > 1)
06380 ast_log(LOG_DEBUG, "T38MaxFaxRate 14400 found\n");
06381 return 14400;
06382 } else if (maxrate & T38FAX_RATE_12000) {
06383 if (option_debug > 1)
06384 ast_log(LOG_DEBUG, "T38MaxFaxRate 12000 found\n");
06385 return 12000;
06386 } else if (maxrate & T38FAX_RATE_9600) {
06387 if (option_debug > 1)
06388 ast_log(LOG_DEBUG, "T38MaxFaxRate 9600 found\n");
06389 return 9600;
06390 } else if (maxrate & T38FAX_RATE_7200) {
06391 if (option_debug > 1)
06392 ast_log(LOG_DEBUG, "T38MaxFaxRate 7200 found\n");
06393 return 7200;
06394 } else if (maxrate & T38FAX_RATE_4800) {
06395 if (option_debug > 1)
06396 ast_log(LOG_DEBUG, "T38MaxFaxRate 4800 found\n");
06397 return 4800;
06398 } else if (maxrate & T38FAX_RATE_2400) {
06399 if (option_debug > 1)
06400 ast_log(LOG_DEBUG, "T38MaxFaxRate 2400 found\n");
06401 return 2400;
06402 } else {
06403 if (option_debug > 1)
06404 ast_log(LOG_DEBUG, "Strange, T38MaxFaxRate NOT found in peers T38 SDP.\n");
06405 return 0;
06406 }
06407 }
06408
06409
06410 static int add_t38_sdp(struct sip_request *resp, struct sip_pvt *p)
06411 {
06412 int len = 0;
06413 int x = 0;
06414 struct sockaddr_in udptlsin;
06415 char v[256] = "";
06416 char s[256] = "";
06417 char o[256] = "";
06418 char c[256] = "";
06419 char t[256] = "";
06420 char m_modem[256];
06421 char a_modem[1024];
06422 char *m_modem_next = m_modem;
06423 size_t m_modem_left = sizeof(m_modem);
06424 char *a_modem_next = a_modem;
06425 size_t a_modem_left = sizeof(a_modem);
06426 struct sockaddr_in udptldest = { 0, };
06427 int debug;
06428
06429 debug = sip_debug_test_pvt(p);
06430 len = 0;
06431 if (!p->udptl) {
06432 ast_log(LOG_WARNING, "No way to add SDP without an UDPTL structure\n");
06433 return -1;
06434 }
06435
06436 if (!p->sessionid) {
06437 p->sessionid = getpid();
06438 p->sessionversion = p->sessionid;
06439 } else
06440 p->sessionversion++;
06441
06442
06443 ast_udptl_get_us(p->udptl, &udptlsin);
06444
06445
06446 if (p->udptlredirip.sin_addr.s_addr) {
06447 udptldest.sin_port = p->udptlredirip.sin_port;
06448 udptldest.sin_addr = p->udptlredirip.sin_addr;
06449 } else {
06450 udptldest.sin_addr = p->ourip;
06451 udptldest.sin_port = udptlsin.sin_port;
06452 }
06453
06454 if (debug)
06455 ast_log(LOG_DEBUG, "T.38 UDPTL is at %s port %d\n", ast_inet_ntoa(p->ourip), ntohs(udptlsin.sin_port));
06456
06457
06458
06459
06460 if (debug) {
06461 ast_log(LOG_DEBUG, "Our T38 capability (%d), peer T38 capability (%d), joint capability (%d)\n",
06462 p->t38.capability,
06463 p->t38.peercapability,
06464 p->t38.jointcapability);
06465 }
06466 snprintf(v, sizeof(v), "v=0\r\n");
06467 snprintf(o, sizeof(o), "o=root %d %d IN IP4 %s\r\n", p->sessionid, p->sessionversion, ast_inet_ntoa(udptldest.sin_addr));
06468 snprintf(s, sizeof(s), "s=session\r\n");
06469 snprintf(c, sizeof(c), "c=IN IP4 %s\r\n", ast_inet_ntoa(udptldest.sin_addr));
06470 snprintf(t, sizeof(t), "t=0 0\r\n");
06471 ast_build_string(&m_modem_next, &m_modem_left, "m=image %d udptl t38\r\n", ntohs(udptldest.sin_port));
06472
06473 if ((p->t38.jointcapability & T38FAX_VERSION) == T38FAX_VERSION_0)
06474 ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxVersion:0\r\n");
06475 if ((p->t38.jointcapability & T38FAX_VERSION) == T38FAX_VERSION_1)
06476 ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxVersion:1\r\n");
06477 if ((x = t38_get_rate(p->t38.jointcapability)))
06478 ast_build_string(&a_modem_next, &a_modem_left, "a=T38MaxBitRate:%d\r\n",x);
06479 ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxFillBitRemoval:%d\r\n", (p->t38.jointcapability & T38FAX_FILL_BIT_REMOVAL) ? 1 : 0);
06480 ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxTranscodingMMR:%d\r\n", (p->t38.jointcapability & T38FAX_TRANSCODING_MMR) ? 1 : 0);
06481 ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxTranscodingJBIG:%d\r\n", (p->t38.jointcapability & T38FAX_TRANSCODING_JBIG) ? 1 : 0);
06482 ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxRateManagement:%s\r\n", (p->t38.jointcapability & T38FAX_RATE_MANAGEMENT_LOCAL_TCF) ? "localTCF" : "transferredTCF");
06483 x = ast_udptl_get_local_max_datagram(p->udptl);
06484 ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxMaxBuffer:%d\r\n",x);
06485 ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxMaxDatagram:%d\r\n",x);
06486 if (p->t38.jointcapability != T38FAX_UDP_EC_NONE)
06487 ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxUdpEC:%s\r\n", (p->t38.jointcapability & T38FAX_UDP_EC_REDUNDANCY) ? "t38UDPRedundancy" : "t38UDPFEC");
06488 len = strlen(v) + strlen(s) + strlen(o) + strlen(c) + strlen(t) + strlen(m_modem) + strlen(a_modem);
06489 add_header(resp, "Content-Type", "application/sdp");
06490 add_header_contentLength(resp, len);
06491 add_line(resp, v);
06492 add_line(resp, o);
06493 add_line(resp, s);
06494 add_line(resp, c);
06495 add_line(resp, t);
06496 add_line(resp, m_modem);
06497 add_line(resp, a_modem);
06498
06499
06500 p->lastrtprx = p->lastrtptx = time(NULL);
06501
06502 return 0;
06503 }
06504
06505
06506
06507 static void add_noncodec_to_sdp(const struct sip_pvt *p, int format, int sample_rate,
06508 char **m_buf, size_t *m_size, char **a_buf, size_t *a_size,
06509 int debug)
06510 {
06511 int rtp_code;
06512
06513 if (debug)
06514 ast_verbose("Adding non-codec 0x%x (%s) to SDP\n", format, ast_rtp_lookup_mime_subtype(0, format, 0));
06515 if ((rtp_code = ast_rtp_lookup_code(p->rtp, 0, format)) == -1)
06516 return;
06517
06518 ast_build_string(m_buf, m_size, " %d", rtp_code);
06519 ast_build_string(a_buf, a_size, "a=rtpmap:%d %s/%d\r\n", rtp_code,
06520 ast_rtp_lookup_mime_subtype(0, format, 0),
06521 sample_rate);
06522 if (format == AST_RTP_DTMF)
06523
06524 ast_build_string(a_buf, a_size, "a=fmtp:%d 0-16\r\n", rtp_code);
06525 }
06526
06527
06528
06529
06530
06531
06532 #define SDP_SAMPLE_RATE(x) 8000
06533
06534
06535 static enum sip_result add_sdp(struct sip_request *resp, struct sip_pvt *p)
06536 {
06537 int len = 0;
06538 int alreadysent = 0;
06539
06540 struct sockaddr_in sin;
06541 struct sockaddr_in vsin;
06542 struct sockaddr_in dest;
06543 struct sockaddr_in vdest = { 0, };
06544
06545
06546 char *version = "v=0\r\n";
06547 char *subject = "s=session\r\n";
06548 char owner[256];
06549 char connection[256];
06550 char *stime = "t=0 0\r\n";
06551 char bandwidth[256] = "";
06552 char *hold;
06553 char m_audio[256];
06554 char m_video[256];
06555 char a_audio[1024];
06556 char a_video[1024];
06557 char *m_audio_next = m_audio;
06558 char *m_video_next = m_video;
06559 size_t m_audio_left = sizeof(m_audio);
06560 size_t m_video_left = sizeof(m_video);
06561 char *a_audio_next = a_audio;
06562 char *a_video_next = a_video;
06563 size_t a_audio_left = sizeof(a_audio);
06564 size_t a_video_left = sizeof(a_video);
06565
06566 int x;
06567 int capability;
06568 int needvideo = FALSE;
06569 int debug = sip_debug_test_pvt(p);
06570 int min_audio_packet_size = 0;
06571 int min_video_packet_size = 0;
06572
06573 m_video[0] = '\0';
06574
06575 if (!p->rtp) {
06576 ast_log(LOG_WARNING, "No way to add SDP without an RTP structure\n");
06577 return AST_FAILURE;
06578 }
06579
06580
06581 if (!p->sessionid) {
06582 p->sessionid = getpid();
06583 p->sessionversion = p->sessionid;
06584 } else
06585 p->sessionversion++;
06586
06587
06588 ast_rtp_get_us(p->rtp, &sin);
06589 if (p->vrtp)
06590 ast_rtp_get_us(p->vrtp, &vsin);
06591
06592
06593 if (p->redirip.sin_addr.s_addr) {
06594 dest.sin_port = p->redirip.sin_port;
06595 dest.sin_addr = p->redirip.sin_addr;
06596 } else {
06597 dest.sin_addr = p->ourip;
06598 dest.sin_port = sin.sin_port;
06599 }
06600
06601 capability = p->jointcapability;
06602
06603
06604 if (option_debug > 1) {
06605 char codecbuf[SIPBUFSIZE];
06606 ast_log(LOG_DEBUG, "** Our capability: %s Video flag: %s\n", ast_getformatname_multiple(codecbuf, sizeof(codecbuf), capability), ast_test_flag(&p->flags[0], SIP_NOVIDEO) ? "True" : "False");
06607 ast_log(LOG_DEBUG, "** Our prefcodec: %s \n", ast_getformatname_multiple(codecbuf, sizeof(codecbuf), p->prefcodec));
06608 }
06609
06610 #ifdef WHEN_WE_HAVE_T38_FOR_OTHER_TRANSPORTS
06611 if (ast_test_flag(&p->t38.t38support, SIP_PAGE2_T38SUPPORT_RTP)) {
06612 ast_build_string(&m_audio_next, &m_audio_left, " %d", 191);
06613 ast_build_string(&a_audio_next, &a_audio_left, "a=rtpmap:%d %s/%d\r\n", 191, "t38", 8000);
06614 }
06615 #endif
06616
06617
06618 if ((capability & AST_FORMAT_VIDEO_MASK) && !ast_test_flag(&p->flags[0], SIP_NOVIDEO)) {
06619 if (p->vrtp) {
06620 needvideo = TRUE;
06621 if (option_debug > 1)
06622 ast_log(LOG_DEBUG, "This call needs video offers!\n");
06623 } else if (option_debug > 1)
06624 ast_log(LOG_DEBUG, "This call needs video offers, but there's no video support enabled!\n");
06625 }
06626
06627
06628
06629
06630 if (needvideo) {
06631
06632 if (p->vredirip.sin_addr.s_addr) {
06633 vdest.sin_addr = p->vredirip.sin_addr;
06634 vdest.sin_port = p->vredirip.sin_port;
06635 } else {
06636 vdest.sin_addr = p->ourip;
06637 vdest.sin_port = vsin.sin_port;
06638 }
06639 ast_build_string(&m_video_next, &m_video_left, "m=video %d RTP/AVP", ntohs(vdest.sin_port));
06640
06641
06642 if (p->maxcallbitrate)
06643 snprintf(bandwidth, sizeof(bandwidth), "b=CT:%d\r\n", p->maxcallbitrate);
06644 if (debug)
06645 ast_verbose("Video is at %s port %d\n", ast_inet_ntoa(p->ourip), ntohs(vsin.sin_port));
06646 }
06647
06648 if (debug)
06649 ast_verbose("Audio is at %s port %d\n", ast_inet_ntoa(p->ourip), ntohs(sin.sin_port));
06650
06651
06652
06653
06654
06655
06656 snprintf(owner, sizeof(owner), "o=root %d %d IN IP4 %s\r\n", p->sessionid, p->sessionversion, ast_inet_ntoa(dest.sin_addr));
06657 snprintf(connection, sizeof(connection), "c=IN IP4 %s\r\n", ast_inet_ntoa(dest.sin_addr));
06658 ast_build_string(&m_audio_next, &m_audio_left, "m=audio %d RTP/AVP", ntohs(dest.sin_port));
06659
06660 if (ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD) == SIP_PAGE2_CALL_ONHOLD_ONEDIR)
06661 hold = "a=recvonly\r\n";
06662 else if (ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD) == SIP_PAGE2_CALL_ONHOLD_INACTIVE)
06663 hold = "a=inactive\r\n";
06664 else
06665 hold = "a=sendrecv\r\n";
06666
06667
06668
06669
06670
06671
06672
06673
06674
06675
06676 if (capability & p->prefcodec) {
06677 int codec = p->prefcodec & AST_FORMAT_AUDIO_MASK;
06678
06679 add_codec_to_sdp(p, codec, SDP_SAMPLE_RATE(codec),
06680 &m_audio_next, &m_audio_left,
06681 &a_audio_next, &a_audio_left,
06682 debug, &min_audio_packet_size);
06683 alreadysent |= codec;
06684 }
06685
06686
06687 for (x = 0; x < 32; x++) {
06688 int codec;
06689
06690 if (!(codec = ast_codec_pref_index(&p->prefs, x)))
06691 break;
06692
06693 if (!(capability & codec))
06694 continue;
06695
06696 if (alreadysent & codec)
06697 continue;
06698
06699 add_codec_to_sdp(p, codec, SDP_SAMPLE_RATE(codec),
06700 &m_audio_next, &m_audio_left,
06701 &a_audio_next, &a_audio_left,
06702 debug, &min_audio_packet_size);
06703 alreadysent |= codec;
06704 }
06705
06706
06707 for (x = 1; x <= (needvideo ? AST_FORMAT_MAX_VIDEO : AST_FORMAT_MAX_AUDIO); x <<= 1) {
06708 if (!(capability & x))
06709 continue;
06710
06711 if (alreadysent & x)
06712 continue;
06713
06714 if (x <= AST_FORMAT_MAX_AUDIO)
06715 add_codec_to_sdp(p, x, SDP_SAMPLE_RATE(x),
06716 &m_audio_next, &m_audio_left,
06717 &a_audio_next, &a_audio_left,
06718 debug, &min_audio_packet_size);
06719 else
06720 add_codec_to_sdp(p, x, 90000,
06721 &m_video_next, &m_video_left,
06722 &a_video_next, &a_video_left,
06723 debug, &min_video_packet_size);
06724 }
06725
06726
06727 for (x = 1; x <= AST_RTP_MAX; x <<= 1) {
06728 if (!(p->jointnoncodeccapability & x))
06729 continue;
06730
06731 add_noncodec_to_sdp(p, x, 8000,
06732 &m_audio_next, &m_audio_left,
06733 &a_audio_next, &a_audio_left,
06734 debug);
06735 }
06736
06737 if (option_debug > 2)
06738 ast_log(LOG_DEBUG, "-- Done with adding codecs to SDP\n");
06739
06740 if (!p->owner || !ast_internal_timing_enabled(p->owner))
06741 ast_build_string(&a_audio_next, &a_audio_left, "a=silenceSupp:off - - - -\r\n");
06742
06743 if (min_audio_packet_size)
06744 ast_build_string(&a_audio_next, &a_audio_left, "a=ptime:%d\r\n", min_audio_packet_size);
06745
06746 if (min_video_packet_size)
06747 ast_build_string(&a_video_next, &a_video_left, "a=ptime:%d\r\n", min_video_packet_size);
06748
06749 if ((m_audio_left < 2) || (m_video_left < 2) || (a_audio_left == 0) || (a_video_left == 0))
06750 ast_log(LOG_WARNING, "SIP SDP may be truncated due to undersized buffer!!\n");
06751
06752 ast_build_string(&m_audio_next, &m_audio_left, "\r\n");
06753 if (needvideo)
06754 ast_build_string(&m_video_next, &m_video_left, "\r\n");
06755
06756 len = strlen(version) + strlen(subject) + strlen(owner) + strlen(connection) + strlen(stime) + strlen(m_audio) + strlen(a_audio) + strlen(hold);
06757 if (needvideo)
06758 len += strlen(m_video) + strlen(a_video) + strlen(bandwidth) + strlen(hold);
06759
06760 add_header(resp, "Content-Type", "application/sdp");
06761 add_header_contentLength(resp, len);
06762 add_line(resp, version);
06763 add_line(resp, owner);
06764 add_line(resp, subject);
06765 add_line(resp, connection);
06766 if (needvideo)
06767 add_line(resp, bandwidth);
06768 add_line(resp, stime);
06769 add_line(resp, m_audio);
06770 add_line(resp, a_audio);
06771 add_line(resp, hold);
06772 if (needvideo) {
06773 add_line(resp, m_video);
06774 add_line(resp, a_video);
06775 add_line(resp, hold);
06776 }
06777
06778
06779 p->lastrtprx = p->lastrtptx = time(NULL);
06780
06781 if (option_debug > 2) {
06782 char buf[SIPBUFSIZE];
06783 ast_log(LOG_DEBUG, "Done building SDP. Settling with this capability: %s\n", ast_getformatname_multiple(buf, SIPBUFSIZE, capability));
06784 }
06785
06786 return AST_SUCCESS;
06787 }
06788
06789
06790 static int transmit_response_with_t38_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans)
06791 {
06792 struct sip_request resp;
06793 int seqno;
06794
06795 if (sscanf(get_header(req, "CSeq"), "%d ", &seqno) != 1) {
06796 ast_log(LOG_WARNING, "Unable to get seqno from '%s'\n", get_header(req, "CSeq"));
06797 return -1;
06798 }
06799 respprep(&resp, p, msg, req);
06800 if (p->udptl) {
06801 ast_udptl_offered_from_local(p->udptl, 0);
06802 add_t38_sdp(&resp, p);
06803 } else
06804 ast_log(LOG_ERROR, "Can't add SDP to response, since we have no UDPTL session allocated. Call-ID %s\n", p->callid);
06805 if (retrans && !p->pendinginvite)
06806 p->pendinginvite = seqno;
06807 return send_response(p, &resp, retrans, seqno);
06808 }
06809
06810
06811 static void copy_request(struct sip_request *dst, const struct sip_request *src)
06812 {
06813 long offset;
06814 int x;
06815 offset = ((void *)dst) - ((void *)src);
06816
06817 memcpy(dst, src, sizeof(*dst));
06818
06819 for (x=0; x < src->headers; x++)
06820 dst->header[x] += offset;
06821 for (x=0; x < src->lines; x++)
06822 dst->line[x] += offset;
06823 dst->rlPart1 += offset;
06824 dst->rlPart2 += offset;
06825 }
06826
06827
06828
06829
06830 static int transmit_response_with_sdp(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable)
06831 {
06832 struct sip_request resp;
06833 int seqno;
06834 if (sscanf(get_header(req, "CSeq"), "%d ", &seqno) != 1) {
06835 ast_log(LOG_WARNING, "Unable to get seqno from '%s'\n", get_header(req, "CSeq"));
06836 return -1;
06837 }
06838 respprep(&resp, p, msg, req);
06839 if (p->rtp) {
06840 if (!p->autoframing && !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
06841 if (option_debug)
06842 ast_log(LOG_DEBUG, "Setting framing from config on incoming call\n");
06843 ast_rtp_codec_setpref(p->rtp, &p->prefs);
06844 }
06845 try_suggested_sip_codec(p);
06846 add_sdp(&resp, p);
06847 } else
06848 ast_log(LOG_ERROR, "Can't add SDP to response, since we have no RTP session allocated. Call-ID %s\n", p->callid);
06849 if (reliable && !p->pendinginvite)
06850 p->pendinginvite = seqno;
06851 return send_response(p, &resp, reliable, seqno);
06852 }
06853
06854
06855 static int determine_firstline_parts(struct sip_request *req)
06856 {
06857 char *e = ast_skip_blanks(req->header[0]);
06858
06859 if (!*e)
06860 return -1;
06861 req->rlPart1 = e;
06862 e = ast_skip_nonblanks(e);
06863 if (*e)
06864 *e++ = '\0';
06865
06866 e = ast_skip_blanks(e);
06867 if ( !*e )
06868 return -1;
06869 ast_trim_blanks(e);
06870
06871 if (!strcasecmp(req->rlPart1, "SIP/2.0") ) {
06872 if (strlen(e) < 3)
06873 return -1;
06874 req->rlPart2 = e;
06875 } else {
06876 if ( *e == '<' ) {
06877 ast_log(LOG_WARNING, "bogus uri in <> %s\n", e);
06878 e++;
06879 if (!*e)
06880 return -1;
06881 }
06882 req->rlPart2 = e;
06883 e = ast_skip_nonblanks(e);
06884 if (*e)
06885 *e++ = '\0';
06886 e = ast_skip_blanks(e);
06887 if (strcasecmp(e, "SIP/2.0") ) {
06888 ast_log(LOG_WARNING, "Bad request protocol %s\n", e);
06889 return -1;
06890 }
06891 }
06892 return 1;
06893 }
06894
06895
06896
06897
06898
06899
06900
06901 static int transmit_reinvite_with_sdp(struct sip_pvt *p)
06902 {
06903 struct sip_request req;
06904
06905 reqprep(&req, p, ast_test_flag(&p->flags[0], SIP_REINVITE_UPDATE) ? SIP_UPDATE : SIP_INVITE, 0, 1);
06906
06907 add_header(&req, "Allow", ALLOWED_METHODS);
06908 add_header(&req, "Supported", SUPPORTED_EXTENSIONS);
06909 if (sipdebug)
06910 add_header(&req, "X-asterisk-Info", "SIP re-invite (External RTP bridge)");
06911 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
06912 append_history(p, "ReInv", "Re-invite sent");
06913 add_sdp(&req, p);
06914
06915 initialize_initreq(p, &req);
06916 p->lastinvite = p->ocseq;
06917 ast_set_flag(&p->flags[0], SIP_OUTGOING);
06918 return send_request(p, &req, XMIT_CRITICAL, p->ocseq);
06919 }
06920
06921
06922
06923
06924
06925 static int transmit_reinvite_with_t38_sdp(struct sip_pvt *p)
06926 {
06927 struct sip_request req;
06928
06929 reqprep(&req, p, ast_test_flag(&p->flags[0], SIP_REINVITE_UPDATE) ? SIP_UPDATE : SIP_INVITE, 0, 1);
06930
06931 add_header(&req, "Allow", ALLOWED_METHODS);
06932 add_header(&req, "Supported", SUPPORTED_EXTENSIONS);
06933 if (sipdebug)
06934 add_header(&req, "X-asterisk-info", "SIP re-invite (T38 switchover)");
06935 ast_udptl_offered_from_local(p->udptl, 1);
06936 add_t38_sdp(&req, p);
06937
06938 initialize_initreq(p, &req);
06939 ast_set_flag(&p->flags[0], SIP_OUTGOING);
06940 p->lastinvite = p->ocseq;
06941 return send_request(p, &req, XMIT_CRITICAL, p->ocseq);
06942 }
06943
06944
06945 static void extract_uri(struct sip_pvt *p, struct sip_request *req)
06946 {
06947 char stripped[SIPBUFSIZE];
06948 char *c;
06949
06950 ast_copy_string(stripped, get_header(req, "Contact"), sizeof(stripped));
06951 c = get_in_brackets(stripped);
06952 c = strsep(&c, ";");
06953 if (!ast_strlen_zero(c))
06954 ast_string_field_set(p, uri, c);
06955 }
06956
06957
06958 static void build_contact(struct sip_pvt *p)
06959 {
06960
06961 if (ourport != STANDARD_SIP_PORT)
06962 ast_string_field_build(p, our_contact, "<sip:%s%s%s:%d>", p->exten, ast_strlen_zero(p->exten) ? "" : "@", ast_inet_ntoa(p->ourip), ourport);
06963 else
06964 ast_string_field_build(p, our_contact, "<sip:%s%s%s>", p->exten, ast_strlen_zero(p->exten) ? "" : "@", ast_inet_ntoa(p->ourip));
06965 }
06966
06967
06968 static void build_rpid(struct sip_pvt *p)
06969 {
06970 int send_pres_tags = TRUE;
06971 const char *privacy=NULL;
06972 const char *screen=NULL;
06973 char buf[256];
06974 const char *clid = default_callerid;
06975 const char *clin = NULL;
06976 const char *fromdomain;
06977
06978 if (!ast_strlen_zero(p->rpid) || !ast_strlen_zero(p->rpid_from))
06979 return;
06980
06981 if (p->owner && p->owner->cid.cid_num)
06982 clid = p->owner->cid.cid_num;
06983 if (p->owner && p->owner->cid.cid_name)
06984 clin = p->owner->cid.cid_name;
06985 if (ast_strlen_zero(clin))
06986 clin = clid;
06987
06988 switch (p->callingpres) {
06989 case AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED:
06990 privacy = "off";
06991 screen = "no";
06992 break;
06993 case AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN:
06994 privacy = "off";
06995 screen = "yes";
06996 break;
06997 case AST_PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN:
06998 privacy = "off";
06999 screen = "no";
07000 break;
07001 case AST_PRES_ALLOWED_NETWORK_NUMBER:
07002 privacy = "off";
07003 screen = "yes";
07004 break;
07005 case AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED:
07006 privacy = "full";
07007 screen = "no";
07008 break;
07009 case AST_PRES_PROHIB_USER_NUMBER_PASSED_SCREEN:
07010 privacy = "full";
07011 screen = "yes";
07012 break;
07013 case AST_PRES_PROHIB_USER_NUMBER_FAILED_SCREEN:
07014 privacy = "full";
07015 screen = "no";
07016 break;
07017 case AST_PRES_PROHIB_NETWORK_NUMBER:
07018 privacy = "full";
07019 screen = "yes";
07020 break;
07021 case AST_PRES_NUMBER_NOT_AVAILABLE:
07022 send_pres_tags = FALSE;
07023 break;
07024 default:
07025 ast_log(LOG_WARNING, "Unsupported callingpres (%d)\n", p->callingpres);
07026 if ((p->callingpres & AST_PRES_RESTRICTION) != AST_PRES_ALLOWED)
07027 privacy = "full";
07028 else
07029 privacy = "off";
07030 screen = "no";
07031 break;
07032 }
07033
07034 fromdomain = S_OR(p->fromdomain, ast_inet_ntoa(p->ourip));
07035
07036 snprintf(buf, sizeof(buf), "\"%s\" <sip:%s@%s>", clin, clid, fromdomain);
07037 if (send_pres_tags)
07038 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), ";privacy=%s;screen=%s", privacy, screen);
07039 ast_string_field_set(p, rpid, buf);
07040
07041 ast_string_field_build(p, rpid_from, "\"%s\" <sip:%s@%s>;tag=%s", clin,
07042 S_OR(p->fromuser, clid),
07043 fromdomain, p->tag);
07044 }
07045
07046
07047 static void initreqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod)
07048 {
07049 char invite_buf[256] = "";
07050 char *invite = invite_buf;
07051 size_t invite_max = sizeof(invite_buf);
07052 char from[256];
07053 char to[256];
07054 char tmp[SIPBUFSIZE/2];
07055 char tmp2[SIPBUFSIZE/2];
07056 const char *l = NULL, *n = NULL;
07057 const char *urioptions = "";
07058
07059 if (ast_test_flag(&p->flags[0], SIP_USEREQPHONE)) {
07060 const char *s = p->username;
07061
07062
07063
07064
07065
07066
07067 if (*s == '+')
07068 s++;
07069 for (; *s; s++) {
07070 if (!strchr(AST_DIGIT_ANYNUM, *s) )
07071 break;
07072 }
07073
07074 if (*s)
07075 urioptions = ";user=phone";
07076 }
07077
07078
07079 snprintf(p->lastmsg, sizeof(p->lastmsg), "Init: %s", sip_methods[sipmethod].text);
07080
07081 if (p->owner) {
07082 l = p->owner->cid.cid_num;
07083 n = p->owner->cid.cid_name;
07084 }
07085
07086 if (!ast_test_flag(&p->flags[0], SIP_SENDRPID) &&
07087 ((p->callingpres & AST_PRES_RESTRICTION) != AST_PRES_ALLOWED)) {
07088 l = CALLERID_UNKNOWN;
07089 n = l;
07090 }
07091 if (ast_strlen_zero(l))
07092 l = default_callerid;
07093 if (ast_strlen_zero(n))
07094 n = l;
07095
07096 if (!ast_strlen_zero(p->fromuser))
07097 l = p->fromuser;
07098 else
07099 ast_string_field_set(p, fromuser, l);
07100
07101
07102 if (!ast_strlen_zero(p->fromname))
07103 n = p->fromname;
07104 else
07105 ast_string_field_set(p, fromname, n);
07106
07107 if (pedanticsipchecking) {
07108 ast_uri_encode(n, tmp, sizeof(tmp), 0);
07109 n = tmp;
07110 ast_uri_encode(l, tmp2, sizeof(tmp2), 0);
07111 l = tmp2;
07112 }
07113
07114 if (ourport != STANDARD_SIP_PORT && ast_strlen_zero(p->fromdomain))
07115 snprintf(from, sizeof(from), "\"%s\" <sip:%s@%s:%d>;tag=%s", n, l, S_OR(p->fromdomain, ast_inet_ntoa(p->ourip)), ourport, p->tag);
07116 else
07117 snprintf(from, sizeof(from), "\"%s\" <sip:%s@%s>;tag=%s", n, l, S_OR(p->fromdomain, ast_inet_ntoa(p->ourip)), p->tag);
07118
07119
07120 if (!ast_strlen_zero(p->fullcontact)) {
07121
07122 ast_build_string(&invite, &invite_max, "%s", p->fullcontact);
07123 } else {
07124
07125 ast_build_string(&invite, &invite_max, "sip:");
07126 if (!ast_strlen_zero(p->username)) {
07127 n = p->username;
07128 if (pedanticsipchecking) {
07129 ast_uri_encode(n, tmp, sizeof(tmp), 0);
07130 n = tmp;
07131 }
07132 ast_build_string(&invite, &invite_max, "%s@", n);
07133 }
07134 ast_build_string(&invite, &invite_max, "%s", p->tohost);
07135 if (ntohs(p->sa.sin_port) != STANDARD_SIP_PORT)
07136 ast_build_string(&invite, &invite_max, ":%d", ntohs(p->sa.sin_port));
07137 ast_build_string(&invite, &invite_max, "%s", urioptions);
07138 }
07139
07140
07141 if (p->options && !ast_strlen_zero(p->options->uri_options))
07142 ast_build_string(&invite, &invite_max, ";%s", p->options->uri_options);
07143
07144 ast_string_field_set(p, uri, invite_buf);
07145
07146 if (sipmethod == SIP_NOTIFY && !ast_strlen_zero(p->theirtag)) {
07147
07148 snprintf(to, sizeof(to), "<%s%s>;tag=%s", (strncasecmp(p->uri, "sip:", 4) ? "" : "sip:"), p->uri, p->theirtag);
07149 } else if (p->options && p->options->vxml_url) {
07150
07151 snprintf(to, sizeof(to), "<%s>;%s", p->uri, p->options->vxml_url);
07152 } else
07153 snprintf(to, sizeof(to), "<%s>", p->uri);
07154
07155 init_req(req, sipmethod, p->uri);
07156 snprintf(tmp, sizeof(tmp), "%d %s", ++p->ocseq, sip_methods[sipmethod].text);
07157
07158 add_header(req, "Via", p->via);
07159
07160
07161
07162 if (ast_test_flag(&p->flags[0], SIP_SENDRPID) && (sipmethod == SIP_INVITE)) {
07163 build_rpid(p);
07164 add_header(req, "From", p->rpid_from);
07165 } else
07166 add_header(req, "From", from);
07167 add_header(req, "To", to);
07168 ast_string_field_set(p, exten, l);
07169 build_contact(p);
07170 add_header(req, "Contact", p->our_contact);
07171 add_header(req, "Call-ID", p->callid);
07172 add_header(req, "CSeq", tmp);
07173 if (!ast_strlen_zero(global_useragent))
07174 add_header(req, "User-Agent", global_useragent);
07175 add_header(req, "Max-Forwards", DEFAULT_MAX_FORWARDS);
07176 if (!ast_strlen_zero(p->rpid))
07177 add_header(req, "Remote-Party-ID", p->rpid);
07178 }
07179
07180
07181 static int transmit_invite(struct sip_pvt *p, int sipmethod, int sdp, int init)
07182 {
07183 struct sip_request req;
07184
07185 req.method = sipmethod;
07186 if (init) {
07187
07188 p->branch ^= ast_random();
07189 build_via(p);
07190 if (init > 1)
07191 initreqprep(&req, p, sipmethod);
07192 else
07193 reqprep(&req, p, sipmethod, 0, 1);
07194 } else
07195 reqprep(&req, p, sipmethod, 0, 1);
07196
07197 if (p->options && p->options->auth)
07198 add_header(&req, p->options->authheader, p->options->auth);
07199 append_date(&req);
07200 if (sipmethod == SIP_REFER) {
07201 if (p->refer) {
07202 char buf[SIPBUFSIZE];
07203 if (!ast_strlen_zero(p->refer->refer_to))
07204 add_header(&req, "Refer-To", p->refer->refer_to);
07205 if (!ast_strlen_zero(p->refer->referred_by)) {
07206 snprintf(buf, sizeof(buf), "%s <%s>", p->refer->referred_by_name, p->refer->referred_by);
07207 add_header(&req, "Referred-By", buf);
07208 }
07209 }
07210 }
07211
07212
07213 if (p->options && p->options->replaces && !ast_strlen_zero(p->options->replaces)) {
07214 add_header(&req, "Replaces", p->options->replaces);
07215 add_header(&req, "Require", "replaces");
07216 }
07217
07218 add_header(&req, "Allow", ALLOWED_METHODS);
07219 add_header(&req, "Supported", SUPPORTED_EXTENSIONS);
07220 if (p->options && p->options->addsipheaders && p->owner) {
07221 struct ast_channel *chan = p->owner;
07222 struct varshead *headp;
07223
07224 ast_channel_lock(chan);
07225
07226 headp = &chan->varshead;
07227
07228 if (!headp)
07229 ast_log(LOG_WARNING,"No Headp for the channel...ooops!\n");
07230 else {
07231 const struct ast_var_t *current;
07232 AST_LIST_TRAVERSE(headp, current, entries) {
07233
07234 if (!strncasecmp(ast_var_name(current), "SIPADDHEADER", strlen("SIPADDHEADER"))) {
07235 char *content, *end;
07236 const char *header = ast_var_value(current);
07237 char *headdup = ast_strdupa(header);
07238
07239
07240 if (*headdup == '"')
07241 headdup++;
07242 if ((content = strchr(headdup, ':'))) {
07243 *content++ = '\0';
07244 content = ast_skip_blanks(content);
07245
07246 end = content + strlen(content) -1;
07247 if (*end == '"')
07248 *end = '\0';
07249
07250 add_header(&req, headdup, content);
07251 if (sipdebug)
07252 ast_log(LOG_DEBUG, "Adding SIP Header \"%s\" with content :%s: \n", headdup, content);
07253 }
07254 }
07255 }
07256 }
07257
07258 ast_channel_unlock(chan);
07259 }
07260 if (sdp) {
07261 if (p->udptl && (p->t38.state == T38_LOCAL_DIRECT || p->t38.state == T38_LOCAL_REINVITE)) {
07262 ast_udptl_offered_from_local(p->udptl, 1);
07263 if (option_debug)
07264 ast_log(LOG_DEBUG, "T38 is in state %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
07265 add_t38_sdp(&req, p);
07266 } else if (p->rtp)
07267 add_sdp(&req, p);
07268 } else {
07269 add_header_contentLength(&req, 0);
07270 }
07271
07272 if (!p->initreq.headers || init > 2)
07273 initialize_initreq(p, &req);
07274 p->lastinvite = p->ocseq;
07275 return send_request(p, &req, init ? XMIT_CRITICAL : XMIT_RELIABLE, p->ocseq);
07276 }
07277
07278
07279 static int transmit_state_notify(struct sip_pvt *p, int state, int full, int timeout)
07280 {
07281 char tmp[4000], from[256], to[256];
07282 char *t = tmp, *c, *mfrom, *mto;
07283 size_t maxbytes = sizeof(tmp);
07284 struct sip_request req;
07285 char hint[AST_MAX_EXTENSION];
07286 char *statestring = "terminated";
07287 const struct cfsubscription_types *subscriptiontype;
07288 enum state { NOTIFY_OPEN, NOTIFY_INUSE, NOTIFY_CLOSED } local_state = NOTIFY_OPEN;
07289 char *pidfstate = "--";
07290 char *pidfnote= "Ready";
07291
07292 memset(from, 0, sizeof(from));
07293 memset(to, 0, sizeof(to));
07294 memset(tmp, 0, sizeof(tmp));
07295
07296 switch (state) {
07297 case (AST_EXTENSION_RINGING | AST_EXTENSION_INUSE):
07298 statestring = (global_notifyringing) ? "early" : "confirmed";
07299 local_state = NOTIFY_INUSE;
07300 pidfstate = "busy";
07301 pidfnote = "Ringing";
07302 break;
07303 case AST_EXTENSION_RINGING:
07304 statestring = "early";
07305 local_state = NOTIFY_INUSE;
07306 pidfstate = "busy";
07307 pidfnote = "Ringing";
07308 break;
07309 case AST_EXTENSION_INUSE:
07310 statestring = "confirmed";
07311 local_state = NOTIFY_INUSE;
07312 pidfstate = "busy";
07313 pidfnote = "On the phone";
07314 break;
07315 case AST_EXTENSION_BUSY:
07316 statestring = "confirmed";
07317 local_state = NOTIFY_CLOSED;
07318 pidfstate = "busy";
07319 pidfnote = "On the phone";
07320 break;
07321 case AST_EXTENSION_UNAVAILABLE:
07322 statestring = "terminated";
07323 local_state = NOTIFY_CLOSED;
07324 pidfstate = "away";
07325 pidfnote = "Unavailable";
07326 break;
07327 case AST_EXTENSION_ONHOLD:
07328 statestring = "confirmed";
07329 local_state = NOTIFY_CLOSED;
07330 pidfstate = "busy";
07331 pidfnote = "On Hold";
07332 break;
07333 case AST_EXTENSION_NOT_INUSE:
07334 default:
07335
07336 break;
07337 }
07338
07339 subscriptiontype = find_subscription_type(p->subscribed);
07340
07341
07342 if (ast_get_hint(hint, sizeof(hint), NULL, 0, NULL, p->context, p->exten)) {
07343 char *hint2 = hint, *individual_hint = NULL;
07344 int hint_count = 0, unavailable_count = 0;
07345
07346 while ((individual_hint = strsep(&hint2, "&"))) {
07347 hint_count++;
07348
07349 if (ast_device_state(individual_hint) == AST_DEVICE_UNAVAILABLE)
07350 unavailable_count++;
07351 }
07352
07353
07354
07355
07356 if (hint_count > 0 && hint_count == unavailable_count) {
07357 local_state = NOTIFY_CLOSED;
07358 pidfstate = "away";
07359 pidfnote = "Not online";
07360 }
07361 }
07362
07363 ast_copy_string(from, get_header(&p->initreq, "From"), sizeof(from));
07364 c = get_in_brackets(from);
07365 if (strncasecmp(c, "sip:", 4)) {
07366 ast_log(LOG_WARNING, "Huh? Not a SIP header (%s)?\n", c);
07367 return -1;
07368 }
07369 mfrom = strsep(&c, ";");
07370
07371 ast_copy_string(to, get_header(&p->initreq, "To"), sizeof(to));
07372 c = get_in_brackets(to);
07373 if (strncasecmp(c, "sip:", 4)) {
07374 ast_log(LOG_WARNING, "Huh? Not a SIP header (%s)?\n", c);
07375 return -1;
07376 }
07377 mto = strsep(&c, ";");
07378
07379 reqprep(&req, p, SIP_NOTIFY, 0, 1);
07380
07381
07382 add_header(&req, "Event", subscriptiontype->event);
07383 add_header(&req, "Content-Type", subscriptiontype->mediatype);
07384 switch(state) {
07385 case AST_EXTENSION_DEACTIVATED:
07386 if (timeout)
07387 add_header(&req, "Subscription-State", "terminated;reason=timeout");
07388 else {
07389 add_header(&req, "Subscription-State", "terminated;reason=probation");
07390 add_header(&req, "Retry-After", "60");
07391 }
07392 break;
07393 case AST_EXTENSION_REMOVED:
07394 add_header(&req, "Subscription-State", "terminated;reason=noresource");
07395 break;
07396 default:
07397 if (p->expiry)
07398 add_header(&req, "Subscription-State", "active");
07399 else
07400 add_header(&req, "Subscription-State", "terminated;reason=timeout");
07401 }
07402 switch (p->subscribed) {
07403 case XPIDF_XML:
07404 case CPIM_PIDF_XML:
07405 ast_build_string(&t, &maxbytes, "<?xml version=\"1.0\"?>\n");
07406 ast_build_string(&t, &maxbytes, "<!DOCTYPE presence PUBLIC \"-//IETF//DTD RFCxxxx XPIDF 1.0//EN\" \"xpidf.dtd\">\n");
07407 ast_build_string(&t, &maxbytes, "<presence>\n");
07408 ast_build_string(&t, &maxbytes, "<presentity uri=\"%s;method=SUBSCRIBE\" />\n", mfrom);
07409 ast_build_string(&t, &maxbytes, "<atom id=\"%s\">\n", p->exten);
07410 ast_build_string(&t, &maxbytes, "<address uri=\"%s;user=ip\" priority=\"0.800000\">\n", mto);
07411 ast_build_string(&t, &maxbytes, "<status status=\"%s\" />\n", (local_state == NOTIFY_OPEN) ? "open" : (local_state == NOTIFY_INUSE) ? "inuse" : "closed");
07412 ast_build_string(&t, &maxbytes, "<msnsubstatus substatus=\"%s\" />\n", (local_state == NOTIFY_OPEN) ? "online" : (local_state == NOTIFY_INUSE) ? "onthephone" : "offline");
07413 ast_build_string(&t, &maxbytes, "</address>\n</atom>\n</presence>\n");
07414 break;
07415 case PIDF_XML:
07416 ast_build_string(&t, &maxbytes, "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n");
07417 ast_build_string(&t, &maxbytes, "<presence xmlns=\"urn:ietf:params:xml:ns:pidf\" \nxmlns:pp=\"urn:ietf:params:xml:ns:pidf:person\"\nxmlns:es=\"urn:ietf:params:xml:ns:pidf:rpid:status:rpid-status\"\nxmlns:ep=\"urn:ietf:params:xml:ns:pidf:rpid:rpid-person\"\nentity=\"%s\">\n", mfrom);
07418 ast_build_string(&t, &maxbytes, "<pp:person><status>\n");
07419 if (pidfstate[0] != '-')
07420 ast_build_string(&t, &maxbytes, "<ep:activities><ep:%s/></ep:activities>\n", pidfstate);
07421 ast_build_string(&t, &maxbytes, "</status></pp:person>\n");
07422 ast_build_string(&t, &maxbytes, "<note>%s</note>\n", pidfnote);
07423 ast_build_string(&t, &maxbytes, "<tuple id=\"%s\">\n", p->exten);
07424 ast_build_string(&t, &maxbytes, "<contact priority=\"1\">%s</contact>\n", mto);
07425 if (pidfstate[0] == 'b')
07426 ast_build_string(&t, &maxbytes, "<status><basic>open</basic></status>\n");
07427 else
07428 ast_build_string(&t, &maxbytes, "<status><basic>%s</basic></status>\n", (local_state != NOTIFY_CLOSED) ? "open" : "closed");
07429 ast_build_string(&t, &maxbytes, "</tuple>\n</presence>\n");
07430 break;
07431 case DIALOG_INFO_XML:
07432 ast_build_string(&t, &maxbytes, "<?xml version=\"1.0\"?>\n");
07433 ast_build_string(&t, &maxbytes, "<dialog-info xmlns=\"urn:ietf:params:xml:ns:dialog-info\" version=\"%d\" state=\"%s\" entity=\"%s\">\n", p->dialogver++, full ? "full":"partial", mto);
07434 if ((state & AST_EXTENSION_RINGING) && global_notifyringing)
07435 ast_build_string(&t, &maxbytes, "<dialog id=\"%s\" direction=\"recipient\">\n", p->exten);
07436 else
07437 ast_build_string(&t, &maxbytes, "<dialog id=\"%s\">\n", p->exten);
07438 ast_build_string(&t, &maxbytes, "<state>%s</state>\n", statestring);
07439 if (state == AST_EXTENSION_ONHOLD) {
07440 ast_build_string(&t, &maxbytes, "<local>\n<target uri=\"%s\">\n"
07441 "<param pname=\"+sip.rendering\" pvalue=\"no\"/>\n"
07442 "</target>\n</local>\n", mto);
07443 }
07444 ast_build_string(&t, &maxbytes, "</dialog>\n</dialog-info>\n");
07445 break;
07446 case NONE:
07447 default:
07448 break;
07449 }
07450
07451 if (t > tmp + sizeof(tmp))
07452 ast_log(LOG_WARNING, "Buffer overflow detected!! (Please file a bug report)\n");
07453
07454 add_header_contentLength(&req, strlen(tmp));
07455 add_line(&req, tmp);
07456 p->pendinginvite = p->ocseq;
07457
07458 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
07459 }
07460
07461
07462
07463
07464
07465
07466
07467 static int transmit_notify_with_mwi(struct sip_pvt *p, int newmsgs, int oldmsgs, char *vmexten)
07468 {
07469 struct sip_request req;
07470 char tmp[500];
07471 char *t = tmp;
07472 size_t maxbytes = sizeof(tmp);
07473
07474 initreqprep(&req, p, SIP_NOTIFY);
07475 add_header(&req, "Event", "message-summary");
07476 add_header(&req, "Content-Type", default_notifymime);
07477
07478 ast_build_string(&t, &maxbytes, "Messages-Waiting: %s\r\n", newmsgs ? "yes" : "no");
07479 ast_build_string(&t, &maxbytes, "Message-Account: sip:%s@%s\r\n",
07480 S_OR(vmexten, default_vmexten), S_OR(p->fromdomain, ast_inet_ntoa(p->ourip)));
07481
07482
07483
07484 ast_build_string(&t, &maxbytes, "Voice-Message: %d/%d%s\r\n", newmsgs, oldmsgs, (ast_test_flag(&p->flags[1], SIP_PAGE2_BUGGY_MWI) ? "" : " (0/0)"));
07485
07486 if (p->subscribed) {
07487 if (p->expiry)
07488 add_header(&req, "Subscription-State", "active");
07489 else
07490 add_header(&req, "Subscription-State", "terminated;reason=timeout");
07491 }
07492
07493 if (t > tmp + sizeof(tmp))
07494 ast_log(LOG_WARNING, "Buffer overflow detected!! (Please file a bug report)\n");
07495
07496 add_header_contentLength(&req, strlen(tmp));
07497 add_line(&req, tmp);
07498
07499 if (!p->initreq.headers)
07500 initialize_initreq(p, &req);
07501 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
07502 }
07503
07504
07505 static int transmit_sip_request(struct sip_pvt *p, struct sip_request *req)
07506 {
07507 if (!p->initreq.headers)
07508 initialize_initreq(p, req);
07509 return send_request(p, req, XMIT_UNRELIABLE, p->ocseq);
07510 }
07511
07512
07513 static int transmit_notify_with_sipfrag(struct sip_pvt *p, int cseq, char *message, int terminate)
07514 {
07515 struct sip_request req;
07516 char tmp[SIPBUFSIZE/2];
07517
07518 reqprep(&req, p, SIP_NOTIFY, 0, 1);
07519 snprintf(tmp, sizeof(tmp), "refer;id=%d", cseq);
07520 add_header(&req, "Event", tmp);
07521 add_header(&req, "Subscription-state", terminate ? "terminated;reason=noresource" : "active");
07522 add_header(&req, "Content-Type", "message/sipfrag;version=2.0");
07523 add_header(&req, "Allow", ALLOWED_METHODS);
07524 add_header(&req, "Supported", SUPPORTED_EXTENSIONS);
07525
07526 snprintf(tmp, sizeof(tmp), "SIP/2.0 %s\r\n", message);
07527 add_header_contentLength(&req, strlen(tmp));
07528 add_line(&req, tmp);
07529
07530 if (!p->initreq.headers)
07531 initialize_initreq(p, &req);
07532
07533 p->lastnoninvite = p->ocseq;
07534
07535 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
07536 }
07537
07538
07539 static char *regstate2str(enum sipregistrystate regstate)
07540 {
07541 switch(regstate) {
07542 case REG_STATE_FAILED:
07543 return "Failed";
07544 case REG_STATE_UNREGISTERED:
07545 return "Unregistered";
07546 case REG_STATE_REGSENT:
07547 return "Request Sent";
07548 case REG_STATE_AUTHSENT:
07549 return "Auth. Sent";
07550 case REG_STATE_REGISTERED:
07551 return "Registered";
07552 case REG_STATE_REJECTED:
07553 return "Rejected";
07554 case REG_STATE_TIMEOUT:
07555 return "Timeout";
07556 case REG_STATE_NOAUTH:
07557 return "No Authentication";
07558 default:
07559 return "Unknown";
07560 }
07561 }
07562
07563
07564 static int sip_reregister(const void *data)
07565 {
07566
07567 struct sip_registry *r= ASTOBJ_REF((struct sip_registry *) data);
07568
07569
07570 if (!r)
07571 return 0;
07572
07573 if (r->call && !ast_test_flag(&r->call->flags[0], SIP_NO_HISTORY))
07574 append_history(r->call, "RegistryRenew", "Account: %s@%s", r->username, r->hostname);
07575
07576
07577 if (sipdebug)
07578 ast_log(LOG_NOTICE, " -- Re-registration for %s@%s\n", r->username, r->hostname);
07579
07580 r->expire = -1;
07581 __sip_do_register(r);
07582 ASTOBJ_UNREF(r, sip_registry_destroy);
07583 return 0;
07584 }
07585
07586
07587 static int __sip_do_register(struct sip_registry *r)
07588 {
07589 int res;
07590
07591 res = transmit_register(r, SIP_REGISTER, NULL, NULL);
07592 return res;
07593 }
07594
07595
07596 static int sip_reg_timeout(const void *data)
07597 {
07598
07599
07600 struct sip_registry *r = ASTOBJ_REF((struct sip_registry *) data);
07601 struct sip_pvt *p;
07602 int res;
07603
07604
07605 if (!r)
07606 return 0;
07607
07608 ast_log(LOG_NOTICE, " -- Registration for '%s@%s' timed out, trying again (Attempt #%d)\n", r->username, r->hostname, r->regattempts);
07609 if (r->call) {
07610
07611
07612 p = r->call;
07613 ast_mutex_lock(&p->lock);
07614 if (p->registry)
07615 ASTOBJ_UNREF(p->registry, sip_registry_destroy);
07616 r->call = NULL;
07617 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
07618
07619 __sip_pretend_ack(p);
07620 ast_mutex_unlock(&p->lock);
07621 }
07622
07623 if (global_regattempts_max && (r->regattempts > global_regattempts_max)) {
07624
07625
07626
07627 ast_log(LOG_NOTICE, " -- Giving up forever trying to register '%s@%s'\n", r->username, r->hostname);
07628 r->regstate = REG_STATE_FAILED;
07629 } else {
07630 r->regstate = REG_STATE_UNREGISTERED;
07631 r->timeout = -1;
07632 res=transmit_register(r, SIP_REGISTER, NULL, NULL);
07633 }
07634 manager_event(EVENT_FLAG_SYSTEM, "Registry", "ChannelDriver: SIP\r\nUsername: %s\r\nDomain: %s\r\nStatus: %s\r\n", r->username, r->hostname, regstate2str(r->regstate));
07635 ASTOBJ_UNREF(r, sip_registry_destroy);
07636 return 0;
07637 }
07638
07639
07640 static int transmit_register(struct sip_registry *r, int sipmethod, const char *auth, const char *authheader)
07641 {
07642 struct sip_request req;
07643 char from[256];
07644 char to[256];
07645 char tmp[80];
07646 char addr[80];
07647 struct sip_pvt *p;
07648 char *fromdomain;
07649
07650
07651 if ( r == NULL || ((auth==NULL) && (r->regstate==REG_STATE_REGSENT || r->regstate==REG_STATE_AUTHSENT))) {
07652 ast_log(LOG_NOTICE, "Strange, trying to register %s@%s when registration already pending\n", r->username, r->hostname);
07653 return 0;
07654 }
07655
07656 if (r->call) {
07657 if (!auth) {
07658 ast_log(LOG_WARNING, "Already have a REGISTER going on to %s@%s?? \n", r->username, r->hostname);
07659 return 0;
07660 } else {
07661 p = r->call;
07662 make_our_tag(p->tag, sizeof(p->tag));
07663 ast_string_field_free(p, theirtag);
07664 }
07665 } else {
07666
07667 if (!r->callid_valid) {
07668 build_callid_registry(r, __ourip, default_fromdomain);
07669 r->callid_valid = TRUE;
07670 }
07671
07672 if (!(p = sip_alloc( r->callid, NULL, 0, SIP_REGISTER))) {
07673 ast_log(LOG_WARNING, "Unable to allocate registration transaction (memory or socket error)\n");
07674 return 0;
07675 }
07676 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
07677 append_history(p, "RegistryInit", "Account: %s@%s", r->username, r->hostname);
07678
07679 if (create_addr(p, r->hostname)) {
07680
07681
07682 sip_destroy(p);
07683
07684 if (r->timeout > -1)
07685 ast_log(LOG_WARNING, "Still have a registration timeout for %s@%s (create_addr() error), %d\n", r->username, r->hostname, r->timeout);
07686 else
07687 ast_log(LOG_WARNING, "Probably a DNS error for registration to %s@%s, trying REGISTER again (after %d seconds)\n", r->username, r->hostname, global_reg_timeout);
07688
07689 AST_SCHED_DEL(sched, r->timeout);
07690 r->timeout = ast_sched_add(sched, global_reg_timeout * 1000, sip_reg_timeout, r);
07691 r->regattempts++;
07692 return 0;
07693 }
07694
07695 ast_string_field_set(r, callid, p->callid);
07696 if (r->portno) {
07697 p->sa.sin_port = htons(r->portno);
07698 p->recv.sin_port = htons(r->portno);
07699 } else
07700 r->portno = ntohs(p->sa.sin_port);
07701 ast_set_flag(&p->flags[0], SIP_OUTGOING);
07702 r->call=p;
07703 p->registry = ASTOBJ_REF(r);
07704 if (!ast_strlen_zero(r->secret))
07705 ast_string_field_set(p, peersecret, r->secret);
07706 if (!ast_strlen_zero(r->md5secret))
07707 ast_string_field_set(p, peermd5secret, r->md5secret);
07708
07709
07710 if (!ast_strlen_zero(r->authuser)) {
07711 ast_string_field_set(p, peername, r->authuser);
07712 ast_string_field_set(p, authname, r->authuser);
07713 } else if (!ast_strlen_zero(r->username)) {
07714 ast_string_field_set(p, peername, r->username);
07715 ast_string_field_set(p, authname, r->username);
07716 ast_string_field_set(p, fromuser, r->username);
07717 }
07718 if (!ast_strlen_zero(r->username))
07719 ast_string_field_set(p, username, r->username);
07720
07721 ast_string_field_set(p, exten, r->contact);
07722
07723
07724
07725
07726
07727
07728 if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
07729 p->ourip = bindaddr.sin_addr;
07730 build_contact(p);
07731 }
07732
07733
07734 if (auth == NULL) {
07735 if (r->timeout > -1)
07736 ast_log(LOG_WARNING, "Still have a registration timeout, #%d - deleting it\n", r->timeout);
07737 AST_SCHED_DEL(sched, r->timeout);
07738 r->timeout = ast_sched_add(sched, global_reg_timeout * 1000, sip_reg_timeout, r);
07739 if (option_debug)
07740 ast_log(LOG_DEBUG, "Scheduled a registration timeout for %s id #%d \n", r->hostname, r->timeout);
07741 }
07742
07743 if ((fromdomain = strchr(r->username, '@'))) {
07744
07745 snprintf(from, sizeof(from), "<sip:%s>;tag=%s", r->username, p->tag);
07746 if (!ast_strlen_zero(p->theirtag))
07747 snprintf(to, sizeof(to), "<sip:%s>;tag=%s", r->username, p->theirtag);
07748 else
07749 snprintf(to, sizeof(to), "<sip:%s>", r->username);
07750
07751
07752
07753 if (ast_strlen_zero(p->fromdomain)) {
07754 ast_string_field_set(p, fromdomain, ++fromdomain);
07755 }
07756 } else {
07757 snprintf(from, sizeof(from), "<sip:%s@%s>;tag=%s", r->username, p->tohost, p->tag);
07758 if (!ast_strlen_zero(p->theirtag))
07759 snprintf(to, sizeof(to), "<sip:%s@%s>;tag=%s", r->username, p->tohost, p->theirtag);
07760 else
07761 snprintf(to, sizeof(to), "<sip:%s@%s>", r->username, p->tohost);
07762 }
07763
07764
07765
07766 if (!ast_strlen_zero(p->fromdomain)) {
07767 if (r->portno && r->portno != STANDARD_SIP_PORT)
07768 snprintf(addr, sizeof(addr), "sip:%s:%d", p->fromdomain, r->portno);
07769 else
07770 snprintf(addr, sizeof(addr), "sip:%s", p->fromdomain);
07771 } else {
07772 if (r->portno && r->portno != STANDARD_SIP_PORT)
07773 snprintf(addr, sizeof(addr), "sip:%s:%d", r->hostname, r->portno);
07774 else
07775 snprintf(addr, sizeof(addr), "sip:%s", r->hostname);
07776 }
07777 ast_string_field_set(p, uri, addr);
07778
07779 p->branch ^= ast_random();
07780
07781 init_req(&req, sipmethod, addr);
07782
07783
07784 snprintf(tmp, sizeof(tmp), "%u %s", ++r->ocseq, sip_methods[sipmethod].text);
07785 p->ocseq = r->ocseq;
07786
07787 build_via(p);
07788 add_header(&req, "Via", p->via);
07789 add_header(&req, "From", from);
07790 add_header(&req, "To", to);
07791 add_header(&req, "Call-ID", p->callid);
07792 add_header(&req, "CSeq", tmp);
07793 if (!ast_strlen_zero(global_useragent))
07794 add_header(&req, "User-Agent", global_useragent);
07795 add_header(&req, "Max-Forwards", DEFAULT_MAX_FORWARDS);
07796
07797
07798 if (auth)
07799 add_header(&req, authheader, auth);
07800 else if (!ast_strlen_zero(r->nonce)) {
07801 char digest[1024];
07802
07803
07804 if (sipdebug)
07805 ast_log(LOG_DEBUG, " >>> Re-using Auth data for %s@%s\n", r->username, r->hostname);
07806 ast_string_field_set(p, realm, r->realm);
07807 ast_string_field_set(p, nonce, r->nonce);
07808 ast_string_field_set(p, domain, r->domain);
07809 ast_string_field_set(p, opaque, r->opaque);
07810 ast_string_field_set(p, qop, r->qop);
07811 r->noncecount++;
07812 p->noncecount = r->noncecount;
07813
07814 memset(digest,0,sizeof(digest));
07815 if(!build_reply_digest(p, sipmethod, digest, sizeof(digest)))
07816 add_header(&req, "Authorization", digest);
07817 else
07818 ast_log(LOG_NOTICE, "No authorization available for authentication of registration to %s@%s\n", r->username, r->hostname);
07819
07820 }
07821
07822 snprintf(tmp, sizeof(tmp), "%d", default_expiry);
07823 add_header(&req, "Expires", tmp);
07824 add_header(&req, "Contact", p->our_contact);
07825 add_header(&req, "Event", "registration");
07826 add_header_contentLength(&req, 0);
07827
07828 initialize_initreq(p, &req);
07829 if (sip_debug_test_pvt(p))
07830 ast_verbose("REGISTER %d headers, %d lines\n", p->initreq.headers, p->initreq.lines);
07831 r->regstate = auth ? REG_STATE_AUTHSENT : REG_STATE_REGSENT;
07832 r->regattempts++;
07833 if (option_debug > 3)
07834 ast_verbose("REGISTER attempt %d to %s@%s\n", r->regattempts, r->username, r->hostname);
07835 return send_request(p, &req, XMIT_CRITICAL, p->ocseq);
07836 }
07837
07838
07839 static int transmit_message_with_text(struct sip_pvt *p, const char *text)
07840 {
07841 struct sip_request req;
07842
07843 reqprep(&req, p, SIP_MESSAGE, 0, 1);
07844 add_text(&req, text);
07845 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
07846 }
07847
07848
07849 static int sip_refer_allocate(struct sip_pvt *p)
07850 {
07851 p->refer = ast_calloc(1, sizeof(struct sip_refer));
07852 return p->refer ? 1 : 0;
07853 }
07854
07855
07856
07857
07858
07859
07860 static int transmit_refer(struct sip_pvt *p, const char *dest)
07861 {
07862 struct sip_request req = {
07863 .headers = 0,
07864 };
07865 char from[256];
07866 const char *of;
07867 char *c;
07868 char referto[256];
07869 char *ttag, *ftag;
07870 char *theirtag = ast_strdupa(p->theirtag);
07871
07872 if (option_debug || sipdebug)
07873 ast_log(LOG_DEBUG, "SIP transfer of %s to %s\n", p->callid, dest);
07874
07875
07876 if (ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
07877 of = get_header(&p->initreq, "To");
07878 ttag = theirtag;
07879 ftag = p->tag;
07880 } else {
07881 of = get_header(&p->initreq, "From");
07882 ftag = theirtag;
07883 ttag = p->tag;
07884 }
07885
07886 ast_copy_string(from, of, sizeof(from));
07887 of = get_in_brackets(from);
07888 ast_string_field_set(p, from, of);
07889 if (strncasecmp(of, "sip:", 4))
07890 ast_log(LOG_NOTICE, "From address missing 'sip:', using it anyway\n");
07891 else
07892 of += 4;
07893
07894 if ((c = strchr(dest, '@')))
07895 c = NULL;
07896 else if ((c = strchr(of, '@')))
07897 *c++ = '\0';
07898 if (c)
07899 snprintf(referto, sizeof(referto), "<sip:%s@%s>", dest, c);
07900 else
07901 snprintf(referto, sizeof(referto), "<sip:%s>", dest);
07902
07903
07904 sip_refer_allocate(p);
07905 ast_copy_string(p->refer->refer_to, referto, sizeof(p->refer->refer_to));
07906 ast_copy_string(p->refer->referred_by, p->our_contact, sizeof(p->refer->referred_by));
07907 p->refer->status = REFER_SENT;
07908
07909 reqprep(&req, p, SIP_REFER, 0, 1);
07910
07911 add_header(&req, "Refer-To", referto);
07912 add_header(&req, "Allow", ALLOWED_METHODS);
07913 add_header(&req, "Supported", SUPPORTED_EXTENSIONS);
07914 if (!ast_strlen_zero(p->our_contact))
07915 add_header(&req, "Referred-By", p->our_contact);
07916
07917 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
07918
07919
07920
07921
07922
07923
07924
07925
07926 }
07927
07928
07929
07930 static int transmit_info_with_digit(struct sip_pvt *p, const char digit, unsigned int duration)
07931 {
07932 struct sip_request req;
07933
07934 reqprep(&req, p, SIP_INFO, 0, 1);
07935 add_digit(&req, digit, duration);
07936 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
07937 }
07938
07939
07940 static int transmit_info_with_vidupdate(struct sip_pvt *p)
07941 {
07942 struct sip_request req;
07943
07944 reqprep(&req, p, SIP_INFO, 0, 1);
07945 add_vidupdate(&req);
07946 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
07947 }
07948
07949
07950
07951
07952 static int transmit_request(struct sip_pvt *p, int sipmethod, int seqno, enum xmittype reliable, int newbranch)
07953 {
07954 struct sip_request resp;
07955
07956 if (sipmethod == SIP_ACK)
07957 p->invitestate = INV_CONFIRMED;
07958
07959 reqprep(&resp, p, sipmethod, seqno, newbranch);
07960 add_header_contentLength(&resp, 0);
07961 return send_request(p, &resp, reliable, seqno ? seqno : p->ocseq);
07962 }
07963
07964
07965 static int transmit_request_with_auth(struct sip_pvt *p, int sipmethod, int seqno, enum xmittype reliable, int newbranch)
07966 {
07967 struct sip_request resp;
07968
07969 reqprep(&resp, p, sipmethod, seqno, newbranch);
07970 if (!ast_strlen_zero(p->realm)) {
07971 char digest[1024];
07972
07973 memset(digest, 0, sizeof(digest));
07974 if(!build_reply_digest(p, sipmethod, digest, sizeof(digest))) {
07975 if (p->options && p->options->auth_type == PROXY_AUTH)
07976 add_header(&resp, "Proxy-Authorization", digest);
07977 else if (p->options && p->options->auth_type == WWW_AUTH)
07978 add_header(&resp, "Authorization", digest);
07979 else
07980 add_header(&resp, "Proxy-Authorization", digest);
07981 } else
07982 ast_log(LOG_WARNING, "No authentication available for call %s\n", p->callid);
07983 }
07984
07985
07986 if (sipmethod == SIP_BYE && p->owner && p->owner->hangupcause) {
07987 char buf[10];
07988
07989 add_header(&resp, "X-Asterisk-HangupCause", ast_cause2str(p->owner->hangupcause));
07990 snprintf(buf, sizeof(buf), "%d", p->owner->hangupcause);
07991 add_header(&resp, "X-Asterisk-HangupCauseCode", buf);
07992 }
07993
07994 add_header_contentLength(&resp, 0);
07995 return send_request(p, &resp, reliable, seqno ? seqno : p->ocseq);
07996 }
07997
07998
07999 static void destroy_association(struct sip_peer *peer)
08000 {
08001 if (!ast_test_flag(&global_flags[1], SIP_PAGE2_IGNOREREGEXPIRE)) {
08002 if (ast_test_flag(&peer->flags[1], SIP_PAGE2_RT_FROMCONTACT))
08003 ast_update_realtime("sippeers", "name", peer->name, "fullcontact", "", "ipaddr", "", "port", "", "regseconds", "0", "username", "", "regserver", "", NULL);
08004 else
08005 ast_db_del("SIP/Registry", peer->name);
08006 }
08007 }
08008
08009
08010 static int expire_register(const void *data)
08011 {
08012 struct sip_peer *peer = (struct sip_peer *)data;
08013
08014 if (!peer)
08015 return 0;
08016
08017 memset(&peer->addr, 0, sizeof(peer->addr));
08018 if (peer->sockfd > 0) {
08019 close(peer->sockfd);
08020 ast_clear_flag(&peer->flags[1], SIP_PAGE2_TCP_CONNECTED);
08021 }
08022
08023 destroy_association(peer);
08024
08025 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "Peer: SIP/%s\r\nPeerStatus: Unregistered\r\nCause: Expired\r\n", peer->name);
08026 register_peer_exten(peer, FALSE);
08027 peer->expire = -1;
08028 ast_device_state_changed("SIP/%s", peer->name);
08029
08030
08031
08032
08033 if (ast_test_flag(&peer->flags[1], SIP_PAGE2_SELFDESTRUCT) ||
08034 ast_test_flag(&peer->flags[1], SIP_PAGE2_RTAUTOCLEAR)) {
08035 struct sip_peer *peer_ptr = peer_ptr;
08036 peer_ptr = ASTOBJ_CONTAINER_UNLINK(&peerl, peer);
08037 if (peer_ptr) {
08038 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
08039 }
08040 }
08041
08042 ASTOBJ_UNREF(peer, sip_destroy_peer);
08043
08044 return 0;
08045 }
08046
08047
08048 static int sip_poke_peer_s(const void *data)
08049 {
08050 struct sip_peer *peer = (struct sip_peer *) data;
08051
08052 peer->pokeexpire = -1;
08053
08054 sip_poke_peer(peer);
08055
08056 ASTOBJ_UNREF(peer, sip_destroy_peer);
08057
08058 return 0;
08059 }
08060
08061
08062 static void reg_source_db(struct sip_peer *peer)
08063 {
08064 char data[256];
08065 struct in_addr in;
08066 int expiry;
08067 int port;
08068 char *scan, *addr, *port_str, *expiry_str, *username, *contact;
08069
08070 if (ast_test_flag(&peer->flags[1], SIP_PAGE2_RT_FROMCONTACT))
08071 return;
08072 if (ast_db_get("SIP/Registry", peer->name, data, sizeof(data)))
08073 return;
08074
08075 scan = data;
08076 addr = strsep(&scan, ":");
08077 port_str = strsep(&scan, ":");
08078 expiry_str = strsep(&scan, ":");
08079 username = strsep(&scan, ":");
08080 contact = scan;
08081
08082 if (!inet_aton(addr, &in))
08083 return;
08084
08085 if (port_str)
08086 port = atoi(port_str);
08087 else
08088 return;
08089
08090 if (expiry_str)
08091 expiry = atoi(expiry_str);
08092 else
08093 return;
08094
08095 if (username)
08096 ast_copy_string(peer->username, username, sizeof(peer->username));
08097 if (contact)
08098 ast_copy_string(peer->fullcontact, contact, sizeof(peer->fullcontact));
08099
08100 if (option_debug > 1)
08101 ast_log(LOG_DEBUG, "SIP Seeding peer from astdb: '%s' at %s@%s:%d for %d\n",
08102 peer->name, peer->username, ast_inet_ntoa(in), port, expiry);
08103
08104 memset(&peer->addr, 0, sizeof(peer->addr));
08105 peer->addr.sin_family = AF_INET;
08106 peer->addr.sin_addr = in;
08107 peer->addr.sin_port = htons(port);
08108 if ((sipsock < 0) || (siptcpsock < 0)){
08109
08110 if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
08111 struct sip_peer *peer_ptr = peer;
08112 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
08113 }
08114 peer->pokeexpire = ast_sched_add(sched, ast_random() % 5000 + 1, sip_poke_peer_s, ASTOBJ_REF(peer));
08115 if (peer->pokeexpire == -1) {
08116 struct sip_peer *peer_ptr = peer;
08117 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
08118 }
08119 } else
08120 sip_poke_peer(peer);
08121 if (!AST_SCHED_DEL(sched, peer->expire)) {
08122 struct sip_peer *peer_ptr = peer;
08123 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
08124 }
08125 peer->expire = ast_sched_add(sched, (expiry + 10) * 1000, expire_register, ASTOBJ_REF(peer));
08126 if (peer->expire == -1) {
08127 struct sip_peer *peer_ptr = peer;
08128 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
08129 }
08130 register_peer_exten(peer, TRUE);
08131 }
08132
08133
08134 static int parse_ok_contact(struct sip_pvt *pvt, struct sip_request *req)
08135 {
08136 char contact[SIPBUFSIZE];
08137 char *c;
08138
08139
08140 ast_copy_string(contact, get_header(req, "Contact"), sizeof(contact));
08141 c = get_in_brackets(contact);
08142
08143
08144 ast_string_field_set(pvt, fullcontact, c);
08145
08146
08147 ast_string_field_set(pvt, okcontacturi, c);
08148
08149
08150
08151 return TRUE;
08152 }
08153
08154 static int __set_address_from_contact(const char *fullcontact, struct sockaddr_in *sin)
08155 {
08156 struct hostent *hp;
08157 struct ast_hostent ahp;
08158 int port;
08159 char *c, *host, *pt;
08160 char contact_buf[256];
08161 char *contact;
08162
08163
08164 ast_copy_string(contact_buf, fullcontact, sizeof(contact_buf));
08165 contact = contact_buf;
08166
08167
08168 if (strncasecmp(contact, "sip:", 4)) {
08169 ast_log(LOG_NOTICE, "'%s' is not a valid SIP contact (missing sip:) trying to use anyway\n", contact);
08170 } else
08171 contact += 4;
08172
08173
08174
08175
08176
08177 host = strchr(contact, '@');
08178 if (!host) {
08179 host = contact;
08180 c = NULL;
08181 } else {
08182 *host++ = '\0';
08183 }
08184 pt = strchr(host, ':');
08185 if (pt) {
08186 *pt++ = '\0';
08187 port = atoi(pt);
08188 } else
08189 port = STANDARD_SIP_PORT;
08190
08191 contact = strsep(&contact, ";");
08192 host = strsep(&host, ";");
08193
08194
08195
08196 hp = ast_gethostbyname(host, &ahp);
08197 if (!hp) {
08198 ast_log(LOG_WARNING, "Invalid host name in Contact: (can't resolve in DNS) : '%s'\n", host);
08199 return -1;
08200 }
08201 sin->sin_family = AF_INET;
08202 memcpy(&sin->sin_addr, hp->h_addr, sizeof(sin->sin_addr));
08203 sin->sin_port = htons(port);
08204
08205 return 0;
08206 }
08207
08208
08209 static int set_address_from_contact(struct sip_pvt *pvt)
08210 {
08211 if (ast_test_flag(&pvt->flags[0], SIP_NAT_ROUTE)) {
08212
08213
08214 pvt->sa = pvt->recv;
08215 return 0;
08216 }
08217
08218 return __set_address_from_contact(pvt->fullcontact, &pvt->sa);
08219 }
08220
08221
08222
08223 static enum parse_register_result parse_register_contact(struct sip_pvt *pvt, struct sip_peer *peer, struct sip_request *req)
08224 {
08225 char contact[SIPBUFSIZE];
08226 char data[SIPBUFSIZE];
08227 const char *expires = get_header(req, "Expires");
08228 int expiry = atoi(expires);
08229 char *curi, *n, *pt;
08230 int port;
08231 const char *useragent;
08232 struct hostent *hp;
08233 struct ast_hostent ahp;
08234 struct sockaddr_in oldsin;
08235
08236 ast_copy_string(contact, get_header(req, "Contact"), sizeof(contact));
08237
08238 if (ast_strlen_zero(expires)) {
08239 expires = strcasestr(contact, ";expires=");
08240 if (expires) {
08241
08242 expires = strsep((char **) &expires, ";");
08243 if (sscanf(expires + 9, "%d", &expiry) != 1)
08244 expiry = default_expiry;
08245 } else {
08246
08247 expiry = default_expiry;
08248 }
08249 }
08250
08251
08252 curi = contact;
08253 if (strchr(contact, '<') == NULL)
08254 strsep(&curi, ";");
08255 curi = get_in_brackets(contact);
08256
08257
08258
08259
08260
08261 if (ast_strlen_zero(curi) && ast_strlen_zero(expires)) {
08262
08263 if (peer->expire > -1 && !ast_strlen_zero(peer->fullcontact))
08264 pvt->expiry = ast_sched_when(sched, peer->expire);
08265 return PARSE_REGISTER_QUERY;
08266 } else if (!strcasecmp(curi, "*") || !expiry) {
08267
08268 memset(&peer->addr, 0, sizeof(peer->addr));
08269 if (!AST_SCHED_DEL(sched, peer->expire)) {
08270 struct sip_peer *peer_ptr = peer;
08271 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
08272 }
08273
08274 destroy_association(peer);
08275
08276 register_peer_exten(peer, 0);
08277 peer->fullcontact[0] = '\0';
08278 peer->useragent[0] = '\0';
08279 peer->sipoptions = 0;
08280 peer->lastms = 0;
08281
08282 if (option_verbose > 2)
08283 ast_verbose(VERBOSE_PREFIX_3 "Unregistered SIP '%s'\n", peer->name);
08284 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "Peer: SIP/%s\r\nPeerStatus: Unregistered\r\n", peer->name);
08285 return PARSE_REGISTER_UPDATE;
08286 }
08287
08288
08289 ast_copy_string(peer->fullcontact, curi, sizeof(peer->fullcontact));
08290
08291
08292 ast_string_field_build(pvt, our_contact, "<%s>", curi);
08293
08294
08295 if (strncasecmp(curi, "sip:", 4)) {
08296 ast_log(LOG_NOTICE, "'%s' is not a valid SIP contact (missing sip:) trying to use anyway\n", curi);
08297 } else
08298 curi += 4;
08299
08300 curi = strsep(&curi, ";");
08301
08302 n = strchr(curi, '@');
08303 if (!n) {
08304 n = curi;
08305 curi = NULL;
08306 } else
08307 *n++ = '\0';
08308 pt = strchr(n, ':');
08309 if (pt) {
08310 *pt++ = '\0';
08311 port = atoi(pt);
08312 } else
08313 port = STANDARD_SIP_PORT;
08314 oldsin = peer->addr;
08315 if (!ast_test_flag(&peer->flags[0], SIP_NAT_ROUTE)) {
08316
08317 hp = ast_gethostbyname(n, &ahp);
08318 if (!hp) {
08319 ast_log(LOG_WARNING, "Invalid host '%s'\n", n);
08320 return PARSE_REGISTER_FAILED;
08321 }
08322 peer->addr.sin_family = AF_INET;
08323 memcpy(&peer->addr.sin_addr, hp->h_addr, sizeof(peer->addr.sin_addr));
08324 peer->addr.sin_port = htons(port);
08325 } else {
08326
08327
08328 peer->addr = pvt->recv;
08329 }
08330
08331
08332 peer->sipoptions = pvt->sipoptions;
08333
08334 if (curi && ast_strlen_zero(peer->username))
08335 ast_copy_string(peer->username, curi, sizeof(peer->username));
08336
08337 if (!AST_SCHED_DEL(sched, peer->expire)) {
08338 struct sip_peer *peer_ptr = peer;
08339 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
08340 }
08341 if (expiry > max_expiry)
08342 expiry = max_expiry;
08343 if (expiry < min_expiry)
08344 expiry = min_expiry;
08345 if (ast_test_flag(&peer->flags[0], SIP_REALTIME) && !ast_test_flag(&peer->flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
08346 peer->expire = -1;
08347 } else {
08348 peer->expire = ast_sched_add(sched, (expiry + 10) * 1000, expire_register, ASTOBJ_REF(peer));
08349 if (peer->expire == -1) {
08350 struct sip_peer *peer_ptr = peer;
08351 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
08352 }
08353 }
08354 pvt->expiry = expiry;
08355 snprintf(data, sizeof(data), "%s:%d:%d:%s:%s", ast_inet_ntoa(peer->addr.sin_addr), ntohs(peer->addr.sin_port), expiry, peer->username, peer->fullcontact);
08356 if (!ast_test_flag(&peer->flags[1], SIP_PAGE2_RT_FROMCONTACT))
08357 ast_db_put("SIP/Registry", peer->name, data);
08358 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "Peer: SIP/%s\r\nPeerStatus: Registered\r\n", peer->name);
08359
08360
08361 if (inaddrcmp(&peer->addr, &oldsin)) {
08362 sip_poke_peer(peer);
08363 if (option_verbose > 2)
08364 ast_verbose(VERBOSE_PREFIX_3 "Registered SIP '%s' at %s port %d expires %d\n", peer->name, ast_inet_ntoa(peer->addr.sin_addr), ntohs(peer->addr.sin_port), expiry);
08365 register_peer_exten(peer, 1);
08366 }
08367
08368
08369 useragent = get_header(req, "User-Agent");
08370 if (strcasecmp(useragent, peer->useragent)) {
08371 ast_copy_string(peer->useragent, useragent, sizeof(peer->useragent));
08372 if (option_verbose > 3)
08373 ast_verbose(VERBOSE_PREFIX_3 "Saved useragent \"%s\" for peer %s\n", peer->useragent, peer->name);
08374 }
08375
08376
08377 if (((!ast_test_flag(&peer->flags[1], SIP_PAGE2_TCP)) || (peer->sockfd != pvt->sockfd)) && (ast_test_flag(&pvt->flags[1], SIP_PAGE2_TCP))) {
08378 ast_set_flag(&peer->flags[1], SIP_PAGE2_TCP);
08379 peer->sockfd=pvt->sockfd;
08380 ast_set_flag(&peer->flags[1], SIP_PAGE2_TCP_CONNECTED);
08381 }
08382 return PARSE_REGISTER_UPDATE;
08383 }
08384
08385
08386 static void free_old_route(struct sip_route *route)
08387 {
08388 struct sip_route *next;
08389
08390 while (route) {
08391 next = route->next;
08392 free(route);
08393 route = next;
08394 }
08395 }
08396
08397
08398 static void list_route(struct sip_route *route)
08399 {
08400 if (!route)
08401 ast_verbose("list_route: no route\n");
08402 else {
08403 for (;route; route = route->next)
08404 ast_verbose("list_route: hop: <%s>\n", route->hop);
08405 }
08406 }
08407
08408
08409 static void build_route(struct sip_pvt *p, struct sip_request *req, int backwards)
08410 {
08411 struct sip_route *thishop, *head, *tail;
08412 int start = 0;
08413 int len;
08414 const char *rr, *contact, *c;
08415
08416
08417 if (p->route && p->route_persistant) {
08418 if (option_debug)
08419 ast_log(LOG_DEBUG, "build_route: Retaining previous route: <%s>\n", p->route->hop);
08420 return;
08421 }
08422
08423 if (p->route) {
08424 free_old_route(p->route);
08425 p->route = NULL;
08426 }
08427
08428
08429 p->route_persistant = 1;
08430
08431
08432
08433
08434
08435
08436 head = NULL;
08437 tail = head;
08438
08439 for (;;) {
08440
08441 rr = __get_header(req, "Record-Route", &start);
08442 if (*rr == '\0')
08443 break;
08444 for (; (rr = strchr(rr, '<')) ; rr += len) {
08445 ++rr;
08446 len = strcspn(rr, ">") + 1;
08447
08448 if ((thishop = ast_malloc(sizeof(*thishop) + len))) {
08449
08450 ast_copy_string(thishop->hop, rr, len);
08451 if (option_debug > 1)
08452 ast_log(LOG_DEBUG, "build_route: Record-Route hop: <%s>\n", thishop->hop);
08453
08454 if (backwards) {
08455
08456 thishop->next = head;
08457 head = thishop;
08458
08459 if (!tail)
08460 tail = thishop;
08461 } else {
08462 thishop->next = NULL;
08463
08464 if (tail)
08465 tail->next = thishop;
08466 else
08467 head = thishop;
08468 tail = thishop;
08469 }
08470 }
08471 }
08472 }
08473
08474
08475 if (!head || (!ast_strlen_zero(head->hop) && strstr(head->hop,";lr") == NULL) ) {
08476
08477
08478 contact = get_header(req, "Contact");
08479 if (!ast_strlen_zero(contact)) {
08480 if (option_debug > 1)
08481 ast_log(LOG_DEBUG, "build_route: Contact hop: %s\n", contact);
08482
08483 c = strchr(contact, '<');
08484 if (c) {
08485
08486 ++c;
08487 len = strcspn(c, ">") + 1;
08488 } else {
08489
08490 c = contact;
08491 len = strlen(contact) + 1;
08492 }
08493 if ((thishop = ast_malloc(sizeof(*thishop) + len))) {
08494
08495 ast_copy_string(thishop->hop, c, len);
08496 thishop->next = NULL;
08497
08498 if (tail)
08499 tail->next = thishop;
08500 else
08501 head = thishop;
08502 }
08503 }
08504 }
08505
08506
08507 p->route = head;
08508
08509
08510 if (sip_debug_test_pvt(p))
08511 list_route(p->route);
08512 }
08513
08514 AST_THREADSTORAGE(check_auth_buf, check_auth_buf_init);
08515 #define CHECK_AUTH_BUF_INITLEN 256
08516
08517
08518
08519
08520
08521
08522 static enum check_auth_result check_auth(struct sip_pvt *p, struct sip_request *req, const char *username,
08523 const char *secret, const char *md5secret, int sipmethod,
08524 char *uri, enum xmittype reliable, int ignore)
08525 {
08526 const char *response = "407 Proxy Authentication Required";
08527 const char *reqheader = "Proxy-Authorization";
08528 const char *respheader = "Proxy-Authenticate";
08529 const char *authtoken;
08530 char a1_hash[256];
08531 char resp_hash[256]="";
08532 char *c;
08533 int wrongnonce = FALSE;
08534 int good_response;
08535 const char *usednonce = p->randdata;
08536 struct ast_dynamic_str *buf;
08537 int res;
08538
08539
08540 enum keys { K_RESP, K_URI, K_USER, K_NONCE, K_LAST };
08541 struct x {
08542 const char *key;
08543 const char *s;
08544 } *i, keys[] = {
08545 [K_RESP] = { "response=", "" },
08546 [K_URI] = { "uri=", "" },
08547 [K_USER] = { "username=", "" },
08548 [K_NONCE] = { "nonce=", "" },
08549 [K_LAST] = { NULL, NULL}
08550 };
08551
08552
08553 if (ast_strlen_zero(secret) && ast_strlen_zero(md5secret))
08554 return AUTH_SUCCESSFUL;
08555 if (sipmethod == SIP_REGISTER || sipmethod == SIP_SUBSCRIBE) {
08556
08557
08558
08559 response = "401 Unauthorized";
08560 reqheader = "Authorization";
08561 respheader = "WWW-Authenticate";
08562 }
08563 authtoken = get_header(req, reqheader);
08564 if (ignore && !ast_strlen_zero(p->randdata) && ast_strlen_zero(authtoken)) {
08565
08566
08567 if (!reliable) {
08568
08569
08570 transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, 0);
08571
08572 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
08573 }
08574 return AUTH_CHALLENGE_SENT;
08575 } else if (ast_strlen_zero(p->randdata) || ast_strlen_zero(authtoken)) {
08576
08577 ast_string_field_build(p, randdata, "%08lx", ast_random());
08578 transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, 0);
08579
08580 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
08581 return AUTH_CHALLENGE_SENT;
08582 }
08583
08584
08585
08586
08587
08588
08589 if (!(buf = ast_dynamic_str_thread_get(&check_auth_buf, CHECK_AUTH_BUF_INITLEN)))
08590 return AUTH_SECRET_FAILED;
08591
08592
08593 res = ast_dynamic_str_thread_set(&buf, 0, &check_auth_buf, "%s", authtoken);
08594
08595 if (res == AST_DYNSTR_BUILD_FAILED)
08596 return AUTH_SECRET_FAILED;
08597
08598 c = buf->str;
08599
08600 while(c && *(c = ast_skip_blanks(c)) ) {
08601 for (i = keys; i->key != NULL; i++) {
08602 const char *separator = ",";
08603
08604 if (strncasecmp(c, i->key, strlen(i->key)) != 0)
08605 continue;
08606
08607 c += strlen(i->key);
08608 if (*c == '"') {
08609 c++;
08610 separator = "\"";
08611 }
08612 i->s = c;
08613 strsep(&c, separator);
08614 break;
08615 }
08616 if (i->key == NULL)
08617 strsep(&c, " ,");
08618 }
08619
08620
08621 if (strcmp(username, keys[K_USER].s)) {
08622 ast_log(LOG_WARNING, "username mismatch, have <%s>, digest has <%s>\n",
08623 username, keys[K_USER].s);
08624
08625 return AUTH_USERNAME_MISMATCH;
08626 }
08627
08628
08629 if (strcasecmp(p->randdata, keys[K_NONCE].s)) {
08630 wrongnonce = TRUE;
08631 usednonce = keys[K_NONCE].s;
08632 }
08633
08634 if (!ast_strlen_zero(md5secret))
08635 ast_copy_string(a1_hash, md5secret, sizeof(a1_hash));
08636 else {
08637 char a1[256];
08638 snprintf(a1, sizeof(a1), "%s:%s:%s", username, global_realm, secret);
08639 ast_md5_hash(a1_hash, a1);
08640 }
08641
08642
08643 {
08644 char a2[256];
08645 char a2_hash[256];
08646 char resp[256];
08647
08648 snprintf(a2, sizeof(a2), "%s:%s", sip_methods[sipmethod].text,
08649 S_OR(keys[K_URI].s, uri));
08650 ast_md5_hash(a2_hash, a2);
08651 snprintf(resp, sizeof(resp), "%s:%s:%s", a1_hash, usednonce, a2_hash);
08652 ast_md5_hash(resp_hash, resp);
08653 }
08654
08655 good_response = keys[K_RESP].s &&
08656 !strncasecmp(keys[K_RESP].s, resp_hash, strlen(resp_hash));
08657 if (wrongnonce) {
08658 if (good_response) {
08659 if (sipdebug)
08660 ast_log(LOG_NOTICE, "Correct auth, but based on stale nonce received from '%s'\n", get_header(req, "To"));
08661
08662 ast_string_field_build(p, randdata, "%08lx", ast_random());
08663 transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, TRUE);
08664 } else {
08665
08666 if (!ast_test_flag(req, SIP_PKT_IGNORE)) {
08667 if (sipdebug)
08668 ast_log(LOG_NOTICE, "Bad authentication received from '%s'\n", get_header(req, "To"));
08669 ast_string_field_build(p, randdata, "%08lx", ast_random());
08670 } else {
08671 if (sipdebug)
08672 ast_log(LOG_NOTICE, "Duplicate authentication received from '%s'\n", get_header(req, "To"));
08673 }
08674 transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, FALSE);
08675 }
08676
08677
08678 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
08679 return AUTH_CHALLENGE_SENT;
08680 }
08681 if (good_response) {
08682 append_history(p, "AuthOK", "Auth challenge succesful for %s", username);
08683 return AUTH_SUCCESSFUL;
08684 }
08685
08686
08687
08688
08689
08690
08691 return AUTH_SECRET_FAILED;
08692 }
08693
08694
08695 static void sip_peer_hold(struct sip_pvt *p, int hold)
08696 {
08697 struct sip_peer *peer = find_peer(p->peername, NULL, 1, 0);
08698
08699 if (!peer)
08700 return;
08701
08702
08703 if (hold)
08704 peer->onHold++;
08705 else
08706 peer->onHold--;
08707
08708
08709 ast_device_state_changed("SIP/%s", peer->name);
08710
08711 return;
08712 }
08713
08714
08715
08716
08717 static int cb_extensionstate(char *context, char* exten, int state, void *data)
08718 {
08719 struct sip_pvt *p = data;
08720
08721 ast_mutex_lock(&p->lock);
08722
08723 switch(state) {
08724 case AST_EXTENSION_DEACTIVATED:
08725 case AST_EXTENSION_REMOVED:
08726 if (p->autokillid > -1 && sip_cancel_destroy(p))
08727 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
08728 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
08729 ast_verbose(VERBOSE_PREFIX_2 "Extension state: Watcher for hint %s %s. Notify User %s\n", exten, state == AST_EXTENSION_DEACTIVATED ? "deactivated" : "removed", p->username);
08730 p->stateid = -1;
08731 p->subscribed = NONE;
08732 append_history(p, "Subscribestatus", "%s", state == AST_EXTENSION_REMOVED ? "HintRemoved" : "Deactivated");
08733 break;
08734 default:
08735 p->laststate = state;
08736 break;
08737 }
08738 if (p->subscribed != NONE) {
08739 if (!p->pendinginvite) {
08740 transmit_state_notify(p, state, 1, FALSE);
08741 } else {
08742
08743
08744 ast_set_flag(&p->flags[1], SIP_PAGE2_STATECHANGEQUEUE);
08745 }
08746 }
08747 if (option_verbose > 1)
08748 ast_verbose(VERBOSE_PREFIX_1 "Extension Changed %s[%s] new state %s for Notify User %s %s\n", exten, context, ast_extension_state2str(state), p->username,
08749 ast_test_flag(&p->flags[1], SIP_PAGE2_STATECHANGEQUEUE) ? "(queued)" : "");
08750
08751
08752 ast_mutex_unlock(&p->lock);
08753
08754 return 0;
08755 }
08756
08757
08758
08759
08760 static void transmit_fake_auth_response(struct sip_pvt *p, struct sip_request *req, int reliable)
08761 {
08762 ast_string_field_build(p, randdata, "%08lx", ast_random());
08763 transmit_response_with_auth(p, "401 Unauthorized", req, p->randdata, reliable, "WWW-Authenticate", 0);
08764 }
08765
08766
08767
08768
08769
08770
08771 static enum check_auth_result register_verify(struct sip_pvt *p, struct sockaddr_in *sin,
08772 struct sip_request *req, char *uri)
08773 {
08774 enum check_auth_result res = AUTH_NOT_FOUND;
08775 struct sip_peer *peer;
08776 char tmp[256];
08777 char *name, *c;
08778 char *t;
08779 char *domain;
08780
08781
08782 t = uri;
08783 while(*t && (*t > 32) && (*t != ';'))
08784 t++;
08785 *t = '\0';
08786
08787 ast_copy_string(tmp, get_header(req, "To"), sizeof(tmp));
08788 if (pedanticsipchecking)
08789 ast_uri_decode(tmp);
08790
08791 c = get_in_brackets(tmp);
08792 c = strsep(&c, ";");
08793
08794 if (!strncasecmp(c, "sip:", 4)) {
08795 name = c + 4;
08796 } else {
08797 name = c;
08798 ast_log(LOG_NOTICE, "Invalid to address: '%s' from %s (missing sip:) trying to use anyway...\n", c, ast_inet_ntoa(sin->sin_addr));
08799 }
08800
08801
08802 if ((c = strchr(name, '@'))) {
08803 *c++ = '\0';
08804 domain = c;
08805 if ((c = strchr(domain, ':')))
08806 *c = '\0';
08807 if (!AST_LIST_EMPTY(&domain_list)) {
08808 if (!check_sip_domain(domain, NULL, 0)) {
08809 transmit_response(p, "404 Not found (unknown domain)", &p->initreq);
08810 return AUTH_UNKNOWN_DOMAIN;
08811 }
08812 }
08813 }
08814
08815 ast_string_field_set(p, exten, name);
08816 build_contact(p);
08817 peer = find_peer(name, NULL, 1, 0);
08818 if (!(peer && ast_apply_ha(peer->ha, sin))) {
08819
08820 if (peer) {
08821 ASTOBJ_UNREF(peer, sip_destroy_peer);
08822 res = AUTH_ACL_FAILED;
08823 } else
08824 res = AUTH_NOT_FOUND;
08825 }
08826 if (peer) {
08827
08828 if (p->rtp) {
08829 ast_rtp_codec_setpref(p->rtp, &peer->prefs);
08830 p->autoframing = peer->autoframing;
08831 }
08832 if (!ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC)) {
08833 ast_log(LOG_ERROR, "Peer '%s' is trying to register, but not configured as host=dynamic\n", peer->name);
08834 res = AUTH_PEER_NOT_DYNAMIC;
08835 } else {
08836 ast_copy_flags(&p->flags[0], &peer->flags[0], SIP_NAT);
08837 transmit_response(p, "100 Trying", req);
08838 if (!(res = check_auth(p, req, peer->name, peer->secret, peer->md5secret, SIP_REGISTER, uri, XMIT_UNRELIABLE, ast_test_flag(req, SIP_PKT_IGNORE)))) {
08839 if (sip_cancel_destroy(p))
08840 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
08841
08842
08843
08844 switch (parse_register_contact(p, peer, req)) {
08845 case PARSE_REGISTER_FAILED:
08846 ast_log(LOG_WARNING, "Failed to parse contact info\n");
08847 transmit_response_with_date(p, "400 Bad Request", req);
08848 peer->lastmsgssent = -1;
08849 res = 0;
08850 break;
08851 case PARSE_REGISTER_QUERY:
08852 transmit_response_with_date(p, "200 OK", req);
08853 peer->lastmsgssent = -1;
08854 res = 0;
08855 break;
08856 case PARSE_REGISTER_UPDATE:
08857 update_peer(peer, p->expiry);
08858
08859 transmit_response_with_date(p, "200 OK", req);
08860 if (!ast_test_flag((&peer->flags[1]), SIP_PAGE2_SUBSCRIBEMWIONLY))
08861 peer->lastmsgssent = -1;
08862 res = 0;
08863 break;
08864 }
08865 }
08866 }
08867 }
08868 if (!peer && autocreatepeer) {
08869
08870 peer = temp_peer(name);
08871 if (peer) {
08872 ASTOBJ_CONTAINER_LINK(&peerl, peer);
08873 if (sip_cancel_destroy(p))
08874 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
08875 switch (parse_register_contact(p, peer, req)) {
08876 case PARSE_REGISTER_FAILED:
08877 ast_log(LOG_WARNING, "Failed to parse contact info\n");
08878 transmit_response_with_date(p, "400 Bad Request", req);
08879 peer->lastmsgssent = -1;
08880 res = 0;
08881 break;
08882 case PARSE_REGISTER_QUERY:
08883 transmit_response_with_date(p, "200 OK", req);
08884 peer->lastmsgssent = -1;
08885 res = 0;
08886 break;
08887 case PARSE_REGISTER_UPDATE:
08888
08889 transmit_response_with_date(p, "200 OK", req);
08890 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "Peer: SIP/%s\r\nPeerStatus: Registered\r\n", peer->name);
08891 peer->lastmsgssent = -1;
08892 res = 0;
08893 break;
08894 }
08895 }
08896 }
08897 if (!res) {
08898 ast_device_state_changed("SIP/%s", peer->name);
08899 }
08900 if (res < 0) {
08901 switch (res) {
08902 case AUTH_SECRET_FAILED:
08903
08904 transmit_response(p, "403 Forbidden (Bad auth)", &p->initreq);
08905 break;
08906 case AUTH_USERNAME_MISMATCH:
08907
08908
08909
08910
08911 transmit_response(p, "403 Authentication user name does not match account name", &p->initreq);
08912 break;
08913 case AUTH_NOT_FOUND:
08914 case AUTH_PEER_NOT_DYNAMIC:
08915 case AUTH_ACL_FAILED:
08916 if (global_alwaysauthreject) {
08917 transmit_fake_auth_response(p, &p->initreq, 1);
08918 } else {
08919
08920 if (res == AUTH_PEER_NOT_DYNAMIC)
08921 transmit_response(p, "403 Forbidden", &p->initreq);
08922 else
08923 transmit_response(p, "404 Not found", &p->initreq);
08924 }
08925 break;
08926 default:
08927 break;
08928 }
08929 }
08930 if (peer)
08931 ASTOBJ_UNREF(peer, sip_destroy_peer);
08932
08933 return res;
08934 }
08935
08936
08937 static int get_rdnis(struct sip_pvt *p, struct sip_request *oreq)
08938 {
08939 char tmp[256], *c, *a;
08940 struct sip_request *req;
08941
08942 req = oreq;
08943 if (!req)
08944 req = &p->initreq;
08945 ast_copy_string(tmp, get_header(req, "Diversion"), sizeof(tmp));
08946 if (ast_strlen_zero(tmp))
08947 return 0;
08948 c = get_in_brackets(tmp);
08949 if (strncasecmp(c, "sip:", 4)) {
08950 ast_log(LOG_WARNING, "Huh? Not an RDNIS SIP header (%s)?\n", c);
08951 return -1;
08952 }
08953 c += 4;
08954 a = c;
08955 strsep(&a, "@;");
08956 if (sip_debug_test_pvt(p))
08957 ast_verbose("RDNIS is %s\n", c);
08958 ast_string_field_set(p, rdnis, c);
08959
08960 return 0;
08961 }
08962
08963
08964
08965
08966 static int get_destination(struct sip_pvt *p, struct sip_request *oreq)
08967 {
08968 char tmp[256] = "", *uri, *a;
08969 char tmpf[256] = "", *from;
08970 struct sip_request *req;
08971 char *colon;
08972 char *decoded_uri;
08973
08974 req = oreq;
08975 if (!req)
08976 req = &p->initreq;
08977
08978
08979 if (req->rlPart2)
08980 ast_copy_string(tmp, req->rlPart2, sizeof(tmp));
08981
08982 if (pedanticsipchecking)
08983 ast_uri_decode(tmp);
08984
08985 uri = get_in_brackets(tmp);
08986
08987 if (strncasecmp(uri, "sip:", 4)) {
08988 ast_log(LOG_WARNING, "Huh? Not a SIP header (%s)?\n", uri);
08989 return -1;
08990 }
08991 uri += 4;
08992
08993
08994 ast_copy_string(tmpf, get_header(req, "From"), sizeof(tmpf));
08995 if (!ast_strlen_zero(tmpf)) {
08996 if (pedanticsipchecking)
08997 ast_uri_decode(tmpf);
08998 from = get_in_brackets(tmpf);
08999 } else {
09000 from = NULL;
09001 }
09002
09003 if (!ast_strlen_zero(from)) {
09004 if (strncasecmp(from, "sip:", 4)) {
09005 ast_log(LOG_WARNING, "Huh? Not a SIP header (%s)?\n", from);
09006 return -1;
09007 }
09008 from += 4;
09009 if ((a = strchr(from, '@')))
09010 *a++ = '\0';
09011 else
09012 a = from;
09013 from = strsep(&from, ";");
09014 a = strsep(&a, ";");
09015 ast_string_field_set(p, fromdomain, a);
09016 }
09017
09018
09019
09020
09021 if ((a = strchr(uri, '@'))) {
09022 *a++ = '\0';
09023 } else {
09024 a = uri;
09025 uri = "s";
09026 }
09027 colon = strchr(a, ':');
09028 if (colon)
09029 *colon = '\0';
09030
09031 uri = strsep(&uri, ";");
09032 a = strsep(&a, ";");
09033
09034 ast_string_field_set(p, domain, a);
09035
09036 if (!AST_LIST_EMPTY(&domain_list)) {
09037 char domain_context[AST_MAX_EXTENSION];
09038
09039 domain_context[0] = '\0';
09040 if (!check_sip_domain(p->domain, domain_context, sizeof(domain_context))) {
09041 if (!allow_external_domains && (req->method == SIP_INVITE || req->method == SIP_REFER)) {
09042 if (option_debug)
09043 ast_log(LOG_DEBUG, "Got SIP %s to non-local domain '%s'; refusing request.\n", sip_methods[req->method].text, p->domain);
09044 return -2;
09045 }
09046 }
09047
09048 if (!ast_strlen_zero(domain_context))
09049 ast_string_field_set(p, context, domain_context);
09050 }
09051
09052
09053 if (req->method == SIP_SUBSCRIBE && !ast_strlen_zero(p->subscribecontext))
09054 ast_string_field_set(p, context, p->subscribecontext);
09055
09056 if (sip_debug_test_pvt(p))
09057 ast_verbose("Looking for %s in %s (domain %s)\n", uri, p->context, p->domain);
09058
09059
09060 if (req->method == SIP_SUBSCRIBE) {
09061 char hint[AST_MAX_EXTENSION];
09062 return (ast_get_hint(hint, sizeof(hint), NULL, 0, NULL, p->context, p->exten) ? 0 : -1);
09063 } else {
09064 decoded_uri = ast_strdupa(uri);
09065 ast_uri_decode(decoded_uri);
09066
09067
09068
09069
09070
09071 if (ast_exists_extension(NULL, p->context, uri, 1, S_OR(p->cid_num, from)) || ast_exists_extension(NULL, p->context, decoded_uri, 1, S_OR(p->cid_num, from)) ||
09072 !strcmp(decoded_uri, ast_pickup_ext())) {
09073 if (!oreq)
09074 ast_string_field_set(p, exten, decoded_uri);
09075 return 0;
09076 }
09077 }
09078
09079
09080 if((ast_test_flag(&global_flags[1], SIP_PAGE2_ALLOWOVERLAP) &&
09081 ast_canmatch_extension(NULL, p->context, decoded_uri, 1, S_OR(p->cid_num, from))) ||
09082 !strncmp(decoded_uri, ast_pickup_ext(), strlen(decoded_uri))) {
09083 return 1;
09084 }
09085
09086 return -1;
09087 }
09088
09089
09090
09091 static struct sip_pvt *get_sip_pvt_byid_locked(const char *callid, const char *totag, const char *fromtag)
09092 {
09093 struct sip_pvt *sip_pvt_ptr;
09094
09095 ast_mutex_lock(&iflock);
09096
09097 if (option_debug > 3 && totag)
09098 ast_log(LOG_DEBUG, "Looking for callid %s (fromtag %s totag %s)\n", callid, fromtag ? fromtag : "<no fromtag>", totag ? totag : "<no totag>");
09099
09100
09101 for (sip_pvt_ptr = iflist; sip_pvt_ptr; sip_pvt_ptr = sip_pvt_ptr->next) {
09102 if (!strcmp(sip_pvt_ptr->callid, callid)) {
09103 int match = 1;
09104
09105
09106 ast_mutex_lock(&sip_pvt_ptr->lock);
09107
09108
09109
09110
09111
09112 if (pedanticsipchecking) {
09113 const char *pvt_fromtag, *pvt_totag;
09114
09115 if (ast_test_flag(&sip_pvt_ptr->flags[1], SIP_PAGE2_OUTGOING_CALL)) {
09116
09117 pvt_fromtag = sip_pvt_ptr->tag ;
09118 pvt_totag = sip_pvt_ptr->theirtag ;
09119 } else {
09120
09121 pvt_fromtag = sip_pvt_ptr->theirtag ;
09122 pvt_totag = sip_pvt_ptr->tag ;
09123 }
09124 if (ast_strlen_zero(fromtag) || strcmp(fromtag, pvt_fromtag) || (!ast_strlen_zero(totag) && strcmp(totag, pvt_totag)))
09125 match = 0;
09126 }
09127
09128 if (!match) {
09129 ast_mutex_unlock(&sip_pvt_ptr->lock);
09130 continue;
09131 }
09132
09133 if (option_debug > 3 && totag)
09134 ast_log(LOG_DEBUG, "Matched %s call - their tag is %s Our tag is %s\n",
09135 ast_test_flag(&sip_pvt_ptr->flags[1], SIP_PAGE2_OUTGOING_CALL) ? "OUTGOING": "INCOMING",
09136 sip_pvt_ptr->theirtag, sip_pvt_ptr->tag);
09137
09138
09139 while (sip_pvt_ptr->owner && ast_channel_trylock(sip_pvt_ptr->owner)) {
09140 DEADLOCK_AVOIDANCE(&sip_pvt_ptr->lock);
09141 }
09142 break;
09143 }
09144 }
09145 ast_mutex_unlock(&iflock);
09146 if (option_debug > 3 && !sip_pvt_ptr)
09147 ast_log(LOG_DEBUG, "Found no match for callid %s to-tag %s from-tag %s\n", callid, totag, fromtag);
09148 return sip_pvt_ptr;
09149 }
09150
09151
09152
09153 static int get_refer_info(struct sip_pvt *transferer, struct sip_request *outgoing_req)
09154 {
09155
09156 const char *p_referred_by = NULL;
09157 char *h_refer_to = NULL;
09158 char *h_referred_by = NULL;
09159 char *refer_to;
09160 const char *p_refer_to;
09161 char *referred_by_uri = NULL;
09162 char *ptr;
09163 struct sip_request *req = NULL;
09164 const char *transfer_context = NULL;
09165 struct sip_refer *referdata;
09166
09167
09168 req = outgoing_req;
09169 referdata = transferer->refer;
09170
09171 if (!req)
09172 req = &transferer->initreq;
09173
09174 p_refer_to = get_header(req, "Refer-To");
09175 if (ast_strlen_zero(p_refer_to)) {
09176 ast_log(LOG_WARNING, "Refer-To Header missing. Skipping transfer.\n");
09177 return -2;
09178 }
09179 h_refer_to = ast_strdupa(p_refer_to);
09180 refer_to = get_in_brackets(h_refer_to);
09181 if (pedanticsipchecking)
09182 ast_uri_decode(refer_to);
09183
09184 if (strncasecmp(refer_to, "sip:", 4)) {
09185 ast_log(LOG_WARNING, "Can't transfer to non-sip: URI. (Refer-to: %s)?\n", refer_to);
09186 return -3;
09187 }
09188 refer_to += 4;
09189
09190
09191 p_referred_by = get_header(req, "Referred-By");
09192 if (!ast_strlen_zero(p_referred_by)) {
09193 char *lessthan;
09194 h_referred_by = ast_strdupa(p_referred_by);
09195 if (pedanticsipchecking)
09196 ast_uri_decode(h_referred_by);
09197
09198
09199 ast_copy_string(referdata->referred_by_name, h_referred_by, sizeof(referdata->referred_by_name));
09200 if ((lessthan = strchr(referdata->referred_by_name, '<'))) {
09201 *(lessthan - 1) = '\0';
09202 }
09203
09204 referred_by_uri = get_in_brackets(h_referred_by);
09205 if(strncasecmp(referred_by_uri, "sip:", 4)) {
09206 ast_log(LOG_WARNING, "Huh? Not a sip: header (Referred-by: %s). Skipping.\n", referred_by_uri);
09207 referred_by_uri = (char *) NULL;
09208 } else {
09209 referred_by_uri += 4;
09210 }
09211 }
09212
09213
09214 if ((ptr = strchr(refer_to, '?'))) {
09215 *ptr++ = '\0';
09216 if (!strncasecmp(ptr, "REPLACES=", 9)) {
09217 char *to = NULL, *from = NULL;
09218
09219
09220 referdata->attendedtransfer = 1;
09221 ast_copy_string(referdata->replaces_callid, ptr+9, sizeof(referdata->replaces_callid));
09222 ast_uri_decode(referdata->replaces_callid);
09223 if ((ptr = strchr(referdata->replaces_callid, ';'))) {
09224 *ptr++ = '\0';
09225 }
09226
09227 if (ptr) {
09228
09229 to = strcasestr(ptr, "to-tag=");
09230 from = strcasestr(ptr, "from-tag=");
09231 }
09232
09233
09234 if (to) {
09235 ptr = to + 7;
09236 if ((to = strchr(ptr, '&')))
09237 *to = '\0';
09238 if ((to = strchr(ptr, ';')))
09239 *to = '\0';
09240 ast_copy_string(referdata->replaces_callid_totag, ptr, sizeof(referdata->replaces_callid_totag));
09241 }
09242
09243 if (from) {
09244 ptr = from + 9;
09245 if ((to = strchr(ptr, '&')))
09246 *to = '\0';
09247 if ((to = strchr(ptr, ';')))
09248 *to = '\0';
09249 ast_copy_string(referdata->replaces_callid_fromtag, ptr, sizeof(referdata->replaces_callid_fromtag));
09250 }
09251
09252 if (option_debug > 1) {
09253 if (!pedanticsipchecking)
09254 ast_log(LOG_DEBUG,"Attended transfer: Will use Replace-Call-ID : %s (No check of from/to tags)\n", referdata->replaces_callid );
09255 else
09256 ast_log(LOG_DEBUG,"Attended transfer: Will use Replace-Call-ID : %s F-tag: %s T-tag: %s\n", referdata->replaces_callid, referdata->replaces_callid_fromtag ? referdata->replaces_callid_fromtag : "<none>", referdata->replaces_callid_totag ? referdata->replaces_callid_totag : "<none>" );
09257 }
09258 }
09259 }
09260
09261 if ((ptr = strchr(refer_to, '@'))) {
09262 char *urioption = NULL, *domain;
09263 *ptr++ = '\0';
09264
09265 if ((urioption = strchr(ptr, ';')))
09266 *urioption++ = '\0';
09267
09268 domain = ptr;
09269 if ((ptr = strchr(domain, ':')))
09270 *ptr = '\0';
09271
09272
09273 ast_copy_string(referdata->refer_to_domain, domain, sizeof(referdata->refer_to_domain));
09274 if (urioption)
09275 ast_copy_string(referdata->refer_to_urioption, urioption, sizeof(referdata->refer_to_urioption));
09276 }
09277
09278 if ((ptr = strchr(refer_to, ';')))
09279 *ptr = '\0';
09280 ast_copy_string(referdata->refer_to, refer_to, sizeof(referdata->refer_to));
09281
09282 if (referred_by_uri) {
09283 if ((ptr = strchr(referred_by_uri, ';')))
09284 *ptr = '\0';
09285 ast_copy_string(referdata->referred_by, referred_by_uri, sizeof(referdata->referred_by));
09286 } else {
09287 referdata->referred_by[0] = '\0';
09288 }
09289
09290
09291 if (transferer->owner)
09292 transfer_context = pbx_builtin_getvar_helper(transferer->owner, "TRANSFER_CONTEXT");
09293
09294
09295 if (ast_strlen_zero(transfer_context)) {
09296 transfer_context = S_OR(transferer->owner->macrocontext,
09297 S_OR(transferer->context, default_context));
09298 }
09299
09300 ast_copy_string(referdata->refer_to_context, transfer_context, sizeof(referdata->refer_to_context));
09301
09302
09303 if (ast_exists_extension(NULL, transfer_context, refer_to, 1, NULL) ) {
09304 if (sip_debug_test_pvt(transferer)) {
09305 ast_verbose("SIP transfer to extension %s@%s by %s\n", refer_to, transfer_context, referred_by_uri);
09306 }
09307
09308 return 0;
09309 }
09310 if (sip_debug_test_pvt(transferer))
09311 ast_verbose("Failed SIP Transfer to non-existing extension %s in context %s\n n", refer_to, transfer_context);
09312
09313
09314 return -1;
09315 }
09316
09317
09318
09319 static int get_also_info(struct sip_pvt *p, struct sip_request *oreq)
09320 {
09321 char tmp[256] = "", *c, *a;
09322 struct sip_request *req = oreq ? oreq : &p->initreq;
09323 struct sip_refer *referdata = NULL;
09324 const char *transfer_context = NULL;
09325
09326 if (!p->refer && !sip_refer_allocate(p))
09327 return -1;
09328
09329 referdata = p->refer;
09330
09331 ast_copy_string(tmp, get_header(req, "Also"), sizeof(tmp));
09332 c = get_in_brackets(tmp);
09333
09334 if (pedanticsipchecking)
09335 ast_uri_decode(c);
09336
09337 if (strncasecmp(c, "sip:", 4)) {
09338 ast_log(LOG_WARNING, "Huh? Not a SIP header in Also: transfer (%s)?\n", c);
09339 return -1;
09340 }
09341 c += 4;
09342 if ((a = strchr(c, ';')))
09343 *a = '\0';
09344
09345 if ((a = strchr(c, '@'))) {
09346 *a++ = '\0';
09347 ast_copy_string(referdata->refer_to_domain, a, sizeof(referdata->refer_to_domain));
09348 }
09349
09350 if (sip_debug_test_pvt(p))
09351 ast_verbose("Looking for %s in %s\n", c, p->context);
09352
09353 if (p->owner)
09354 transfer_context = pbx_builtin_getvar_helper(p->owner, "TRANSFER_CONTEXT");
09355
09356
09357 if (ast_strlen_zero(transfer_context)) {
09358 transfer_context = S_OR(p->owner->macrocontext,
09359 S_OR(p->context, default_context));
09360 }
09361 if (ast_exists_extension(NULL, transfer_context, c, 1, NULL)) {
09362
09363 if (option_debug)
09364 ast_log(LOG_DEBUG,"SIP Bye-also transfer to Extension %s@%s \n", c, transfer_context);
09365 ast_copy_string(referdata->refer_to, c, sizeof(referdata->refer_to));
09366 ast_copy_string(referdata->referred_by, "", sizeof(referdata->referred_by));
09367 ast_copy_string(referdata->refer_contact, "", sizeof(referdata->refer_contact));
09368 referdata->refer_call = NULL;
09369
09370 ast_string_field_set(p, context, transfer_context);
09371 return 0;
09372 } else if (ast_canmatch_extension(NULL, p->context, c, 1, NULL)) {
09373 return 1;
09374 }
09375
09376 return -1;
09377 }
09378
09379 static void check_via(struct sip_pvt *p, const struct sip_request *req)
09380 {
09381 char via[512];
09382 char *c, *pt;
09383 struct hostent *hp;
09384 struct ast_hostent ahp;
09385
09386 ast_copy_string(via, get_header(req, "Via"), sizeof(via));
09387
09388
09389 c = strchr(via, ',');
09390 if (c)
09391 *c = '\0';
09392
09393
09394 c = strstr(via, ";rport");
09395 if (c && (c[6] != '='))
09396 ast_set_flag(&p->flags[0], SIP_NAT_ROUTE);
09397
09398 c = strchr(via, ';');
09399 if (c)
09400 *c = '\0';
09401
09402 c = strchr(via, ' ');
09403 if (c) {
09404 *c = '\0';
09405 c = ast_skip_blanks(c+1);
09406 if ((strcasecmp(via, "SIP/2.0/UDP")) && (strcasecmp(via, "SIP/2.0/TCP"))) {
09407 ast_log(LOG_WARNING, "Don't know how to respond via '%s'\n", via);
09408 return;
09409 }
09410 pt = strchr(c, ':');
09411 if (pt)
09412 *pt++ = '\0';
09413 hp = ast_gethostbyname(c, &ahp);
09414 if (!hp) {
09415 ast_log(LOG_WARNING, "'%s' is not a valid host\n", c);
09416 return;
09417 }
09418 memset(&p->sa, 0, sizeof(p->sa));
09419 p->sa.sin_family = AF_INET;
09420 memcpy(&p->sa.sin_addr, hp->h_addr, sizeof(p->sa.sin_addr));
09421 p->sa.sin_port = htons(pt ? atoi(pt) : STANDARD_SIP_PORT);
09422
09423 if (sip_debug_test_pvt(p)) {
09424 const struct sockaddr_in *dst = sip_real_dst(p);
09425 ast_verbose("Sending to %s : %d (%s)\n", ast_inet_ntoa(dst->sin_addr), ntohs(dst->sin_port), sip_nat_mode(p));
09426 }
09427 }
09428 }
09429
09430
09431 static char *get_calleridname(const char *input, char *output, size_t outputsize)
09432 {
09433 const char *end = strchr(input,'<');
09434 const char *tmp = strchr(input,'"');
09435 int bytes = 0;
09436 int maxbytes = outputsize - 1;
09437
09438 if (!end || end == input)
09439 return NULL;
09440
09441 end--;
09442
09443 if (tmp && tmp <= end) {
09444
09445
09446
09447 end = strchr(tmp+1, '"');
09448 if (!end)
09449 return NULL;
09450 bytes = (int) (end - tmp);
09451
09452 if (bytes > maxbytes)
09453 bytes = maxbytes;
09454 ast_copy_string(output, tmp + 1, bytes);
09455 } else {
09456
09457
09458 input = ast_skip_blanks(input);
09459
09460 while(*end && *end < 33 && end > input)
09461 end--;
09462 if (end >= input) {
09463 bytes = (int) (end - input) + 2;
09464
09465 if (bytes > maxbytes)
09466 bytes = maxbytes;
09467 ast_copy_string(output, input, bytes);
09468 } else
09469 return NULL;
09470 }
09471 return output;
09472 }
09473
09474
09475
09476
09477
09478 static int get_rpid_num(const char *input, char *output, int maxlen)
09479 {
09480 char *start;
09481 char *end;
09482
09483 start = strchr(input,':');
09484 if (!start) {
09485 output[0] = '\0';
09486 return 0;
09487 }
09488 start++;
09489
09490
09491 ast_copy_string(output,start,maxlen);
09492 output[maxlen-1] = '\0';
09493
09494 end = strchr(output,'@');
09495 if (end)
09496 *end = '\0';
09497 else
09498 output[0] = '\0';
09499 if (strstr(input,"privacy=full") || strstr(input,"privacy=uri"))
09500 return AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
09501
09502 return 0;
09503 }
09504
09505
09506
09507
09508
09509
09510
09511 static enum check_auth_result check_user_full(struct sip_pvt *p, struct sip_request *req,
09512 int sipmethod, char *uri, enum xmittype reliable,
09513 struct sockaddr_in *sin, struct sip_peer **authpeer)
09514 {
09515 struct sip_user *user = NULL;
09516 struct sip_peer *peer;
09517 char from[256], *c;
09518 char *of;
09519 char rpid_num[50];
09520 const char *rpid;
09521 enum check_auth_result res = AUTH_SUCCESSFUL;
09522 char *t;
09523 char calleridname[50];
09524 int debug=sip_debug_test_addr(sin);
09525 struct ast_variable *tmpvar = NULL, *v = NULL;
09526 char *uri2 = ast_strdupa(uri);
09527
09528
09529 t = uri2;
09530 while (*t && *t > 32 && *t != ';')
09531 t++;
09532 *t = '\0';
09533 ast_copy_string(from, get_header(req, "From"), sizeof(from));
09534 if (pedanticsipchecking)
09535 ast_uri_decode(from);
09536
09537 memset(calleridname, 0, sizeof(calleridname));
09538 get_calleridname(from, calleridname, sizeof(calleridname));
09539 if (calleridname[0])
09540 ast_string_field_set(p, cid_name, calleridname);
09541
09542 rpid = get_header(req, "Remote-Party-ID");
09543 memset(rpid_num, 0, sizeof(rpid_num));
09544 if (!ast_strlen_zero(rpid))
09545 p->callingpres = get_rpid_num(rpid, rpid_num, sizeof(rpid_num));
09546
09547 of = get_in_brackets(from);
09548 if (ast_strlen_zero(p->exten)) {
09549 t = uri2;
09550 if (!strncasecmp(t, "sip:", 4))
09551 t+= 4;
09552 ast_string_field_set(p, exten, t);
09553 t = strchr(p->exten, '@');
09554 if (t)
09555 *t = '\0';
09556 if (ast_strlen_zero(p->our_contact))
09557 build_contact(p);
09558 }
09559
09560 ast_string_field_set(p, from, of);
09561 if (strncasecmp(of, "sip:", 4)) {
09562 ast_log(LOG_NOTICE, "From address missing 'sip:', using it anyway\n");
09563 } else
09564 of += 4;
09565
09566 if ((c = strchr(of, '@'))) {
09567 char *tmp;
09568 *c = '\0';
09569 if ((c = strchr(of, ':')))
09570 *c = '\0';
09571 tmp = ast_strdupa(of);
09572
09573
09574
09575 tmp = strsep(&tmp, ";");
09576 if (ast_is_shrinkable_phonenumber(tmp))
09577 ast_shrink_phone_number(tmp);
09578 ast_string_field_set(p, cid_num, tmp);
09579 }
09580
09581 if (!authpeer)
09582 user = find_user(of, 1);
09583
09584
09585 if (user && ast_apply_ha(user->ha, sin)) {
09586 ast_copy_flags(&p->flags[0], &user->flags[0], SIP_FLAGS_TO_COPY);
09587 ast_copy_flags(&p->flags[1], &user->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
09588
09589 for (v = user->chanvars ; v ; v = v->next) {
09590 if ((tmpvar = ast_variable_new(v->name, v->value))) {
09591 tmpvar->next = p->chanvars;
09592 p->chanvars = tmpvar;
09593 }
09594 }
09595 p->prefs = user->prefs;
09596
09597 if (p->rtp) {
09598 ast_rtp_codec_setpref(p->rtp, &p->prefs);
09599 p->autoframing = user->autoframing;
09600 }
09601
09602 if (!ast_strlen_zero(rpid_num) && ast_test_flag(&p->flags[0], SIP_TRUSTRPID)) {
09603 char *tmp;
09604 if (*calleridname)
09605 ast_string_field_set(p, cid_name, calleridname);
09606 tmp = ast_strdupa(rpid_num);
09607 if (ast_is_shrinkable_phonenumber(tmp))
09608 ast_shrink_phone_number(tmp);
09609 ast_string_field_set(p, cid_num, tmp);
09610 }
09611
09612 do_setnat(p, ast_test_flag(&p->flags[0], SIP_NAT_ROUTE) );
09613
09614 if (!(res = check_auth(p, req, user->name, user->secret, user->md5secret, sipmethod, uri2, reliable, ast_test_flag(req, SIP_PKT_IGNORE)))) {
09615 if (sip_cancel_destroy(p))
09616 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
09617 ast_copy_flags(&p->flags[0], &user->flags[0], SIP_FLAGS_TO_COPY);
09618 ast_copy_flags(&p->flags[1], &user->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
09619
09620 if (p->sipoptions)
09621 user->sipoptions = p->sipoptions;
09622
09623
09624 if (user->call_limit)
09625 ast_set_flag(&p->flags[0], SIP_CALL_LIMIT);
09626 if (!ast_strlen_zero(user->context))
09627 ast_string_field_set(p, context, user->context);
09628 if (!ast_strlen_zero(user->cid_num)) {
09629 char *tmp = ast_strdupa(user->cid_num);
09630 if (ast_is_shrinkable_phonenumber(tmp))
09631 ast_shrink_phone_number(tmp);
09632 ast_string_field_set(p, cid_num, tmp);
09633 }
09634 if (!ast_strlen_zero(user->cid_name))
09635 ast_string_field_set(p, cid_name, user->cid_name);
09636 ast_string_field_set(p, username, user->name);
09637 ast_string_field_set(p, peername, user->name);
09638 ast_string_field_set(p, peersecret, user->secret);
09639 ast_string_field_set(p, peermd5secret, user->md5secret);
09640 ast_string_field_set(p, subscribecontext, user->subscribecontext);
09641 ast_string_field_set(p, accountcode, user->accountcode);
09642 ast_string_field_set(p, language, user->language);
09643 ast_string_field_set(p, mohsuggest, user->mohsuggest);
09644 ast_string_field_set(p, mohinterpret, user->mohinterpret);
09645 p->allowtransfer = user->allowtransfer;
09646 p->amaflags = user->amaflags;
09647 p->callgroup = user->callgroup;
09648 p->pickupgroup = user->pickupgroup;
09649 if (user->callingpres)
09650 p->callingpres = user->callingpres;
09651
09652
09653 p->capability = user->capability;
09654 p->jointcapability = user->capability;
09655 if (p->peercapability)
09656 p->jointcapability &= p->peercapability;
09657 if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
09658 (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO))
09659 p->noncodeccapability |= AST_RTP_DTMF;
09660 else
09661 p->noncodeccapability &= ~AST_RTP_DTMF;
09662 p->jointnoncodeccapability = p->noncodeccapability;
09663 if (p->t38.peercapability)
09664 p->t38.jointcapability &= p->t38.peercapability;
09665 p->maxcallbitrate = user->maxcallbitrate;
09666
09667 if ((!ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT) || !(p->capability & AST_FORMAT_VIDEO_MASK)) && p->vrtp) {
09668 ast_rtp_destroy(p->vrtp);
09669 p->vrtp = NULL;
09670 }
09671 }
09672 if (user && debug)
09673 ast_verbose("Found user '%s'\n", user->name);
09674 } else {
09675 if (user) {
09676 if (!authpeer && debug)
09677 ast_verbose("Found user '%s', but fails host access\n", user->name);
09678 ASTOBJ_UNREF(user,sip_destroy_user);
09679 }
09680 user = NULL;
09681 }
09682
09683 if (!user) {
09684
09685 if (sipmethod == SIP_SUBSCRIBE)
09686
09687 peer = find_peer(of, NULL, 1, 0);
09688 else
09689
09690
09691
09692
09693 peer = find_peer(NULL, &p->recv, 1, 0);
09694
09695 if (peer) {
09696
09697 if (p->rtp) {
09698 ast_rtp_codec_setpref(p->rtp, &peer->prefs);
09699 p->autoframing = peer->autoframing;
09700 }
09701 if (debug)
09702 ast_verbose("Found peer '%s'\n", peer->name);
09703
09704
09705 ast_copy_flags(&p->flags[0], &peer->flags[0], SIP_FLAGS_TO_COPY);
09706 ast_copy_flags(&p->flags[1], &peer->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
09707
09708
09709 if (p->sipoptions)
09710 peer->sipoptions = p->sipoptions;
09711
09712
09713 if (!ast_strlen_zero(rpid_num) && ast_test_flag(&p->flags[0], SIP_TRUSTRPID)) {
09714 char *tmp = ast_strdupa(rpid_num);
09715 if (*calleridname)
09716 ast_string_field_set(p, cid_name, calleridname);
09717 if (ast_is_shrinkable_phonenumber(tmp))
09718 ast_shrink_phone_number(tmp);
09719 ast_string_field_set(p, cid_num, tmp);
09720 }
09721 do_setnat(p, ast_test_flag(&p->flags[0], SIP_NAT_ROUTE));
09722
09723 ast_string_field_set(p, peersecret, peer->secret);
09724 ast_string_field_set(p, peermd5secret, peer->md5secret);
09725 ast_string_field_set(p, subscribecontext, peer->subscribecontext);
09726 ast_string_field_set(p, mohinterpret, peer->mohinterpret);
09727 ast_string_field_set(p, mohsuggest, peer->mohsuggest);
09728 if (peer->callingpres)
09729 p->callingpres = peer->callingpres;
09730 if (peer->maxms && peer->lastms)
09731 p->timer_t1 = peer->lastms < global_t1min ? global_t1min : peer->lastms;
09732 if (ast_test_flag(&peer->flags[0], SIP_INSECURE_INVITE)) {
09733
09734 ast_string_field_free(p, peersecret);
09735 ast_string_field_free(p, peermd5secret);
09736 }
09737 if (!(res = check_auth(p, req, peer->name, p->peersecret, p->peermd5secret, sipmethod, uri2, reliable, ast_test_flag(req, SIP_PKT_IGNORE)))) {
09738 ast_copy_flags(&p->flags[0], &peer->flags[0], SIP_FLAGS_TO_COPY);
09739 ast_copy_flags(&p->flags[1], &peer->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
09740
09741 if (peer->call_limit)
09742 ast_set_flag(&p->flags[0], SIP_CALL_LIMIT);
09743 ast_string_field_set(p, peername, peer->name);
09744 ast_string_field_set(p, authname, peer->name);
09745
09746
09747 for (v = peer->chanvars ; v ; v = v->next) {
09748 if ((tmpvar = ast_variable_new(v->name, v->value))) {
09749 tmpvar->next = p->chanvars;
09750 p->chanvars = tmpvar;
09751 }
09752 }
09753 if (authpeer) {
09754 (*authpeer) = ASTOBJ_REF(peer);
09755 }
09756
09757 if (!ast_strlen_zero(peer->username)) {
09758 ast_string_field_set(p, username, peer->username);
09759
09760
09761 ast_string_field_set(p, authname, peer->username);
09762 }
09763 if (!ast_strlen_zero(peer->cid_num)) {
09764 char *tmp = ast_strdupa(peer->cid_num);
09765 if (ast_is_shrinkable_phonenumber(tmp))
09766 ast_shrink_phone_number(tmp);
09767 ast_string_field_set(p, cid_num, tmp);
09768 }
09769 if (!ast_strlen_zero(peer->cid_name))
09770 ast_string_field_set(p, cid_name, peer->cid_name);
09771 ast_string_field_set(p, fullcontact, peer->fullcontact);
09772 if (!ast_strlen_zero(peer->context))
09773 ast_string_field_set(p, context, peer->context);
09774 ast_string_field_set(p, peersecret, peer->secret);
09775 ast_string_field_set(p, peermd5secret, peer->md5secret);
09776 ast_string_field_set(p, language, peer->language);
09777 ast_string_field_set(p, accountcode, peer->accountcode);
09778 p->amaflags = peer->amaflags;
09779 p->callgroup = peer->callgroup;
09780 p->pickupgroup = peer->pickupgroup;
09781 p->capability = peer->capability;
09782 p->prefs = peer->prefs;
09783 p->jointcapability = peer->capability;
09784 if (p->peercapability)
09785 p->jointcapability &= p->peercapability;
09786 p->maxcallbitrate = peer->maxcallbitrate;
09787 if ((!ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT) || !(p->capability & AST_FORMAT_VIDEO_MASK)) && p->vrtp) {
09788 ast_rtp_destroy(p->vrtp);
09789 p->vrtp = NULL;
09790 }
09791 if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
09792 (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO))
09793 p->noncodeccapability |= AST_RTP_DTMF;
09794 else
09795 p->noncodeccapability &= ~AST_RTP_DTMF;
09796 p->jointnoncodeccapability = p->noncodeccapability;
09797 if (p->t38.peercapability)
09798 p->t38.jointcapability &= p->t38.peercapability;
09799 }
09800 ASTOBJ_UNREF(peer, sip_destroy_peer);
09801 } else {
09802 if (debug)
09803 ast_verbose("Found no matching peer or user for '%s:%d'\n", ast_inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));
09804
09805
09806 if (!global_allowguest) {
09807 if (global_alwaysauthreject)
09808 res = AUTH_FAKE_AUTH;
09809 else
09810 res = AUTH_SECRET_FAILED;
09811 } else if (!ast_strlen_zero(rpid_num) && ast_test_flag(&p->flags[0], SIP_TRUSTRPID)) {
09812 char *tmp = ast_strdupa(rpid_num);
09813 if (*calleridname)
09814 ast_string_field_set(p, cid_name, calleridname);
09815 if (ast_is_shrinkable_phonenumber(tmp))
09816 ast_shrink_phone_number(tmp);
09817 ast_string_field_set(p, cid_num, tmp);
09818 }
09819 }
09820
09821 }
09822
09823 if (user)
09824 ASTOBJ_UNREF(user, sip_destroy_user);
09825 return res;
09826 }
09827
09828
09829
09830
09831 static int check_user(struct sip_pvt *p, struct sip_request *req, int sipmethod, char *uri, enum xmittype reliable, struct sockaddr_in *sin)
09832 {
09833 return check_user_full(p, req, sipmethod, uri, reliable, sin, NULL);
09834 }
09835
09836
09837 static int get_msg_text(char *buf, int len, struct sip_request *req)
09838 {
09839 int x;
09840 int y;
09841
09842 buf[0] = '\0';
09843 y = len - strlen(buf) - 5;
09844 if (y < 0)
09845 y = 0;
09846 for (x=0;x<req->lines;x++) {
09847 strncat(buf, req->line[x], y);
09848 y -= strlen(req->line[x]) + 1;
09849 if (y < 0)
09850 y = 0;
09851 if (y != 0)
09852 strcat(buf, "\n");
09853 }
09854 return 0;
09855 }
09856
09857
09858
09859
09860
09861 static void receive_message(struct sip_pvt *p, struct sip_request *req)
09862 {
09863 char buf[1024];
09864 struct ast_frame f;
09865 const char *content_type = get_header(req, "Content-Type");
09866
09867 if (strncmp(content_type, "text/plain", strlen("text/plain"))) {
09868 transmit_response(p, "415 Unsupported Media Type", req);
09869 if (!p->owner)
09870 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
09871 return;
09872 }
09873
09874 if (get_msg_text(buf, sizeof(buf), req)) {
09875 ast_log(LOG_WARNING, "Unable to retrieve text from %s\n", p->callid);
09876 transmit_response(p, "202 Accepted", req);
09877 if (!p->owner)
09878 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
09879 return;
09880 }
09881
09882 if (p->owner) {
09883 if (sip_debug_test_pvt(p))
09884 ast_verbose("Message received: '%s'\n", buf);
09885 memset(&f, 0, sizeof(f));
09886 f.frametype = AST_FRAME_TEXT;
09887 f.subclass = 0;
09888 f.offset = 0;
09889 f.data = buf;
09890 f.datalen = strlen(buf);
09891 ast_queue_frame(p->owner, &f);
09892 transmit_response(p, "202 Accepted", req);
09893 } else {
09894 ast_log(LOG_WARNING,"Received message to %s from %s, dropped it...\n Content-Type:%s\n Message: %s\n", get_header(req,"To"), get_header(req,"From"), content_type, buf);
09895 transmit_response(p, "405 Method Not Allowed", req);
09896 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
09897 }
09898 return;
09899 }
09900
09901
09902 static int sip_show_inuse(int fd, int argc, char *argv[])
09903 {
09904 #define FORMAT "%-25.25s %-15.15s %-15.15s \n"
09905 #define FORMAT2 "%-25.25s %-15.15s %-15.15s \n"
09906 char ilimits[40];
09907 char iused[40];
09908 int showall = FALSE;
09909
09910 if (argc < 3)
09911 return RESULT_SHOWUSAGE;
09912
09913 if (argc == 4 && !strcmp(argv[3],"all"))
09914 showall = TRUE;
09915
09916 ast_cli(fd, FORMAT, "* User name", "In use", "Limit");
09917 ASTOBJ_CONTAINER_TRAVERSE(&userl, 1, do {
09918 ASTOBJ_RDLOCK(iterator);
09919 if (iterator->call_limit)
09920 snprintf(ilimits, sizeof(ilimits), "%d", iterator->call_limit);
09921 else
09922 ast_copy_string(ilimits, "N/A", sizeof(ilimits));
09923 snprintf(iused, sizeof(iused), "%d", iterator->inUse);
09924 if (showall || iterator->call_limit)
09925 ast_cli(fd, FORMAT2, iterator->name, iused, ilimits);
09926 ASTOBJ_UNLOCK(iterator);
09927 } while (0) );
09928
09929 ast_cli(fd, FORMAT, "* Peer name", "In use", "Limit");
09930
09931 ASTOBJ_CONTAINER_TRAVERSE(&peerl, 1, do {
09932 ASTOBJ_RDLOCK(iterator);
09933 if (iterator->call_limit)
09934 snprintf(ilimits, sizeof(ilimits), "%d", iterator->call_limit);
09935 else
09936 ast_copy_string(ilimits, "N/A", sizeof(ilimits));
09937 snprintf(iused, sizeof(iused), "%d/%d", iterator->inUse, iterator->inRinging);
09938 if (showall || iterator->call_limit)
09939 ast_cli(fd, FORMAT2, iterator->name, iused, ilimits);
09940 ASTOBJ_UNLOCK(iterator);
09941 } while (0) );
09942
09943 return RESULT_SUCCESS;
09944 #undef FORMAT
09945 #undef FORMAT2
09946 }
09947
09948
09949 static char *transfermode2str(enum transfermodes mode)
09950 {
09951 if (mode == TRANSFER_OPENFORALL)
09952 return "open";
09953 else if (mode == TRANSFER_CLOSED)
09954 return "closed";
09955 return "strict";
09956 }
09957
09958
09959 static char *nat2str(int nat)
09960 {
09961 switch(nat) {
09962 case SIP_NAT_NEVER:
09963 return "No";
09964 case SIP_NAT_ROUTE:
09965 return "Route";
09966 case SIP_NAT_ALWAYS:
09967 return "Always";
09968 case SIP_NAT_RFC3581:
09969 return "RFC3581";
09970 default:
09971 return "Unknown";
09972 }
09973 }
09974
09975
09976
09977
09978 static int peer_status(struct sip_peer *peer, char *status, int statuslen)
09979 {
09980 int res = 0;
09981 if (peer->maxms) {
09982 if (peer->lastms < 0) {
09983 ast_copy_string(status, "UNREACHABLE", statuslen);
09984 } else if (peer->lastms > peer->maxms) {
09985 snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
09986 res = 1;
09987 } else if (peer->lastms) {
09988 snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
09989 res = 1;
09990 } else {
09991 ast_copy_string(status, "UNKNOWN", statuslen);
09992 }
09993 } else {
09994 ast_copy_string(status, "Unmonitored", statuslen);
09995
09996 res = -1;
09997 }
09998 return res;
09999 }
10000
10001
10002 static int sip_show_users(int fd, int argc, char *argv[])
10003 {
10004 regex_t regexbuf;
10005 int havepattern = FALSE;
10006
10007 #define FORMAT "%-25.25s %-15.15s %-15.15s %-15.15s %-5.5s%-10.10s\n"
10008
10009 switch (argc) {
10010 case 5:
10011 if (!strcasecmp(argv[3], "like")) {
10012 if (regcomp(®exbuf, argv[4], REG_EXTENDED | REG_NOSUB))
10013 return RESULT_SHOWUSAGE;
10014 havepattern = TRUE;
10015 } else
10016 return RESULT_SHOWUSAGE;
10017 case 3:
10018 break;
10019 default:
10020 return RESULT_SHOWUSAGE;
10021 }
10022
10023 ast_cli(fd, FORMAT, "Username", "Secret", "Accountcode", "Def.Context", "ACL", "NAT");
10024 ASTOBJ_CONTAINER_TRAVERSE(&userl, 1, do {
10025 ASTOBJ_RDLOCK(iterator);
10026
10027 if (havepattern && regexec(®exbuf, iterator->name, 0, NULL, 0)) {
10028 ASTOBJ_UNLOCK(iterator);
10029 continue;
10030 }
10031
10032 ast_cli(fd, FORMAT, iterator->name,
10033 iterator->secret,
10034 iterator->accountcode,
10035 iterator->context,
10036 iterator->ha ? "Yes" : "No",
10037 nat2str(ast_test_flag(&iterator->flags[0], SIP_NAT)));
10038 ASTOBJ_UNLOCK(iterator);
10039 } while (0)
10040 );
10041
10042 if (havepattern)
10043 regfree(®exbuf);
10044
10045 return RESULT_SUCCESS;
10046 #undef FORMAT
10047 }
10048
10049 static char mandescr_show_peers[] =
10050 "Description: Lists SIP peers in text format with details on current status.\n"
10051 "Variables: \n"
10052 " ActionID: <id> Action ID for this transaction. Will be returned.\n";
10053
10054
10055
10056 static int manager_sip_show_peers(struct mansession *s, const struct message *m)
10057 {
10058 const char *id = astman_get_header(m,"ActionID");
10059 const char *a[] = {"sip", "show", "peers"};
10060 char idtext[256] = "";
10061 int total = 0;
10062
10063 if (!ast_strlen_zero(id))
10064 snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
10065
10066 astman_send_ack(s, m, "Peer status list will follow");
10067
10068 _sip_show_peers(-1, &total, s, m, 3, a);
10069
10070 astman_append(s,
10071 "Event: PeerlistComplete\r\n"
10072 "ListItems: %d\r\n"
10073 "%s"
10074 "\r\n", total, idtext);
10075 return 0;
10076 }
10077
10078
10079 static int sip_show_peers(int fd, int argc, char *argv[])
10080 {
10081 return _sip_show_peers(fd, NULL, NULL, NULL, argc, (const char **) argv);
10082 }
10083
10084
10085 static int _sip_show_peers(int fd, int *total, struct mansession *s, const struct message *m, int argc, const char *argv[])
10086 {
10087 regex_t regexbuf;
10088 int havepattern = FALSE;
10089
10090 #define FORMAT2 "%-25.25s %-15.15s %-3.3s %-3.3s %-3.3s %-8s %-10s %-10s\n"
10091 #define FORMAT "%-25.25s %-15.15s %-3.3s %-3.3s %-3.3s %-8d %-10s %-10s\n"
10092
10093 char name[256];
10094 int total_peers = 0;
10095 int peers_mon_online = 0;
10096 int peers_mon_offline = 0;
10097 int peers_unmon_offline = 0;
10098 int peers_unmon_online = 0;
10099 const char *id;
10100 char idtext[256] = "";
10101 int realtimepeers;
10102
10103 realtimepeers = ast_check_realtime("sippeers");
10104
10105 if (s) {
10106 id = astman_get_header(m,"ActionID");
10107 if (!ast_strlen_zero(id))
10108 snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
10109 }
10110
10111 switch (argc) {
10112 case 5:
10113 if (!strcasecmp(argv[3], "like")) {
10114 if (regcomp(®exbuf, argv[4], REG_EXTENDED | REG_NOSUB))
10115 return RESULT_SHOWUSAGE;
10116 havepattern = TRUE;
10117 } else
10118 return RESULT_SHOWUSAGE;
10119 case 3:
10120 break;
10121 default:
10122 return RESULT_SHOWUSAGE;
10123 }
10124
10125 if (!s)
10126 ast_cli(fd, FORMAT2, "Name/username", "Host", "Dyn", "Nat", "ACL", "Port", "Status", (realtimepeers ? "Realtime" : ""));
10127
10128 ASTOBJ_CONTAINER_TRAVERSE(&peerl, 1, do {
10129 char status[20] = "";
10130 char srch[2000];
10131 char pstatus;
10132
10133 ASTOBJ_RDLOCK(iterator);
10134
10135 if (havepattern && regexec(®exbuf, iterator->name, 0, NULL, 0)) {
10136 ASTOBJ_UNLOCK(iterator);
10137 continue;
10138 }
10139
10140 if (!ast_strlen_zero(iterator->username) && !s)
10141 snprintf(name, sizeof(name), "%s/%s", iterator->name, iterator->username);
10142 else
10143 ast_copy_string(name, iterator->name, sizeof(name));
10144
10145 pstatus = peer_status(iterator, status, sizeof(status));
10146 if (pstatus == 1)
10147 peers_mon_online++;
10148 else if (pstatus == 0)
10149 peers_mon_offline++;
10150 else {
10151 if (iterator->addr.sin_port == 0)
10152 peers_unmon_offline++;
10153 else
10154 peers_unmon_online++;
10155 }
10156
10157 snprintf(srch, sizeof(srch), FORMAT, name,
10158 iterator->addr.sin_addr.s_addr ? ast_inet_ntoa(iterator->addr.sin_addr) : "(Unspecified)",
10159 ast_test_flag(&iterator->flags[1], SIP_PAGE2_DYNAMIC) ? " D " : " ",
10160 ast_test_flag(&iterator->flags[0], SIP_NAT_ROUTE) ? " N " : " ",
10161 iterator->ha ? " A " : " ",
10162 ntohs(iterator->addr.sin_port), status,
10163 realtimepeers ? (ast_test_flag(&iterator->flags[0], SIP_REALTIME) ? "Cached RT":"") : "");
10164
10165 if (!s) {
10166 ast_cli(fd, FORMAT, name,
10167 iterator->addr.sin_addr.s_addr ? ast_inet_ntoa(iterator->addr.sin_addr) : "(Unspecified)",
10168 ast_test_flag(&iterator->flags[1], SIP_PAGE2_DYNAMIC) ? " D " : " ",
10169 ast_test_flag(&iterator->flags[0], SIP_NAT_ROUTE) ? " N " : " ",
10170 iterator->ha ? " A " : " ",
10171
10172 ntohs(iterator->addr.sin_port), status,
10173 realtimepeers ? (ast_test_flag(&iterator->flags[0], SIP_REALTIME) ? "Cached RT":"") : "");
10174 } else {
10175
10176 astman_append(s,
10177 "Event: PeerEntry\r\n%s"
10178 "Channeltype: SIP\r\n"
10179 "ObjectName: %s\r\n"
10180 "ChanObjectType: peer\r\n"
10181 "IPaddress: %s\r\n"
10182 "IPport: %d\r\n"
10183 "Dynamic: %s\r\n"
10184 "Natsupport: %s\r\n"
10185 "VideoSupport: %s\r\n"
10186 "ACL: %s\r\n"
10187 "Status: %s\r\n"
10188 "RealtimeDevice: %s\r\n\r\n",
10189 idtext,
10190 iterator->name,
10191 iterator->addr.sin_addr.s_addr ? ast_inet_ntoa(iterator->addr.sin_addr) : "-none-",
10192 ntohs(iterator->addr.sin_port),
10193 ast_test_flag(&iterator->flags[1], SIP_PAGE2_DYNAMIC) ? "yes" : "no",
10194 ast_test_flag(&iterator->flags[0], SIP_NAT_ROUTE) ? "yes" : "no",
10195 ast_test_flag(&iterator->flags[1], SIP_PAGE2_VIDEOSUPPORT) ? "yes" : "no",
10196 iterator->ha ? "yes" : "no",
10197 status,
10198 realtimepeers ? (ast_test_flag(&iterator->flags[0], SIP_REALTIME) ? "yes":"no") : "no");
10199 }
10200
10201 ASTOBJ_UNLOCK(iterator);
10202
10203 total_peers++;
10204 } while(0) );
10205
10206 if (!s)
10207 ast_cli(fd, "%d sip peers [Monitored: %d online, %d offline Unmonitored: %d online, %d offline]\n",
10208 total_peers, peers_mon_online, peers_mon_offline, peers_unmon_online, peers_unmon_offline);
10209
10210 if (havepattern)
10211 regfree(®exbuf);
10212
10213 if (total)
10214 *total = total_peers;
10215
10216
10217 return RESULT_SUCCESS;
10218 #undef FORMAT
10219 #undef FORMAT2
10220 }
10221
10222
10223 static int sip_show_objects(int fd, int argc, char *argv[])
10224 {
10225 char tmp[256];
10226 if (argc != 3)
10227 return RESULT_SHOWUSAGE;
10228 ast_cli(fd, "-= User objects: %d static, %d realtime =-\n\n", suserobjs, ruserobjs);
10229 ASTOBJ_CONTAINER_DUMP(fd, tmp, sizeof(tmp), &userl);
10230 ast_cli(fd, "-= Peer objects: %d static, %d realtime, %d autocreate =-\n\n", speerobjs, rpeerobjs, apeerobjs);
10231 ASTOBJ_CONTAINER_DUMP(fd, tmp, sizeof(tmp), &peerl);
10232 ast_cli(fd, "-= Registry objects: %d =-\n\n", regobjs);
10233 ASTOBJ_CONTAINER_DUMP(fd, tmp, sizeof(tmp), ®l);
10234 return RESULT_SUCCESS;
10235 }
10236
10237 static void print_group(int fd, ast_group_t group, int crlf)
10238 {
10239 char buf[256];
10240 ast_cli(fd, crlf ? "%s\r\n" : "%s\n", ast_print_group(buf, sizeof(buf), group) );
10241 }
10242
10243
10244 static const char *dtmfmode2str(int mode)
10245 {
10246 switch (mode) {
10247 case SIP_DTMF_RFC2833:
10248 return "rfc2833";
10249 case SIP_DTMF_INFO:
10250 return "info";
10251 case SIP_DTMF_INBAND:
10252 return "inband";
10253 case SIP_DTMF_AUTO:
10254 return "auto";
10255 }
10256 return "<error>";
10257 }
10258
10259
10260 static const char *insecure2str(int port, int invite)
10261 {
10262 if (port && invite)
10263 return "port,invite";
10264 else if (port)
10265 return "port";
10266 else if (invite)
10267 return "invite";
10268 else
10269 return "no";
10270 }
10271
10272
10273
10274
10275 static void cleanup_stale_contexts(char *new, char *old)
10276 {
10277 char *oldcontext, *newcontext, *stalecontext, *stringp, newlist[AST_MAX_CONTEXT];
10278
10279 while ((oldcontext = strsep(&old, "&"))) {
10280 stalecontext = '\0';
10281 ast_copy_string(newlist, new, sizeof(newlist));
10282 stringp = newlist;
10283 while ((newcontext = strsep(&stringp, "&"))) {
10284 if (strcmp(newcontext, oldcontext) == 0) {
10285
10286 stalecontext = '\0';
10287 break;
10288 } else if (strcmp(newcontext, oldcontext)) {
10289 stalecontext = oldcontext;
10290 }
10291
10292 }
10293 if (stalecontext)
10294 ast_context_destroy(ast_context_find(stalecontext), "SIP");
10295 }
10296 }
10297
10298
10299 static int sip_prune_realtime(int fd, int argc, char *argv[])
10300 {
10301 struct sip_peer *peer;
10302 struct sip_user *user;
10303 int pruneuser = FALSE;
10304 int prunepeer = FALSE;
10305 int multi = FALSE;
10306 char *name = NULL;
10307 regex_t regexbuf;
10308
10309 switch (argc) {
10310 case 4:
10311 if (!strcasecmp(argv[3], "user"))
10312 return RESULT_SHOWUSAGE;
10313 if (!strcasecmp(argv[3], "peer"))
10314 return RESULT_SHOWUSAGE;
10315 if (!strcasecmp(argv[3], "like"))
10316 return RESULT_SHOWUSAGE;
10317 if (!strcasecmp(argv[3], "all")) {
10318 multi = TRUE;
10319 pruneuser = prunepeer = TRUE;
10320 } else {
10321 pruneuser = prunepeer = TRUE;
10322 name = argv[3];
10323 }
10324 break;
10325 case 5:
10326 if (!strcasecmp(argv[4], "like"))
10327 return RESULT_SHOWUSAGE;
10328 if (!strcasecmp(argv[3], "all"))
10329 return RESULT_SHOWUSAGE;
10330 if (!strcasecmp(argv[3], "like")) {
10331 multi = TRUE;
10332 name = argv[4];
10333 pruneuser = prunepeer = TRUE;
10334 } else if (!strcasecmp(argv[3], "user")) {
10335 pruneuser = TRUE;
10336 if (!strcasecmp(argv[4], "all"))
10337 multi = TRUE;
10338 else
10339 name = argv[4];
10340 } else if (!strcasecmp(argv[3], "peer")) {
10341 prunepeer = TRUE;
10342 if (!strcasecmp(argv[4], "all"))
10343 multi = TRUE;
10344 else
10345 name = argv[4];
10346 } else
10347 return RESULT_SHOWUSAGE;
10348 break;
10349 case 6:
10350 if (strcasecmp(argv[4], "like"))
10351 return RESULT_SHOWUSAGE;
10352 if (!strcasecmp(argv[3], "user")) {
10353 pruneuser = TRUE;
10354 name = argv[5];
10355 } else if (!strcasecmp(argv[3], "peer")) {
10356 prunepeer = TRUE;
10357 name = argv[5];
10358 } else
10359 return RESULT_SHOWUSAGE;
10360 break;
10361 default:
10362 return RESULT_SHOWUSAGE;
10363 }
10364
10365 if (multi && name) {
10366 if (regcomp(®exbuf, name, REG_EXTENDED | REG_NOSUB))
10367 return RESULT_SHOWUSAGE;
10368 }
10369
10370 if (multi) {
10371 if (prunepeer) {
10372 int pruned = 0;
10373
10374 ASTOBJ_CONTAINER_WRLOCK(&peerl);
10375 ASTOBJ_CONTAINER_TRAVERSE(&peerl, 1, do {
10376 ASTOBJ_RDLOCK(iterator);
10377 if (name && regexec(®exbuf, iterator->name, 0, NULL, 0)) {
10378 ASTOBJ_UNLOCK(iterator);
10379 continue;
10380 };
10381 if (ast_test_flag(&iterator->flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
10382 ASTOBJ_MARK(iterator);
10383 pruned++;
10384 }
10385 ASTOBJ_UNLOCK(iterator);
10386 } while (0) );
10387 if (pruned) {
10388 ASTOBJ_CONTAINER_PRUNE_MARKED(&peerl, sip_destroy_peer);
10389 ast_cli(fd, "%d peers pruned.\n", pruned);
10390 } else
10391 ast_cli(fd, "No peers found to prune.\n");
10392 ASTOBJ_CONTAINER_UNLOCK(&peerl);
10393 }
10394 if (pruneuser) {
10395 int pruned = 0;
10396
10397 ASTOBJ_CONTAINER_WRLOCK(&userl);
10398 ASTOBJ_CONTAINER_TRAVERSE(&userl, 1, do {
10399 ASTOBJ_RDLOCK(iterator);
10400 if (name && regexec(®exbuf, iterator->name, 0, NULL, 0)) {
10401 ASTOBJ_UNLOCK(iterator);
10402 continue;
10403 };
10404 if (ast_test_flag(&iterator->flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
10405 ASTOBJ_MARK(iterator);
10406 pruned++;
10407 }
10408 ASTOBJ_UNLOCK(iterator);
10409 } while (0) );
10410 if (pruned) {
10411 ASTOBJ_CONTAINER_PRUNE_MARKED(&userl, sip_destroy_user);
10412 ast_cli(fd, "%d users pruned.\n", pruned);
10413 } else
10414 ast_cli(fd, "No users found to prune.\n");
10415 ASTOBJ_CONTAINER_UNLOCK(&userl);
10416 }
10417 } else {
10418 if (prunepeer) {
10419 if ((peer = ASTOBJ_CONTAINER_FIND_UNLINK(&peerl, name))) {
10420 if (!ast_test_flag(&peer->flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
10421 ast_cli(fd, "Peer '%s' is not a Realtime peer, cannot be pruned.\n", name);
10422 ASTOBJ_CONTAINER_LINK(&peerl, peer);
10423 } else
10424 ast_cli(fd, "Peer '%s' pruned.\n", name);
10425 ASTOBJ_UNREF(peer, sip_destroy_peer);
10426 } else
10427 ast_cli(fd, "Peer '%s' not found.\n", name);
10428 }
10429 if (pruneuser) {
10430 if ((user = ASTOBJ_CONTAINER_FIND_UNLINK(&userl, name))) {
10431 if (!ast_test_flag(&user->flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
10432 ast_cli(fd, "User '%s' is not a Realtime user, cannot be pruned.\n", name);
10433 ASTOBJ_CONTAINER_LINK(&userl, user);
10434 } else
10435 ast_cli(fd, "User '%s' pruned.\n", name);
10436 ASTOBJ_UNREF(user, sip_destroy_user);
10437 } else
10438 ast_cli(fd, "User '%s' not found.\n", name);
10439 }
10440 }
10441
10442 return RESULT_SUCCESS;
10443 }
10444
10445
10446 static void print_codec_to_cli(int fd, struct ast_codec_pref *pref)
10447 {
10448 int x, codec;
10449
10450 for(x = 0; x < 32 ; x++) {
10451 codec = ast_codec_pref_index(pref, x);
10452 if (!codec)
10453 break;
10454 ast_cli(fd, "%s", ast_getformatname(codec));
10455 ast_cli(fd, ":%d", pref->framing[x]);
10456 if (x < 31 && ast_codec_pref_index(pref, x + 1))
10457 ast_cli(fd, ",");
10458 }
10459 if (!x)
10460 ast_cli(fd, "none");
10461 }
10462
10463
10464 static const char *domain_mode_to_text(const enum domain_mode mode)
10465 {
10466 switch (mode) {
10467 case SIP_DOMAIN_AUTO:
10468 return "[Automatic]";
10469 case SIP_DOMAIN_CONFIG:
10470 return "[Configured]";
10471 }
10472
10473 return "";
10474 }
10475
10476
10477 static int sip_show_domains(int fd, int argc, char *argv[])
10478 {
10479 struct domain *d;
10480 #define FORMAT "%-40.40s %-20.20s %-16.16s\n"
10481
10482 if (AST_LIST_EMPTY(&domain_list)) {
10483 ast_cli(fd, "SIP Domain support not enabled.\n\n");
10484 return RESULT_SUCCESS;
10485 } else {
10486 ast_cli(fd, FORMAT, "Our local SIP domains:", "Context", "Set by");
10487 AST_LIST_LOCK(&domain_list);
10488 AST_LIST_TRAVERSE(&domain_list, d, list)
10489 ast_cli(fd, FORMAT, d->domain, S_OR(d->context, "(default)"),
10490 domain_mode_to_text(d->mode));
10491 AST_LIST_UNLOCK(&domain_list);
10492 ast_cli(fd, "\n");
10493 return RESULT_SUCCESS;
10494 }
10495 }
10496 #undef FORMAT
10497
10498 static char mandescr_show_peer[] =
10499 "Description: Show one SIP peer with details on current status.\n"
10500 "Variables: \n"
10501 " Peer: <name> The peer name you want to check.\n"
10502 " ActionID: <id> Optional action ID for this AMI transaction.\n";
10503
10504
10505 static int manager_sip_show_peer(struct mansession *s, const struct message *m)
10506 {
10507 const char *a[4];
10508 const char *peer;
10509 int ret;
10510
10511 peer = astman_get_header(m,"Peer");
10512 if (ast_strlen_zero(peer)) {
10513 astman_send_error(s, m, "Peer: <name> missing.");
10514 return 0;
10515 }
10516 a[0] = "sip";
10517 a[1] = "show";
10518 a[2] = "peer";
10519 a[3] = peer;
10520
10521 ret = _sip_show_peer(1, -1, s, m, 4, a);
10522 astman_append(s, "\r\n\r\n" );
10523 return ret;
10524 }
10525
10526
10527
10528
10529 static int sip_show_peer(int fd, int argc, char *argv[])
10530 {
10531 return _sip_show_peer(0, fd, NULL, NULL, argc, (const char **) argv);
10532 }
10533
10534
10535 static int _sip_show_peer(int type, int fd, struct mansession *s, const struct message *m, int argc, const char *argv[])
10536 {
10537 char status[30] = "";
10538 char cbuf[256];
10539 struct sip_peer *peer;
10540 char codec_buf[512];
10541 struct ast_codec_pref *pref;
10542 struct ast_variable *v;
10543 struct sip_auth *auth;
10544 int x = 0, codec = 0, load_realtime;
10545 int realtimepeers;
10546
10547 realtimepeers = ast_check_realtime("sippeers");
10548
10549 if (argc < 4)
10550 return RESULT_SHOWUSAGE;
10551
10552 load_realtime = (argc == 5 && !strcmp(argv[4], "load")) ? TRUE : FALSE;
10553 peer = find_peer(argv[3], NULL, load_realtime, 0);
10554 if (s) {
10555 if (peer) {
10556 const char *id = astman_get_header(m,"ActionID");
10557
10558 astman_append(s, "Response: Success\r\n");
10559 if (!ast_strlen_zero(id))
10560 astman_append(s, "ActionID: %s\r\n",id);
10561 } else {
10562 snprintf (cbuf, sizeof(cbuf), "Peer %s not found.", argv[3]);
10563 astman_send_error(s, m, cbuf);
10564 return 0;
10565 }
10566 }
10567 if (peer && type==0 ) {
10568 ast_cli(fd,"\n\n");
10569 ast_cli(fd, " * Name : %s\n", peer->name);
10570 if (realtimepeers) {
10571 ast_cli(fd, " Realtime peer: %s\n", ast_test_flag(&peer->flags[0], SIP_REALTIME) ? "Yes, cached" : "No");
10572 }
10573 ast_cli(fd, " Secret : %s\n", ast_strlen_zero(peer->secret)?"<Not set>":"<Set>");
10574 ast_cli(fd, " MD5Secret : %s\n", ast_strlen_zero(peer->md5secret)?"<Not set>":"<Set>");
10575 for (auth = peer->auth; auth; auth = auth->next) {
10576 ast_cli(fd, " Realm-auth : Realm %-15.15s User %-10.20s ", auth->realm, auth->username);
10577 ast_cli(fd, "%s\n", !ast_strlen_zero(auth->secret)?"<Secret set>":(!ast_strlen_zero(auth->md5secret)?"<MD5secret set>" : "<Not set>"));
10578 }
10579 ast_cli(fd, " Context : %s\n", peer->context);
10580 ast_cli(fd, " Subscr.Cont. : %s\n", S_OR(peer->subscribecontext, "<Not set>") );
10581 ast_cli(fd, " Language : %s\n", peer->language);
10582 if (!ast_strlen_zero(peer->accountcode))
10583 ast_cli(fd, " Accountcode : %s\n", peer->accountcode);
10584 ast_cli(fd, " AMA flags : %s\n", ast_cdr_flags2str(peer->amaflags));
10585 ast_cli(fd, " Transfer mode: %s\n", transfermode2str(peer->allowtransfer));
10586 ast_cli(fd, " CallingPres : %s\n", ast_describe_caller_presentation(peer->callingpres));
10587 if (!ast_strlen_zero(peer->fromuser))
10588 ast_cli(fd, " FromUser : %s\n", peer->fromuser);
10589 if (!ast_strlen_zero(peer->fromdomain))
10590 ast_cli(fd, " FromDomain : %s\n", peer->fromdomain);
10591 ast_cli(fd, " Callgroup : ");
10592 print_group(fd, peer->callgroup, 0);
10593 ast_cli(fd, " Pickupgroup : ");
10594 print_group(fd, peer->pickupgroup, 0);
10595 ast_cli(fd, " Mailbox : %s\n", peer->mailbox);
10596 ast_cli(fd, " VM Extension : %s\n", peer->vmexten);
10597 ast_cli(fd, " LastMsgsSent : %d/%d\n", (peer->lastmsgssent & 0x7fff0000) >> 16, peer->lastmsgssent & 0xffff);
10598 ast_cli(fd, " Call limit : %d\n", peer->call_limit);
10599 ast_cli(fd, " Dynamic : %s\n", (ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC)?"Yes":"No"));
10600 ast_cli(fd, " Callerid : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
10601 ast_cli(fd, " MaxCallBR : %d kbps\n", peer->maxcallbitrate);
10602 ast_cli(fd, " Expire : %ld\n", ast_sched_when(sched, peer->expire));
10603 ast_cli(fd, " Insecure : %s\n", insecure2str(ast_test_flag(&peer->flags[0], SIP_INSECURE_PORT), ast_test_flag(&peer->flags[0], SIP_INSECURE_INVITE)));
10604 ast_cli(fd, " Nat : %s\n", nat2str(ast_test_flag(&peer->flags[0], SIP_NAT)));
10605 ast_cli(fd, " ACL : %s\n", (peer->ha?"Yes":"No"));
10606 ast_cli(fd, " T38 pt UDPTL : %s\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_T38SUPPORT_UDPTL)?"Yes":"No");
10607 #ifdef WHEN_WE_HAVE_T38_FOR_OTHER_TRANSPORTS
10608 ast_cli(fd, " T38 pt RTP : %s\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_T38SUPPORT_RTP)?"Yes":"No");
10609 ast_cli(fd, " T38 pt TCP : %s\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_T38SUPPORT_TCP)?"Yes":"No");
10610 #endif
10611 ast_cli(fd, " CanReinvite : %s\n", ast_test_flag(&peer->flags[0], SIP_CAN_REINVITE)?"Yes":"No");
10612 ast_cli(fd, " PromiscRedir : %s\n", ast_test_flag(&peer->flags[0], SIP_PROMISCREDIR)?"Yes":"No");
10613 ast_cli(fd, " User=Phone : %s\n", ast_test_flag(&peer->flags[0], SIP_USEREQPHONE)?"Yes":"No");
10614 ast_cli(fd, " Video Support: %s\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_VIDEOSUPPORT)?"Yes":"No");
10615 ast_cli(fd, " Trust RPID : %s\n", ast_test_flag(&peer->flags[0], SIP_TRUSTRPID) ? "Yes" : "No");
10616 ast_cli(fd, " Send RPID : %s\n", ast_test_flag(&peer->flags[0], SIP_SENDRPID) ? "Yes" : "No");
10617 ast_cli(fd, " Subscriptions: %s\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_ALLOWSUBSCRIBE) ? "Yes" : "No");
10618 ast_cli(fd, " Overlap dial : %s\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_ALLOWOVERLAP) ? "Yes" : "No");
10619
10620
10621 ast_cli(fd, " DTMFmode : %s\n", dtmfmode2str(ast_test_flag(&peer->flags[0], SIP_DTMF)));
10622 ast_cli(fd, " LastMsg : %d\n", peer->lastmsg);
10623 ast_cli(fd, " ToHost : %s\n", peer->tohost);
10624 ast_cli(fd, " Addr->IP : %s Port %d\n", peer->addr.sin_addr.s_addr ? ast_inet_ntoa(peer->addr.sin_addr) : "(Unspecified)", ntohs(peer->addr.sin_port));
10625 ast_cli(fd, " Defaddr->IP : %s Port %d\n", ast_inet_ntoa(peer->defaddr.sin_addr), ntohs(peer->defaddr.sin_port));
10626 ast_cli(fd, " Transport : %s\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_TCP) ? "TCP" : "UDP");
10627 if (!ast_strlen_zero(global_regcontext))
10628 ast_cli(fd, " Reg. exten : %s\n", peer->regexten);
10629 ast_cli(fd, " Def. Username: %s\n", peer->username);
10630 ast_cli(fd, " SIP Options : ");
10631 if (peer->sipoptions) {
10632 int lastoption = -1;
10633 for (x=0 ; (x < (sizeof(sip_options) / sizeof(sip_options[0]))); x++) {
10634 if (sip_options[x].id != lastoption) {
10635 if (peer->sipoptions & sip_options[x].id)
10636 ast_cli(fd, "%s ", sip_options[x].text);
10637 lastoption = x;
10638 }
10639 }
10640 } else
10641 ast_cli(fd, "(none)");
10642
10643 ast_cli(fd, "\n");
10644 ast_cli(fd, " Codecs : ");
10645 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
10646 ast_cli(fd, "%s\n", codec_buf);
10647 ast_cli(fd, " Codec Order : (");
10648 print_codec_to_cli(fd, &peer->prefs);
10649 ast_cli(fd, ")\n");
10650
10651 ast_cli(fd, " Auto-Framing: %s \n", peer->autoframing ? "Yes" : "No");
10652 ast_cli(fd, " Status : ");
10653 peer_status(peer, status, sizeof(status));
10654 ast_cli(fd, "%s\n",status);
10655 ast_cli(fd, " Useragent : %s\n", peer->useragent);
10656 ast_cli(fd, " Reg. Contact : %s\n", peer->fullcontact);
10657 if (peer->chanvars) {
10658 ast_cli(fd, " Variables :\n");
10659 for (v = peer->chanvars ; v ; v = v->next)
10660 ast_cli(fd, " %s = %s\n", v->name, v->value);
10661 }
10662 ast_cli(fd,"\n");
10663 ASTOBJ_UNREF(peer,sip_destroy_peer);
10664 } else if (peer && type == 1) {
10665 char buf[256];
10666 astman_append(s, "Channeltype: SIP\r\n");
10667 astman_append(s, "ObjectName: %s\r\n", peer->name);
10668 astman_append(s, "ChanObjectType: peer\r\n");
10669 astman_append(s, "SecretExist: %s\r\n", ast_strlen_zero(peer->secret)?"N":"Y");
10670 astman_append(s, "MD5SecretExist: %s\r\n", ast_strlen_zero(peer->md5secret)?"N":"Y");
10671 astman_append(s, "Context: %s\r\n", peer->context);
10672 astman_append(s, "Language: %s\r\n", peer->language);
10673 if (!ast_strlen_zero(peer->accountcode))
10674 astman_append(s, "Accountcode: %s\r\n", peer->accountcode);
10675 astman_append(s, "AMAflags: %s\r\n", ast_cdr_flags2str(peer->amaflags));
10676 astman_append(s, "CID-CallingPres: %s\r\n", ast_describe_caller_presentation(peer->callingpres));
10677 if (!ast_strlen_zero(peer->fromuser))
10678 astman_append(s, "SIP-FromUser: %s\r\n", peer->fromuser);
10679 if (!ast_strlen_zero(peer->fromdomain))
10680 astman_append(s, "SIP-FromDomain: %s\r\n", peer->fromdomain);
10681 astman_append(s, "Callgroup: ");
10682 astman_append(s, "%s\r\n", ast_print_group(buf, sizeof(buf), peer->callgroup));
10683 astman_append(s, "Pickupgroup: ");
10684 astman_append(s, "%s\r\n", ast_print_group(buf, sizeof(buf), peer->pickupgroup));
10685 astman_append(s, "VoiceMailbox: %s\r\n", peer->mailbox);
10686 astman_append(s, "TransferMode: %s\r\n", transfermode2str(peer->allowtransfer));
10687 astman_append(s, "LastMsgsSent: %d\r\n", peer->lastmsgssent);
10688 astman_append(s, "Call-limit: %d\r\n", peer->call_limit);
10689 astman_append(s, "MaxCallBR: %d kbps\r\n", peer->maxcallbitrate);
10690 astman_append(s, "Dynamic: %s\r\n", (ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC)?"Y":"N"));
10691 astman_append(s, "Callerid: %s\r\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, ""));
10692 astman_append(s, "RegExpire: %ld seconds\r\n", ast_sched_when(sched,peer->expire));
10693 astman_append(s, "SIP-AuthInsecure: %s\r\n", insecure2str(ast_test_flag(&peer->flags[0], SIP_INSECURE_PORT), ast_test_flag(&peer->flags[0], SIP_INSECURE_INVITE)));
10694 astman_append(s, "SIP-NatSupport: %s\r\n", nat2str(ast_test_flag(&peer->flags[0], SIP_NAT)));
10695 astman_append(s, "ACL: %s\r\n", (peer->ha?"Y":"N"));
10696 astman_append(s, "SIP-CanReinvite: %s\r\n", (ast_test_flag(&peer->flags[0], SIP_CAN_REINVITE)?"Y":"N"));
10697 astman_append(s, "SIP-PromiscRedir: %s\r\n", (ast_test_flag(&peer->flags[0], SIP_PROMISCREDIR)?"Y":"N"));
10698 astman_append(s, "SIP-UserPhone: %s\r\n", (ast_test_flag(&peer->flags[0], SIP_USEREQPHONE)?"Y":"N"));
10699 astman_append(s, "SIP-VideoSupport: %s\r\n", (ast_test_flag(&peer->flags[1], SIP_PAGE2_VIDEOSUPPORT)?"Y":"N"));
10700
10701
10702 astman_append(s, "SIP-DTMFmode: %s\r\n", dtmfmode2str(ast_test_flag(&peer->flags[0], SIP_DTMF)));
10703 astman_append(s, "SIPLastMsg: %d\r\n", peer->lastmsg);
10704 astman_append(s, "ToHost: %s\r\n", peer->tohost);
10705 astman_append(s, "Address-IP: %s\r\nAddress-Port: %d\r\n", peer->addr.sin_addr.s_addr ? ast_inet_ntoa(peer->addr.sin_addr) : "", ntohs(peer->addr.sin_port));
10706 astman_append(s, "Default-addr-IP: %s\r\nDefault-addr-port: %d\r\n", ast_inet_ntoa(peer->defaddr.sin_addr), ntohs(peer->defaddr.sin_port));
10707 astman_append(s, "Default-Username: %s\r\n", peer->username);
10708 if (!ast_strlen_zero(global_regcontext))
10709 astman_append(s, "RegExtension: %s\r\n", peer->regexten);
10710 astman_append(s, "Codecs: ");
10711 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
10712 astman_append(s, "%s\r\n", codec_buf);
10713 astman_append(s, "CodecOrder: ");
10714 pref = &peer->prefs;
10715 for(x = 0; x < 32 ; x++) {
10716 codec = ast_codec_pref_index(pref,x);
10717 if (!codec)
10718 break;
10719 astman_append(s, "%s", ast_getformatname(codec));
10720 if (x < 31 && ast_codec_pref_index(pref,x+1))
10721 astman_append(s, ",");
10722 }
10723
10724 astman_append(s, "\r\n");
10725 astman_append(s, "Status: ");
10726 peer_status(peer, status, sizeof(status));
10727 astman_append(s, "%s\r\n", status);
10728 astman_append(s, "SIP-Useragent: %s\r\n", peer->useragent);
10729 astman_append(s, "Reg-Contact : %s\r\n", peer->fullcontact);
10730 if (peer->chanvars) {
10731 for (v = peer->chanvars ; v ; v = v->next) {
10732 astman_append(s, "ChanVariable:\n");
10733 astman_append(s, " %s,%s\r\n", v->name, v->value);
10734 }
10735 }
10736
10737 ASTOBJ_UNREF(peer,sip_destroy_peer);
10738
10739 } else {
10740 ast_cli(fd,"Peer %s not found.\n", argv[3]);
10741 ast_cli(fd,"\n");
10742 }
10743
10744 return RESULT_SUCCESS;
10745 }
10746
10747
10748 static int sip_show_user(int fd, int argc, char *argv[])
10749 {
10750 char cbuf[256];
10751 struct sip_user *user;
10752 struct ast_variable *v;
10753 int load_realtime;
10754
10755 if (argc < 4)
10756 return RESULT_SHOWUSAGE;
10757
10758
10759 load_realtime = (argc == 5 && !strcmp(argv[4], "load")) ? TRUE : FALSE;
10760
10761 user = find_user(argv[3], load_realtime);
10762 if (user) {
10763 ast_cli(fd,"\n\n");
10764 ast_cli(fd, " * Name : %s\n", user->name);
10765 ast_cli(fd, " Secret : %s\n", ast_strlen_zero(user->secret)?"<Not set>":"<Set>");
10766 ast_cli(fd, " MD5Secret : %s\n", ast_strlen_zero(user->md5secret)?"<Not set>":"<Set>");
10767 ast_cli(fd, " Context : %s\n", user->context);
10768 ast_cli(fd, " Language : %s\n", user->language);
10769 if (!ast_strlen_zero(user->accountcode))
10770 ast_cli(fd, " Accountcode : %s\n", user->accountcode);
10771 ast_cli(fd, " AMA flags : %s\n", ast_cdr_flags2str(user->amaflags));
10772 ast_cli(fd, " Transfer mode: %s\n", transfermode2str(user->allowtransfer));
10773 ast_cli(fd, " MaxCallBR : %d kbps\n", user->maxcallbitrate);
10774 ast_cli(fd, " CallingPres : %s\n", ast_describe_caller_presentation(user->callingpres));
10775 ast_cli(fd, " Call limit : %d\n", user->call_limit);
10776 ast_cli(fd, " Callgroup : ");
10777 print_group(fd, user->callgroup, 0);
10778 ast_cli(fd, " Pickupgroup : ");
10779 print_group(fd, user->pickupgroup, 0);
10780 ast_cli(fd, " Callerid : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), user->cid_name, user->cid_num, "<unspecified>"));
10781 ast_cli(fd, " ACL : %s\n", (user->ha?"Yes":"No"));
10782 ast_cli(fd, " Codec Order : (");
10783 print_codec_to_cli(fd, &user->prefs);
10784 ast_cli(fd, ")\n");
10785
10786 ast_cli(fd, " Auto-Framing: %s \n", user->autoframing ? "Yes" : "No");
10787 if (user->chanvars) {
10788 ast_cli(fd, " Variables :\n");
10789 for (v = user->chanvars ; v ; v = v->next)
10790 ast_cli(fd, " %s = %s\n", v->name, v->value);
10791 }
10792 ast_cli(fd,"\n");
10793 ASTOBJ_UNREF(user,sip_destroy_user);
10794 } else {
10795 ast_cli(fd,"User %s not found.\n", argv[3]);
10796 ast_cli(fd,"\n");
10797 }
10798
10799 return RESULT_SUCCESS;
10800 }
10801
10802
10803 static int sip_show_registry(int fd, int argc, char *argv[])
10804 {
10805 #define FORMAT2 "%-30.30s %-12.12s %8.8s %-20.20s %-25.25s\n"
10806 #define FORMAT "%-30.30s %-12.12s %8d %-20.20s %-25.25s\n"
10807 char host[80];
10808 char tmpdat[256];
10809 struct tm tm;
10810
10811
10812 if (argc != 3)
10813 return RESULT_SHOWUSAGE;
10814 ast_cli(fd, FORMAT2, "Host", "Username", "Refresh", "State", "Reg.Time");
10815 ASTOBJ_CONTAINER_TRAVERSE(®l, 1, do {
10816 ASTOBJ_RDLOCK(iterator);
10817 snprintf(host, sizeof(host), "%s:%d", iterator->hostname, iterator->portno ? iterator->portno : STANDARD_SIP_PORT);
10818 if (iterator->regtime) {
10819 ast_localtime(&iterator->regtime, &tm, NULL);
10820 strftime(tmpdat, sizeof(tmpdat), "%a, %d %b %Y %T", &tm);
10821 } else {
10822 tmpdat[0] = 0;
10823 }
10824 ast_cli(fd, FORMAT, host, iterator->username, iterator->refresh, regstate2str(iterator->regstate), tmpdat);
10825 ASTOBJ_UNLOCK(iterator);
10826 } while(0));
10827 return RESULT_SUCCESS;
10828 #undef FORMAT
10829 #undef FORMAT2
10830 }
10831
10832
10833 static int sip_show_settings(int fd, int argc, char *argv[])
10834 {
10835 int realtimepeers;
10836 int realtimeusers;
10837 char codec_buf[SIPBUFSIZE];
10838
10839 realtimepeers = ast_check_realtime("sippeers");
10840 realtimeusers = ast_check_realtime("sipusers");
10841
10842 if (argc != 3)
10843 return RESULT_SHOWUSAGE;
10844 ast_cli(fd, "\n\nGlobal Settings:\n");
10845 ast_cli(fd, "----------------\n");
10846 ast_cli(fd, " SIP Port: %d\n", ntohs(bindaddr.sin_port));
10847 ast_cli(fd, " Bindaddress: %s\n", ast_inet_ntoa(bindaddr.sin_addr));
10848 ast_cli(fd, " Videosupport: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_VIDEOSUPPORT) ? "Yes" : "No");
10849 ast_cli(fd, " AutoCreatePeer: %s\n", autocreatepeer ? "Yes" : "No");
10850 ast_cli(fd, " Allow unknown access: %s\n", global_allowguest ? "Yes" : "No");
10851 ast_cli(fd, " Allow subscriptions: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_ALLOWSUBSCRIBE) ? "Yes" : "No");
10852 ast_cli(fd, " Allow overlap dialing: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_ALLOWOVERLAP) ? "Yes" : "No");
10853 ast_cli(fd, " Promsic. redir: %s\n", ast_test_flag(&global_flags[0], SIP_PROMISCREDIR) ? "Yes" : "No");
10854 ast_cli(fd, " SIP domain support: %s\n", AST_LIST_EMPTY(&domain_list) ? "No" : "Yes");
10855 ast_cli(fd, " Call to non-local dom.: %s\n", allow_external_domains ? "Yes" : "No");
10856 ast_cli(fd, " URI user is phone no: %s\n", ast_test_flag(&global_flags[0], SIP_USEREQPHONE) ? "Yes" : "No");
10857 ast_cli(fd, " Our auth realm %s\n", global_realm);
10858 ast_cli(fd, " Realm. auth: %s\n", authl ? "Yes": "No");
10859 ast_cli(fd, " Always auth rejects: %s\n", global_alwaysauthreject ? "Yes" : "No");
10860 ast_cli(fd, " Call limit peers only: %s\n", global_limitonpeers ? "Yes" : "No");
10861 ast_cli(fd, " Direct RTP setup: %s\n", global_directrtpsetup ? "Yes" : "No");
10862 ast_cli(fd, " User Agent: %s\n", global_useragent);
10863 ast_cli(fd, " MWI checking interval: %d secs\n", global_mwitime);
10864 ast_cli(fd, " Reg. context: %s\n", S_OR(global_regcontext, "(not set)"));
10865 ast_cli(fd, " Caller ID: %s\n", default_callerid);
10866 ast_cli(fd, " From: Domain: %s\n", default_fromdomain);
10867 ast_cli(fd, " Record SIP history: %s\n", recordhistory ? "On" : "Off");
10868 ast_cli(fd, " Call Events: %s\n", global_callevents ? "On" : "Off");
10869 ast_cli(fd, " IP ToS SIP: %s\n", ast_tos2str(global_tos_sip));
10870 ast_cli(fd, " IP ToS RTP audio: %s\n", ast_tos2str(global_tos_audio));
10871 ast_cli(fd, " IP ToS RTP video: %s\n", ast_tos2str(global_tos_video));
10872 ast_cli(fd, " T38 fax pt UDPTL: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_T38SUPPORT_UDPTL) ? "Yes" : "No");
10873 #ifdef WHEN_WE_HAVE_T38_FOR_OTHER_TRANSPORTS
10874 ast_cli(fd, " T38 fax pt RTP: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_T38SUPPORT_RTP) ? "Yes" : "No");
10875 ast_cli(fd, " T38 fax pt TCP: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_T38SUPPORT_TCP) ? "Yes" : "No");
10876 #endif
10877 ast_cli(fd, " RFC2833 Compensation: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_RFC2833_COMPENSATE) ? "Yes" : "No");
10878 if (!realtimepeers && !realtimeusers)
10879 ast_cli(fd, " SIP realtime: Disabled\n" );
10880 else
10881 ast_cli(fd, " SIP realtime: Enabled\n" );
10882
10883 ast_cli(fd, "\nGlobal Signalling Settings:\n");
10884 ast_cli(fd, "---------------------------\n");
10885 ast_cli(fd, " Codecs: ");
10886 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, global_capability);
10887 ast_cli(fd, "%s\n", codec_buf);
10888 ast_cli(fd, " Codec Order: ");
10889 print_codec_to_cli(fd, &default_prefs);
10890 ast_cli(fd, "\n");
10891 ast_cli(fd, " T1 minimum: %d\n", global_t1min);
10892 ast_cli(fd, " Relax DTMF: %s\n", global_relaxdtmf ? "Yes" : "No");
10893 ast_cli(fd, " Compact SIP headers: %s\n", compactheaders ? "Yes" : "No");
10894 ast_cli(fd, " RTP Keepalive: %d %s\n", global_rtpkeepalive, global_rtpkeepalive ? "" : "(Disabled)" );
10895 ast_cli(fd, " RTP Timeout: %d %s\n", global_rtptimeout, global_rtptimeout ? "" : "(Disabled)" );
10896 ast_cli(fd, " RTP Hold Timeout: %d %s\n", global_rtpholdtimeout, global_rtpholdtimeout ? "" : "(Disabled)");
10897 ast_cli(fd, " MWI NOTIFY mime type: %s\n", default_notifymime);
10898 ast_cli(fd, " DNS SRV lookup: %s\n", srvlookup ? "Yes" : "No");
10899 ast_cli(fd, " Pedantic SIP support: %s\n", pedanticsipchecking ? "Yes" : "No");
10900 ast_cli(fd, " Reg. min duration %d secs\n", min_expiry);
10901 ast_cli(fd, " Reg. max duration: %d secs\n", max_expiry);
10902 ast_cli(fd, " Reg. default duration: %d secs\n", default_expiry);
10903 ast_cli(fd, " Outbound reg. timeout: %d secs\n", global_reg_timeout);
10904 ast_cli(fd, " Outbound reg. attempts: %d\n", global_regattempts_max);
10905 ast_cli(fd, " Notify ringing state: %s\n", global_notifyringing ? "Yes" : "No");
10906 ast_cli(fd, " Notify hold state: %s\n", global_notifyhold ? "Yes" : "No");
10907 ast_cli(fd, " SIP Transfer mode: %s\n", transfermode2str(global_allowtransfer));
10908 ast_cli(fd, " Max Call Bitrate: %d kbps\r\n", default_maxcallbitrate);
10909 ast_cli(fd, " Auto-Framing: %s \r\n", global_autoframing ? "Yes" : "No");
10910 ast_cli(fd, "\nDefault Settings:\n");
10911 ast_cli(fd, "-----------------\n");
10912 ast_cli(fd, " Context: %s\n", default_context);
10913 ast_cli(fd, " Nat: %s\n", nat2str(ast_test_flag(&global_flags[0], SIP_NAT)));
10914 ast_cli(fd, " DTMF: %s\n", dtmfmode2str(ast_test_flag(&global_flags[0], SIP_DTMF)));
10915 ast_cli(fd, " Qualify: %d\n", default_qualify);
10916 ast_cli(fd, " Use ClientCode: %s\n", ast_test_flag(&global_flags[0], SIP_USECLIENTCODE) ? "Yes" : "No");
10917 ast_cli(fd, " Progress inband: %s\n", (ast_test_flag(&global_flags[0], SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER) ? "Never" : (ast_test_flag(&global_flags[0], SIP_PROG_INBAND) == SIP_PROG_INBAND_NO) ? "No" : "Yes" );
10918 ast_cli(fd, " Language: %s\n", S_OR(default_language, "(Defaults to English)"));
10919 ast_cli(fd, " MOH Interpret: %s\n", default_mohinterpret);
10920 ast_cli(fd, " MOH Suggest: %s\n", default_mohsuggest);
10921 ast_cli(fd, " Voice Mail Extension: %s\n", default_vmexten);
10922
10923
10924 if (realtimepeers || realtimeusers) {
10925 ast_cli(fd, "\nRealtime SIP Settings:\n");
10926 ast_cli(fd, "----------------------\n");
10927 ast_cli(fd, " Realtime Peers: %s\n", realtimepeers ? "Yes" : "No");
10928 ast_cli(fd, " Realtime Users: %s\n", realtimeusers ? "Yes" : "No");
10929 ast_cli(fd, " Cache Friends: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS) ? "Yes" : "No");
10930 ast_cli(fd, " Update: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_RTUPDATE) ? "Yes" : "No");
10931 ast_cli(fd, " Ignore Reg. Expire: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_IGNOREREGEXPIRE) ? "Yes" : "No");
10932 ast_cli(fd, " Save sys. name: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_RTSAVE_SYSNAME) ? "Yes" : "No");
10933 ast_cli(fd, " Auto Clear: %d\n", global_rtautoclear);
10934 }
10935 ast_cli(fd, "\n----\n");
10936 return RESULT_SUCCESS;
10937 }
10938
10939
10940 static const char *subscription_type2str(enum subscriptiontype subtype)
10941 {
10942 int i;
10943
10944 for (i = 1; (i < (sizeof(subscription_types) / sizeof(subscription_types[0]))); i++) {
10945 if (subscription_types[i].type == subtype) {
10946 return subscription_types[i].text;
10947 }
10948 }
10949 return subscription_types[0].text;
10950 }
10951
10952
10953 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype)
10954 {
10955 int i;
10956
10957 for (i = 1; (i < (sizeof(subscription_types) / sizeof(subscription_types[0]))); i++) {
10958 if (subscription_types[i].type == subtype) {
10959 return &subscription_types[i];
10960 }
10961 }
10962 return &subscription_types[0];
10963 }
10964
10965
10966 static int sip_show_channels(int fd, int argc, char *argv[])
10967 {
10968 return __sip_show_channels(fd, argc, argv, 0);
10969 }
10970
10971
10972 static int sip_show_subscriptions(int fd, int argc, char *argv[])
10973 {
10974 return __sip_show_channels(fd, argc, argv, 1);
10975 }
10976
10977
10978 static int __sip_show_channels(int fd, int argc, char *argv[], int subscriptions)
10979 {
10980 #define FORMAT3L "%-15.15s %-10.10s %-11.11s %-15.15s %-13.13s %-15.15s %-10.10s %6d\n"
10981 #define FORMAT3H "%-15.15s %-10.10s %-11.11s %-15.15s %-13.13s %-15.15s %-10.10s %-6s\n"
10982 #define FORMAT2 "%-15.15s %-10.10s %-11.11s %-11.11s %-15.15s %-7.7s %-15.15s\n"
10983 #define FORMAT "%-15.15s %-10.10s %-11.11s %5.5d/%5.5d %-15.15s %-3.3s %-3.3s %-15.15s %-10.10s\n"
10984 struct sip_pvt *cur;
10985 int numchans = 0;
10986 char *referstatus = NULL;
10987
10988 if (argc != 3)
10989 return RESULT_SHOWUSAGE;
10990 ast_mutex_lock(&iflock);
10991 cur = iflist;
10992 if (!subscriptions)
10993 ast_cli(fd, FORMAT2, "Peer", "User/ANR", "Call ID", "Seq (Tx/Rx)", "Format", "Hold", "Last Message");
10994 else
10995 ast_cli(fd, FORMAT3H, "Peer", "User", "Call ID", "Extension", "Last state", "Type", "Mailbox", "Expiry");
10996 for (; cur; cur = cur->next) {
10997 referstatus = "";
10998 if (cur->refer) {
10999 referstatus = referstatus2str(cur->refer->status);
11000 }
11001 if (cur->subscribed == NONE && !subscriptions) {
11002 char formatbuf[SIPBUFSIZE/2];
11003 ast_cli(fd, FORMAT, ast_inet_ntoa(cur->sa.sin_addr),
11004 S_OR(cur->username, S_OR(cur->cid_num, "(None)")),
11005 cur->callid,
11006 cur->ocseq, cur->icseq,
11007 ast_getformatname_multiple(formatbuf, sizeof(formatbuf), cur->owner ? cur->owner->nativeformats : 0),
11008 ast_test_flag(&cur->flags[1], SIP_PAGE2_CALL_ONHOLD) ? "Yes" : "No",
11009 ast_test_flag(&cur->flags[0], SIP_NEEDDESTROY) ? "(d)" : "",
11010 cur->lastmsg ,
11011 referstatus
11012 );
11013 numchans++;
11014 }
11015 if (cur->subscribed != NONE && subscriptions) {
11016 ast_cli(fd, FORMAT3L, ast_inet_ntoa(cur->sa.sin_addr),
11017 S_OR(cur->username, S_OR(cur->cid_num, "(None)")),
11018 cur->callid,
11019
11020 cur->subscribed == MWI_NOTIFICATION ? "--" : cur->subscribeuri,
11021 cur->subscribed == MWI_NOTIFICATION ? "<none>" : ast_extension_state2str(cur->laststate),
11022 subscription_type2str(cur->subscribed),
11023 cur->subscribed == MWI_NOTIFICATION ? (cur->relatedpeer ? cur->relatedpeer->mailbox : "<none>") : "<none>",
11024 cur->expiry
11025 );
11026 numchans++;
11027 }
11028 }
11029 ast_mutex_unlock(&iflock);
11030 if (!subscriptions)
11031 ast_cli(fd, "%d active SIP channel%s\n", numchans, (numchans != 1) ? "s" : "");
11032 else
11033 ast_cli(fd, "%d active SIP subscription%s\n", numchans, (numchans != 1) ? "s" : "");
11034 return RESULT_SUCCESS;
11035 #undef FORMAT
11036 #undef FORMAT2
11037 #undef FORMAT3
11038 }
11039
11040
11041 static char *complete_sipch(const char *line, const char *word, int pos, int state)
11042 {
11043 int which=0;
11044 struct sip_pvt *cur;
11045 char *c = NULL;
11046 int wordlen = strlen(word);
11047
11048 if (pos != 3) {
11049 return NULL;
11050 }
11051
11052 ast_mutex_lock(&iflock);
11053 for (cur = iflist; cur; cur = cur->next) {
11054 if (!strncasecmp(word, cur->callid, wordlen) && ++which > state) {
11055 c = ast_strdup(cur->callid);
11056 break;
11057 }
11058 }
11059 ast_mutex_unlock(&iflock);
11060 return c;
11061 }
11062
11063
11064 static char *complete_sip_peer(const char *word, int state, int flags2)
11065 {
11066 char *result = NULL;
11067 int wordlen = strlen(word);
11068 int which = 0;
11069
11070 ASTOBJ_CONTAINER_TRAVERSE(&peerl, !result, do {
11071
11072 if (!strncasecmp(word, iterator->name, wordlen) &&
11073 (!flags2 || ast_test_flag(&iterator->flags[1], flags2)) &&
11074 ++which > state)
11075 result = ast_strdup(iterator->name);
11076 } while(0) );
11077 return result;
11078 }
11079
11080
11081 static char *complete_sip_show_peer(const char *line, const char *word, int pos, int state)
11082 {
11083 if (pos == 3)
11084 return complete_sip_peer(word, state, 0);
11085
11086 return NULL;
11087 }
11088
11089
11090 static char *complete_sip_debug_peer(const char *line, const char *word, int pos, int state)
11091 {
11092 if (pos == 3)
11093 return complete_sip_peer(word, state, 0);
11094
11095 return NULL;
11096 }
11097
11098
11099 static char *complete_sip_user(const char *word, int state, int flags2)
11100 {
11101 char *result = NULL;
11102 int wordlen = strlen(word);
11103 int which = 0;
11104
11105 ASTOBJ_CONTAINER_TRAVERSE(&userl, !result, do {
11106
11107 if (!strncasecmp(word, iterator->name, wordlen)) {
11108 if (flags2 && !ast_test_flag(&iterator->flags[1], flags2))
11109 continue;
11110 if (++which > state) {
11111 result = ast_strdup(iterator->name);
11112 }
11113 }
11114 } while(0) );
11115 return result;
11116 }
11117
11118
11119 static char *complete_sip_show_user(const char *line, const char *word, int pos, int state)
11120 {
11121 if (pos == 3)
11122 return complete_sip_user(word, state, 0);
11123
11124 return NULL;
11125 }
11126
11127
11128 static char *complete_sipnotify(const char *line, const char *word, int pos, int state)
11129 {
11130 char *c = NULL;
11131
11132 if (pos == 2) {
11133 int which = 0;
11134 char *cat = NULL;
11135 int wordlen = strlen(word);
11136
11137
11138
11139 if (!notify_types)
11140 return NULL;
11141
11142 while ( (cat = ast_category_browse(notify_types, cat)) ) {
11143 if (!strncasecmp(word, cat, wordlen) && ++which > state) {
11144 c = ast_strdup(cat);
11145 break;
11146 }
11147 }
11148 return c;
11149 }
11150
11151 if (pos > 2)
11152 return complete_sip_peer(word, state, 0);
11153
11154 return NULL;
11155 }
11156
11157
11158 static char *complete_sip_prune_realtime_peer(const char *line, const char *word, int pos, int state)
11159 {
11160 if (pos == 4)
11161 return complete_sip_peer(word, state, SIP_PAGE2_RTCACHEFRIENDS);
11162 return NULL;
11163 }
11164
11165
11166 static char *complete_sip_prune_realtime_user(const char *line, const char *word, int pos, int state)
11167 {
11168 if (pos == 4)
11169 return complete_sip_user(word, state, SIP_PAGE2_RTCACHEFRIENDS);
11170
11171 return NULL;
11172 }
11173
11174
11175 static int sip_show_channel(int fd, int argc, char *argv[])
11176 {
11177 struct sip_pvt *cur;
11178 size_t len;
11179 int found = 0;
11180
11181 if (argc != 4)
11182 return RESULT_SHOWUSAGE;
11183 len = strlen(argv[3]);
11184 ast_mutex_lock(&iflock);
11185 for (cur = iflist; cur; cur = cur->next) {
11186 if (!strncasecmp(cur->callid, argv[3], len)) {
11187 char formatbuf[SIPBUFSIZE/2];
11188 ast_cli(fd,"\n");
11189 if (cur->subscribed != NONE)
11190 ast_cli(fd, " * Subscription (type: %s)\n", subscription_type2str(cur->subscribed));
11191 else
11192 ast_cli(fd, " * SIP Call\n");
11193 ast_cli(fd, " Curr. trans. direction: %s\n", ast_test_flag(&cur->flags[0], SIP_OUTGOING) ? "Outgoing" : "Incoming");
11194 ast_cli(fd, " Call-ID: %s\n", cur->callid);
11195 ast_cli(fd, " Owner channel ID: %s\n", cur->owner ? cur->owner->name : "<none>");
11196 ast_cli(fd, " Our Codec Capability: %d\n", cur->capability);
11197 ast_cli(fd, " Non-Codec Capability (DTMF): %d\n", cur->noncodeccapability);
11198 ast_cli(fd, " Their Codec Capability: %d\n", cur->peercapability);
11199 ast_cli(fd, " Joint Codec Capability: %d\n", cur->jointcapability);
11200 ast_cli(fd, " Format: %s\n", ast_getformatname_multiple(formatbuf, sizeof(formatbuf), cur->owner ? cur->owner->nativeformats : 0) );
11201 ast_cli(fd, " MaxCallBR: %d kbps\n", cur->maxcallbitrate);
11202 ast_cli(fd, " Theoretical Address: %s:%d\n", ast_inet_ntoa(cur->sa.sin_addr), ntohs(cur->sa.sin_port));
11203 ast_cli(fd, " Received Address: %s:%d\n", ast_inet_ntoa(cur->recv.sin_addr), ntohs(cur->recv.sin_port));
11204 ast_cli(fd, " SIP Transfer mode: %s\n", transfermode2str(cur->allowtransfer));
11205 ast_cli(fd, " NAT Support: %s\n", nat2str(ast_test_flag(&cur->flags[0], SIP_NAT)));
11206 ast_cli(fd, " Audio IP: %s %s\n", ast_inet_ntoa(cur->redirip.sin_addr.s_addr ? cur->redirip.sin_addr : cur->ourip), cur->redirip.sin_addr.s_addr ? "(Outside bridge)" : "(local)" );
11207 ast_cli(fd, " Our Tag: %s\n", cur->tag);
11208 ast_cli(fd, " Their Tag: %s\n", cur->theirtag);
11209 ast_cli(fd, " SIP User agent: %s\n", cur->useragent);
11210 if (!ast_strlen_zero(cur->username))
11211 ast_cli(fd, " Username: %s\n", cur->username);
11212 if (!ast_strlen_zero(cur->peername))
11213 ast_cli(fd, " Peername: %s\n", cur->peername);
11214 if (!ast_strlen_zero(cur->uri))
11215 ast_cli(fd, " Original uri: %s\n", cur->uri);
11216 if (!ast_strlen_zero(cur->cid_num))
11217 ast_cli(fd, " Caller-ID: %s\n", cur->cid_num);
11218 ast_cli(fd, " Need Destroy: %d\n", ast_test_flag(&cur->flags[0], SIP_NEEDDESTROY));
11219 ast_cli(fd, " Last Message: %s\n", cur->lastmsg);
11220 ast_cli(fd, " Promiscuous Redir: %s\n", ast_test_flag(&cur->flags[0], SIP_PROMISCREDIR) ? "Yes" : "No");
11221 ast_cli(fd, " Route: %s\n", cur->route ? cur->route->hop : "N/A");
11222 ast_cli(fd, " DTMF Mode: %s\n", dtmfmode2str(ast_test_flag(&cur->flags[0], SIP_DTMF)));
11223 ast_cli(fd, " SIP Options: ");
11224 if (cur->sipoptions) {
11225 int x;
11226 for (x=0 ; (x < (sizeof(sip_options) / sizeof(sip_options[0]))); x++) {
11227 if (cur->sipoptions & sip_options[x].id)
11228 ast_cli(fd, "%s ", sip_options[x].text);
11229 }
11230 } else
11231 ast_cli(fd, "(none)\n");
11232 ast_cli(fd, "\n\n");
11233 found++;
11234 }
11235 }
11236 ast_mutex_unlock(&iflock);
11237 if (!found)
11238 ast_cli(fd, "No such SIP Call ID starting with '%s'\n", argv[3]);
11239 return RESULT_SUCCESS;
11240 }
11241
11242
11243 static int sip_show_history(int fd, int argc, char *argv[])
11244 {
11245 struct sip_pvt *cur;
11246 size_t len;
11247 int found = 0;
11248
11249 if (argc != 4)
11250 return RESULT_SHOWUSAGE;
11251 if (!recordhistory)
11252 ast_cli(fd, "\n***Note: History recording is currently DISABLED. Use 'sip history' to ENABLE.\n");
11253 len = strlen(argv[3]);
11254 ast_mutex_lock(&iflock);
11255 for (cur = iflist; cur; cur = cur->next) {
11256 if (!strncasecmp(cur->callid, argv[3], len)) {
11257 struct sip_history *hist;
11258 int x = 0;
11259
11260 ast_cli(fd,"\n");
11261 if (cur->subscribed != NONE)
11262 ast_cli(fd, " * Subscription\n");
11263 else
11264 ast_cli(fd, " * SIP Call\n");
11265 if (cur->history)
11266 AST_LIST_TRAVERSE(cur->history, hist, list)
11267 ast_cli(fd, "%d. %s\n", ++x, hist->event);
11268 if (x == 0)
11269 ast_cli(fd, "Call '%s' has no history\n", cur->callid);
11270 found++;
11271 }
11272 }
11273 ast_mutex_unlock(&iflock);
11274 if (!found)
11275 ast_cli(fd, "No such SIP Call ID starting with '%s'\n", argv[3]);
11276 return RESULT_SUCCESS;
11277 }
11278
11279
11280 static void sip_dump_history(struct sip_pvt *dialog)
11281 {
11282 int x = 0;
11283 struct sip_history *hist;
11284 static int errmsg = 0;
11285
11286 if (!dialog)
11287 return;
11288
11289 if (!option_debug && !sipdebug) {
11290 if (!errmsg) {
11291 ast_log(LOG_NOTICE, "You must have debugging enabled (SIP or Asterisk) in order to dump SIP history.\n");
11292 errmsg = 1;
11293 }
11294 return;
11295 }
11296
11297 ast_log(LOG_DEBUG, "\n---------- SIP HISTORY for '%s' \n", dialog->callid);
11298 if (dialog->subscribed)
11299 ast_log(LOG_DEBUG, " * Subscription\n");
11300 else
11301 ast_log(LOG_DEBUG, " * SIP Call\n");
11302 if (dialog->history)
11303 AST_LIST_TRAVERSE(dialog->history, hist, list)
11304 ast_log(LOG_DEBUG, " %-3.3d. %s\n", ++x, hist->event);
11305 if (!x)
11306 ast_log(LOG_DEBUG, "Call '%s' has no history\n", dialog->callid);
11307 ast_log(LOG_DEBUG, "\n---------- END SIP HISTORY for '%s' \n", dialog->callid);
11308 }
11309
11310
11311
11312
11313 static void handle_request_info(struct sip_pvt *p, struct sip_request *req)
11314 {
11315 char buf[1024];
11316 unsigned int event;
11317 const char *c = get_header(req, "Content-Type");
11318
11319
11320 if (!strcasecmp(c, "application/dtmf-relay") ||
11321 !strcasecmp(c, "application/DTMF") ||
11322 !strcasecmp(c, "application/vnd.nortelnetworks.digits")) {
11323 unsigned int duration = 0;
11324
11325
11326 if (ast_strlen_zero(c = get_body(req, "Signal")) && ast_strlen_zero(c = get_body(req, "d"))) {
11327 ast_log(LOG_WARNING, "Unable to retrieve DTMF signal from INFO message from %s\n", p->callid);
11328 transmit_response(p, "200 OK", req);
11329 return;
11330 } else {
11331 ast_copy_string(buf, c, sizeof(buf));
11332 }
11333
11334 if (!ast_strlen_zero((c = get_body(req, "Duration"))))
11335 duration = atoi(c);
11336 if (!duration)
11337 duration = 100;
11338
11339 if (!p->owner) {
11340 transmit_response(p, "481 Call leg/transaction does not exist", req);
11341 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
11342 return;
11343 }
11344
11345 if (ast_strlen_zero(buf)) {
11346 transmit_response(p, "200 OK", req);
11347 return;
11348 }
11349
11350 if (buf[0] == '*')
11351 event = 10;
11352 else if (buf[0] == '#')
11353 event = 11;
11354 else if ((buf[0] >= 'A') && (buf[0] <= 'D'))
11355 event = 12 + buf[0] - 'A';
11356 else
11357 event = atoi(buf);
11358 if (event == 16) {
11359
11360 struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_FLASH, };
11361 ast_queue_frame(p->owner, &f);
11362 if (sipdebug)
11363 ast_verbose("* DTMF-relay event received: FLASH\n");
11364 } else {
11365
11366 struct ast_frame f = { AST_FRAME_DTMF, };
11367 if (event < 10) {
11368 f.subclass = '0' + event;
11369 } else if (event < 11) {
11370 f.subclass = '*';
11371 } else if (event < 12) {
11372 f.subclass = '#';
11373 } else if (event < 16) {
11374 f.subclass = 'A' + (event - 12);
11375 }
11376 f.len = duration;
11377 ast_queue_frame(p->owner, &f);
11378 if (sipdebug)
11379 ast_verbose("* DTMF-relay event received: %c\n", f.subclass);
11380 }
11381 transmit_response(p, "200 OK", req);
11382 return;
11383 } else if (!strcasecmp(c, "application/media_control+xml")) {
11384
11385 if (p->owner)
11386 ast_queue_control(p->owner, AST_CONTROL_VIDUPDATE);
11387 transmit_response(p, "200 OK", req);
11388 return;
11389 } else if (!ast_strlen_zero(c = get_header(req, "X-ClientCode"))) {
11390
11391 if (ast_test_flag(&p->flags[0], SIP_USECLIENTCODE)) {
11392 if (p->owner && p->owner->cdr)
11393 ast_cdr_setuserfield(p->owner, c);
11394 if (p->owner && ast_bridged_channel(p->owner) && ast_bridged_channel(p->owner)->cdr)
11395 ast_cdr_setuserfield(ast_bridged_channel(p->owner), c);
11396 transmit_response(p, "200 OK", req);
11397 } else {
11398 transmit_response(p, "403 Unauthorized", req);
11399 }
11400 return;
11401 } else if (ast_strlen_zero(c = get_header(req, "Content-Length")) || !strcasecmp(c, "0")) {
11402
11403 transmit_response(p, "200 OK", req);
11404 return;
11405 }
11406
11407
11408
11409
11410
11411 if (!strcasecmp(get_header(req, "Content-Length"), "0")) {
11412 transmit_response(p, "200 OK", req);
11413 return;
11414 }
11415
11416 ast_log(LOG_WARNING, "Unable to parse INFO message from %s. Content %s\n", p->callid, buf);
11417 transmit_response(p, "415 Unsupported media type", req);
11418 return;
11419 }
11420
11421
11422 static int sip_do_debug_ip(int fd, int argc, char *argv[])
11423 {
11424 struct hostent *hp;
11425 struct ast_hostent ahp;
11426 int port = 0;
11427 char *p, *arg;
11428
11429
11430 if (argc != 5)
11431 return RESULT_SHOWUSAGE;
11432 p = arg = argv[4];
11433 strsep(&p, ":");
11434 if (p)
11435 port = atoi(p);
11436 hp = ast_gethostbyname(arg, &ahp);
11437 if (hp == NULL)
11438 return RESULT_SHOWUSAGE;
11439
11440 debugaddr.sin_family = AF_INET;
11441 memcpy(&debugaddr.sin_addr, hp->h_addr, sizeof(debugaddr.sin_addr));
11442 debugaddr.sin_port = htons(port);
11443 if (port == 0)
11444 ast_cli(fd, "SIP Debugging Enabled for IP: %s\n", ast_inet_ntoa(debugaddr.sin_addr));
11445 else
11446 ast_cli(fd, "SIP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(debugaddr.sin_addr), port);
11447
11448 ast_set_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
11449
11450 return RESULT_SUCCESS;
11451 }
11452
11453
11454 static int sip_do_debug_peer(int fd, int argc, char *argv[])
11455 {
11456 struct sip_peer *peer;
11457 if (argc != 5)
11458 return RESULT_SHOWUSAGE;
11459 peer = find_peer(argv[4], NULL, 1, 0);
11460 if (peer) {
11461 if (peer->addr.sin_addr.s_addr) {
11462 debugaddr.sin_family = AF_INET;
11463 debugaddr.sin_addr = peer->addr.sin_addr;
11464 debugaddr.sin_port = peer->addr.sin_port;
11465 ast_cli(fd, "SIP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(debugaddr.sin_addr), ntohs(debugaddr.sin_port));
11466 ast_set_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
11467 } else
11468 ast_cli(fd, "Unable to get IP address of peer '%s'\n", argv[4]);
11469 ASTOBJ_UNREF(peer,sip_destroy_peer);
11470 } else
11471 ast_cli(fd, "No such peer '%s'\n", argv[4]);
11472 return RESULT_SUCCESS;
11473 }
11474
11475
11476 static int sip_do_debug(int fd, int argc, char *argv[])
11477 {
11478 int oldsipdebug = sipdebug_console;
11479 if (argc != 3) {
11480 if (argc != 5)
11481 return RESULT_SHOWUSAGE;
11482 else if (strcmp(argv[3], "ip") == 0)
11483 return sip_do_debug_ip(fd, argc, argv);
11484 else if (strcmp(argv[3], "peer") == 0)
11485 return sip_do_debug_peer(fd, argc, argv);
11486 else
11487 return RESULT_SHOWUSAGE;
11488 }
11489 ast_set_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
11490 memset(&debugaddr, 0, sizeof(debugaddr));
11491 ast_cli(fd, "SIP Debugging %senabled\n", oldsipdebug ? "re-" : "");
11492 return RESULT_SUCCESS;
11493 }
11494
11495 static int sip_do_debug_deprecated(int fd, int argc, char *argv[])
11496 {
11497 int oldsipdebug = sipdebug_console;
11498 char *newargv[6] = { "sip", "set", "debug", NULL };
11499 if (argc != 2) {
11500 if (argc != 4)
11501 return RESULT_SHOWUSAGE;
11502 else if (strcmp(argv[2], "ip") == 0) {
11503 newargv[3] = argv[2];
11504 newargv[4] = argv[3];
11505 return sip_do_debug_ip(fd, argc + 1, newargv);
11506 } else if (strcmp(argv[2], "peer") == 0) {
11507 newargv[3] = argv[2];
11508 newargv[4] = argv[3];
11509 return sip_do_debug_peer(fd, argc + 1, newargv);
11510 } else
11511 return RESULT_SHOWUSAGE;
11512 }
11513 ast_set_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
11514 memset(&debugaddr, 0, sizeof(debugaddr));
11515 ast_cli(fd, "SIP Debugging %senabled\n", oldsipdebug ? "re-" : "");
11516 return RESULT_SUCCESS;
11517 }
11518
11519
11520 static int sip_notify(int fd, int argc, char *argv[])
11521 {
11522 struct ast_variable *varlist;
11523 int i;
11524
11525 if (argc < 4)
11526 return RESULT_SHOWUSAGE;
11527
11528 if (!notify_types) {
11529 ast_cli(fd, "No %s file found, or no types listed there\n", notify_config);
11530 return RESULT_FAILURE;
11531 }
11532
11533 varlist = ast_variable_browse(notify_types, argv[2]);
11534
11535 if (!varlist) {
11536 ast_cli(fd, "Unable to find notify type '%s'\n", argv[2]);
11537 return RESULT_FAILURE;
11538 }
11539
11540 for (i = 3; i < argc; i++) {
11541 struct sip_pvt *p;
11542 struct sip_request req;
11543 struct ast_variable *var;
11544
11545 if (!(p = sip_alloc(NULL, NULL, 0, SIP_NOTIFY))) {
11546 ast_log(LOG_WARNING, "Unable to build sip pvt data for notify (memory/socket error)\n");
11547 return RESULT_FAILURE;
11548 }
11549
11550 if (create_addr(p, argv[i])) {
11551
11552 sip_destroy(p);
11553 ast_cli(fd, "Could not create address for '%s'\n", argv[i]);
11554 continue;
11555 }
11556
11557 initreqprep(&req, p, SIP_NOTIFY);
11558
11559 for (var = varlist; var; var = var->next)
11560 add_header(&req, var->name, ast_unescape_semicolon(var->value));
11561
11562
11563 if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
11564 p->ourip = __ourip;
11565 build_via(p);
11566 build_callid_pvt(p);
11567 ast_cli(fd, "Sending NOTIFY of type '%s' to '%s'\n", argv[2], argv[i]);
11568 transmit_sip_request(p, &req);
11569 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
11570 }
11571
11572 return RESULT_SUCCESS;
11573 }
11574
11575
11576 static int sip_no_debug(int fd, int argc, char *argv[])
11577 {
11578 if (argc != 4)
11579 return RESULT_SHOWUSAGE;
11580 ast_clear_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
11581 ast_cli(fd, "SIP Debugging Disabled\n");
11582 return RESULT_SUCCESS;
11583 }
11584
11585 static int sip_no_debug_deprecated(int fd, int argc, char *argv[])
11586 {
11587 if (argc != 3)
11588 return RESULT_SHOWUSAGE;
11589 ast_clear_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
11590 ast_cli(fd, "SIP Debugging Disabled\n");
11591 return RESULT_SUCCESS;
11592 }
11593
11594
11595 static int sip_do_history(int fd, int argc, char *argv[])
11596 {
11597 if (argc != 2) {
11598 return RESULT_SHOWUSAGE;
11599 }
11600 recordhistory = TRUE;
11601 ast_cli(fd, "SIP History Recording Enabled (use 'sip show history')\n");
11602 return RESULT_SUCCESS;
11603 }
11604
11605
11606 static int sip_no_history(int fd, int argc, char *argv[])
11607 {
11608 if (argc != 3) {
11609 return RESULT_SHOWUSAGE;
11610 }
11611 recordhistory = FALSE;
11612 ast_cli(fd, "SIP History Recording Disabled\n");
11613 return RESULT_SUCCESS;
11614 }
11615
11616
11617 static int do_register_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader)
11618 {
11619 char digest[1024];
11620 p->authtries++;
11621 memset(digest,0,sizeof(digest));
11622 if (reply_digest(p, req, header, SIP_REGISTER, digest, sizeof(digest))) {
11623
11624
11625 if (sip_debug_test_pvt(p) && p->registry)
11626 ast_verbose("No authentication challenge, sending blank registration to domain/host name %s\n", p->registry->hostname);
11627
11628 return -1;
11629 }
11630 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
11631 append_history(p, "RegistryAuth", "Try: %d", p->authtries);
11632 if (sip_debug_test_pvt(p) && p->registry)
11633 ast_verbose("Responding to challenge, registration to domain/host name %s\n", p->registry->hostname);
11634 return transmit_register(p->registry, SIP_REGISTER, digest, respheader);
11635 }
11636
11637
11638 static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader, int sipmethod, int init)
11639 {
11640 char digest[1024];
11641
11642 if (!p->options && !(p->options = ast_calloc(1, sizeof(*p->options))))
11643 return -2;
11644
11645 p->authtries++;
11646 if (option_debug > 1)
11647 ast_log(LOG_DEBUG, "Auth attempt %d on %s\n", p->authtries, sip_methods[sipmethod].text);
11648 memset(digest, 0, sizeof(digest));
11649 if (reply_digest(p, req, header, sipmethod, digest, sizeof(digest) )) {
11650
11651 return -1;
11652 }
11653
11654 p->options->auth = digest;
11655 p->options->authheader = respheader;
11656 return transmit_invite(p, sipmethod, sipmethod == SIP_INVITE, init);
11657 }
11658
11659
11660
11661
11662
11663 static int reply_digest(struct sip_pvt *p, struct sip_request *req, char *header, int sipmethod, char *digest, int digest_len)
11664 {
11665 char tmp[512];
11666 char *c;
11667 char oldnonce[256];
11668
11669
11670 const struct x {
11671 const char *key;
11672 int field_index;
11673 } *i, keys[] = {
11674 { "realm=", ast_string_field_index(p, realm) },
11675 { "nonce=", ast_string_field_index(p, nonce) },
11676 { "opaque=", ast_string_field_index(p, opaque) },
11677 { "qop=", ast_string_field_index(p, qop) },
11678 { "domain=", ast_string_field_index(p, domain) },
11679 { NULL, 0 },
11680 };
11681
11682 ast_copy_string(tmp, get_header(req, header), sizeof(tmp));
11683 if (ast_strlen_zero(tmp))
11684 return -1;
11685 if (strncasecmp(tmp, "Digest ", strlen("Digest "))) {
11686 ast_log(LOG_WARNING, "missing Digest.\n");
11687 return -1;
11688 }
11689 c = tmp + strlen("Digest ");
11690 ast_copy_string(oldnonce, p->nonce, sizeof(oldnonce));
11691 while (c && *(c = ast_skip_blanks(c))) {
11692 for (i = keys; i->key != NULL; i++) {
11693 char *src, *separator;
11694 if (strncasecmp(c, i->key, strlen(i->key)) != 0)
11695 continue;
11696
11697 c += strlen(i->key);
11698 if (*c == '"') {
11699 src = ++c;
11700 separator = "\"";
11701 } else {
11702 src = c;
11703 separator = ",";
11704 }
11705 strsep(&c, separator);
11706 ast_string_field_index_set(p, i->field_index, src);
11707 break;
11708 }
11709 if (i->key == NULL)
11710 strsep(&c, ",");
11711 }
11712
11713 if (strcmp(p->nonce, oldnonce))
11714 p->noncecount = 0;
11715
11716
11717 if (p->registry) {
11718 struct sip_registry *r = p->registry;
11719
11720 if (strcmp(r->nonce, p->nonce)) {
11721 ast_string_field_set(r, realm, p->realm);
11722 ast_string_field_set(r, nonce, p->nonce);
11723 ast_string_field_set(r, domain, p->domain);
11724 ast_string_field_set(r, opaque, p->opaque);
11725 ast_string_field_set(r, qop, p->qop);
11726 r->noncecount = 0;
11727 }
11728 }
11729 return build_reply_digest(p, sipmethod, digest, digest_len);
11730 }
11731
11732
11733
11734
11735
11736
11737 static int build_reply_digest(struct sip_pvt *p, int method, char* digest, int digest_len)
11738 {
11739 char a1[256];
11740 char a2[256];
11741 char a1_hash[256];
11742 char a2_hash[256];
11743 char resp[256];
11744 char resp_hash[256];
11745 char uri[256];
11746 char opaque[256] = "";
11747 char cnonce[80];
11748 const char *username;
11749 const char *secret;
11750 const char *md5secret;
11751 struct sip_auth *auth = NULL;
11752
11753 if (!ast_strlen_zero(p->domain))
11754 ast_copy_string(uri, p->domain, sizeof(uri));
11755 else if (!ast_strlen_zero(p->uri))
11756 ast_copy_string(uri, p->uri, sizeof(uri));
11757 else
11758 snprintf(uri, sizeof(uri), "sip:%s@%s",p->username, ast_inet_ntoa(p->sa.sin_addr));
11759
11760 snprintf(cnonce, sizeof(cnonce), "%08lx", ast_random());
11761
11762
11763 if(!(auth = find_realm_authentication(p->peerauth, p->realm)))
11764 auth = find_realm_authentication(authl, p->realm);
11765
11766 if (auth) {
11767 ast_log(LOG_DEBUG, "use realm [%s] from peer [%s][%s]\n", auth->username, p->peername, p->username);
11768 username = auth->username;
11769 secret = auth->secret;
11770 md5secret = auth->md5secret;
11771 if (sipdebug)
11772 ast_log(LOG_DEBUG,"Using realm %s authentication for call %s\n", p->realm, p->callid);
11773 } else {
11774
11775 username = p->authname;
11776 secret = p->peersecret;
11777 md5secret = p->peermd5secret;
11778 }
11779 if (ast_strlen_zero(username))
11780 return -1;
11781
11782
11783 snprintf(a1,sizeof(a1),"%s:%s:%s", username, p->realm, secret);
11784 snprintf(a2,sizeof(a2),"%s:%s", sip_methods[method].text, uri);
11785 if (!ast_strlen_zero(md5secret))
11786 ast_copy_string(a1_hash, md5secret, sizeof(a1_hash));
11787 else
11788 ast_md5_hash(a1_hash,a1);
11789 ast_md5_hash(a2_hash,a2);
11790
11791 p->noncecount++;
11792 if (!ast_strlen_zero(p->qop))
11793 snprintf(resp,sizeof(resp),"%s:%s:%08x:%s:%s:%s", a1_hash, p->nonce, p->noncecount, cnonce, "auth", a2_hash);
11794 else
11795 snprintf(resp,sizeof(resp),"%s:%s:%s", a1_hash, p->nonce, a2_hash);
11796 ast_md5_hash(resp_hash, resp);
11797
11798
11799 if (!ast_strlen_zero(p->opaque)) {
11800 snprintf(opaque, sizeof(opaque), ", opaque=\"%s\"", p->opaque);
11801 }
11802
11803
11804 if (!ast_strlen_zero(p->qop))
11805 snprintf(digest, digest_len, "Digest username=\"%s\", realm=\"%s\", algorithm=MD5, uri=\"%s\", nonce=\"%s\", response=\"%s\"%s, qop=auth, cnonce=\"%s\", nc=%08x", username, p->realm, uri, p->nonce, resp_hash, opaque, cnonce, p->noncecount);
11806 else
11807 snprintf(digest, digest_len, "Digest username=\"%s\", realm=\"%s\", algorithm=MD5, uri=\"%s\", nonce=\"%s\", response=\"%s\"%s", username, p->realm, uri, p->nonce, resp_hash, opaque);
11808
11809 append_history(p, "AuthResp", "Auth response sent for %s in realm %s - nc %d", username, p->realm, p->noncecount);
11810
11811 return 0;
11812 }
11813
11814 static char show_domains_usage[] =
11815 "Usage: sip show domains\n"
11816 " Lists all configured SIP local domains.\n"
11817 " Asterisk only responds to SIP messages to local domains.\n";
11818
11819 static char notify_usage[] =
11820 "Usage: sip notify <type> <peer> [<peer>...]\n"
11821 " Send a NOTIFY message to a SIP peer or peers\n"
11822 " Message types are defined in sip_notify.conf\n";
11823
11824 static char show_users_usage[] =
11825 "Usage: sip show users [like <pattern>]\n"
11826 " Lists all known SIP users.\n"
11827 " Optional regular expression pattern is used to filter the user list.\n";
11828
11829 static char show_user_usage[] =
11830 "Usage: sip show user <name> [load]\n"
11831 " Shows all details on one SIP user and the current status.\n"
11832 " Option \"load\" forces lookup of peer in realtime storage.\n";
11833
11834 static char show_inuse_usage[] =
11835 "Usage: sip show inuse [all]\n"
11836 " List all SIP users and peers usage counters and limits.\n"
11837 " Add option \"all\" to show all devices, not only those with a limit.\n";
11838
11839 static char show_channels_usage[] =
11840 "Usage: sip show channels\n"
11841 " Lists all currently active SIP channels.\n";
11842
11843 static char show_channel_usage[] =
11844 "Usage: sip show channel <channel>\n"
11845 " Provides detailed status on a given SIP channel.\n";
11846
11847 static char show_history_usage[] =
11848 "Usage: sip show history <channel>\n"
11849 " Provides detailed dialog history on a given SIP channel.\n";
11850
11851 static char show_peers_usage[] =
11852 "Usage: sip show peers [like <pattern>]\n"
11853 " Lists all known SIP peers.\n"
11854 " Optional regular expression pattern is used to filter the peer list.\n";
11855
11856 static char show_peer_usage[] =
11857 "Usage: sip show peer <name> [load]\n"
11858 " Shows all details on one SIP peer and the current status.\n"
11859 " Option \"load\" forces lookup of peer in realtime storage.\n";
11860
11861 static char prune_realtime_usage[] =
11862 "Usage: sip prune realtime [peer|user] [<name>|all|like <pattern>]\n"
11863 " Prunes object(s) from the cache.\n"
11864 " Optional regular expression pattern is used to filter the objects.\n";
11865
11866 static char show_reg_usage[] =
11867 "Usage: sip show registry\n"
11868 " Lists all registration requests and status.\n";
11869
11870 static char debug_usage[] =
11871 "Usage: sip set debug\n"
11872 " Enables dumping of SIP packets for debugging purposes\n\n"
11873 " sip set debug ip <host[:PORT]>\n"
11874 " Enables dumping of SIP packets to and from host.\n\n"
11875 " sip set debug peer <peername>\n"
11876 " Enables dumping of SIP packets to and from host.\n"
11877 " Require peer to be registered.\n";
11878
11879 static char no_debug_usage[] =
11880 "Usage: sip set debug off\n"
11881 " Disables dumping of SIP packets for debugging purposes\n";
11882
11883 static char no_history_usage[] =
11884 "Usage: sip history off\n"
11885 " Disables recording of SIP dialog history for debugging purposes\n";
11886
11887 static char history_usage[] =
11888 "Usage: sip history\n"
11889 " Enables recording of SIP dialog history for debugging purposes.\n"
11890 "Use 'sip show history' to view the history of a call number.\n";
11891
11892 static char sip_reload_usage[] =
11893 "Usage: sip reload\n"
11894 " Reloads SIP configuration from sip.conf\n";
11895
11896 static char show_subscriptions_usage[] =
11897 "Usage: sip show subscriptions\n"
11898 " Lists active SIP subscriptions for extension states\n";
11899
11900 static char show_objects_usage[] =
11901 "Usage: sip show objects\n"
11902 " Lists status of known SIP objects\n";
11903
11904 static char show_settings_usage[] =
11905 "Usage: sip show settings\n"
11906 " Provides detailed list of the configuration of the SIP channel.\n";
11907
11908
11909 static int func_header_read(struct ast_channel *chan, char *function, char *data, char *buf, size_t len)
11910 {
11911 struct sip_pvt *p;
11912 const char *content = NULL;
11913 AST_DECLARE_APP_ARGS(args,
11914 AST_APP_ARG(header);
11915 AST_APP_ARG(number);
11916 );
11917 int i, number, start = 0;
11918
11919 if (ast_strlen_zero(data)) {
11920 ast_log(LOG_WARNING, "This function requires a header name.\n");
11921 return -1;
11922 }
11923
11924 ast_channel_lock(chan);
11925 if (chan->tech != &sip_tech && chan->tech != &sip_tech_info) {
11926 ast_log(LOG_WARNING, "This function can only be used on SIP channels.\n");
11927 ast_channel_unlock(chan);
11928 return -1;
11929 }
11930
11931 AST_STANDARD_APP_ARGS(args, data);
11932 if (!args.number) {
11933 number = 1;
11934 } else {
11935 sscanf(args.number, "%d", &number);
11936 if (number < 1)
11937 number = 1;
11938 }
11939
11940 p = chan->tech_pvt;
11941
11942
11943 if (!p) {
11944 ast_channel_unlock(chan);
11945 return -1;
11946 }
11947
11948 for (i = 0; i < number; i++)
11949 content = __get_header(&p->initreq, args.header, &start);
11950
11951 if (ast_strlen_zero(content)) {
11952 ast_channel_unlock(chan);
11953 return -1;
11954 }
11955
11956 ast_copy_string(buf, content, len);
11957 ast_channel_unlock(chan);
11958
11959 return 0;
11960 }
11961
11962 static struct ast_custom_function sip_header_function = {
11963 .name = "SIP_HEADER",
11964 .synopsis = "Gets the specified SIP header",
11965 .syntax = "SIP_HEADER(<name>[,<number>])",
11966 .desc = "Since there are several headers (such as Via) which can occur multiple\n"
11967 "times, SIP_HEADER takes an optional second argument to specify which header with\n"
11968 "that name to retrieve. Headers start at offset 1.\n",
11969 .read = func_header_read,
11970 };
11971
11972
11973 static int func_check_sipdomain(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
11974 {
11975 if (ast_strlen_zero(data)) {
11976 ast_log(LOG_WARNING, "CHECKSIPDOMAIN requires an argument - A domain name\n");
11977 return -1;
11978 }
11979 if (check_sip_domain(data, NULL, 0))
11980 ast_copy_string(buf, data, len);
11981 else
11982 buf[0] = '\0';
11983 return 0;
11984 }
11985
11986 static struct ast_custom_function checksipdomain_function = {
11987 .name = "CHECKSIPDOMAIN",
11988 .synopsis = "Checks if domain is a local domain",
11989 .syntax = "CHECKSIPDOMAIN(<domain|IP>)",
11990 .read = func_check_sipdomain,
11991 .desc = "This function checks if the domain in the argument is configured\n"
11992 "as a local SIP domain that this Asterisk server is configured to handle.\n"
11993 "Returns the domain name if it is locally handled, otherwise an empty string.\n"
11994 "Check the domain= configuration in sip.conf\n",
11995 };
11996
11997
11998 static int function_sippeer(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
11999 {
12000 struct sip_peer *peer;
12001 char *colname;
12002
12003 if ((colname = strchr(data, ':')))
12004 *colname++ = '\0';
12005 else if ((colname = strchr(data, '|')))
12006 *colname++ = '\0';
12007 else
12008 colname = "ip";
12009
12010 if (!(peer = find_peer(data, NULL, 1, 0)))
12011 return -1;
12012
12013 if (!strcasecmp(colname, "ip")) {
12014 ast_copy_string(buf, peer->addr.sin_addr.s_addr ? ast_inet_ntoa(peer->addr.sin_addr) : "", len);
12015 } else if (!strcasecmp(colname, "status")) {
12016 peer_status(peer, buf, len);
12017 } else if (!strcasecmp(colname, "language")) {
12018 ast_copy_string(buf, peer->language, len);
12019 } else if (!strcasecmp(colname, "regexten")) {
12020 ast_copy_string(buf, peer->regexten, len);
12021 } else if (!strcasecmp(colname, "limit")) {
12022 snprintf(buf, len, "%d", peer->call_limit);
12023 } else if (!strcasecmp(colname, "curcalls")) {
12024 snprintf(buf, len, "%d", peer->inUse);
12025 } else if (!strcasecmp(colname, "accountcode")) {
12026 ast_copy_string(buf, peer->accountcode, len);
12027 } else if (!strcasecmp(colname, "useragent")) {
12028 ast_copy_string(buf, peer->useragent, len);
12029 } else if (!strcasecmp(colname, "mailbox")) {
12030 ast_copy_string(buf, peer->mailbox, len);
12031 } else if (!strcasecmp(colname, "context")) {
12032 ast_copy_string(buf, peer->context, len);
12033 } else if (!strcasecmp(colname, "expire")) {
12034 snprintf(buf, len, "%d", peer->expire);
12035 } else if (!strcasecmp(colname, "dynamic")) {
12036 ast_copy_string(buf, (ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC) ? "yes" : "no"), len);
12037 } else if (!strcasecmp(colname, "callerid_name")) {
12038 ast_copy_string(buf, peer->cid_name, len);
12039 } else if (!strcasecmp(colname, "callerid_num")) {
12040 ast_copy_string(buf, peer->cid_num, len);
12041 } else if (!strcasecmp(colname, "codecs")) {
12042 ast_getformatname_multiple(buf, len -1, peer->capability);
12043 } else if (!strncasecmp(colname, "codec[", 6)) {
12044 char *codecnum;
12045 int index = 0, codec = 0;
12046
12047 codecnum = colname + 6;
12048 codecnum = strsep(&codecnum, "]");
12049 index = atoi(codecnum);
12050 if((codec = ast_codec_pref_index(&peer->prefs, index))) {
12051 ast_copy_string(buf, ast_getformatname(codec), len);
12052 }
12053 }
12054
12055 ASTOBJ_UNREF(peer, sip_destroy_peer);
12056
12057 return 0;
12058 }
12059
12060
12061 struct ast_custom_function sippeer_function = {
12062 .name = "SIPPEER",
12063 .synopsis = "Gets SIP peer information",
12064 .syntax = "SIPPEER(<peername>[|item])",
12065 .read = function_sippeer,
12066 .desc = "Valid items are:\n"
12067 "- ip (default) The IP address.\n"
12068 "- mailbox The configured mailbox.\n"
12069 "- context The configured context.\n"
12070 "- expire The epoch time of the next expire.\n"
12071 "- dynamic Is it dynamic? (yes/no).\n"
12072 "- callerid_name The configured Caller ID name.\n"
12073 "- callerid_num The configured Caller ID number.\n"
12074 "- codecs The configured codecs.\n"
12075 "- status Status (if qualify=yes).\n"
12076 "- regexten Registration extension\n"
12077 "- limit Call limit (call-limit)\n"
12078 "- curcalls Current amount of calls \n"
12079 " Only available if call-limit is set\n"
12080 "- language Default language for peer\n"
12081 "- accountcode Account code for this peer\n"
12082 "- useragent Current user agent id for peer\n"
12083 "- codec[x] Preferred codec index number 'x' (beginning with zero).\n"
12084 "\n"
12085 };
12086
12087
12088 static int function_sipchaninfo_read(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
12089 {
12090 struct sip_pvt *p;
12091
12092 *buf = 0;
12093
12094 if (!data) {
12095 ast_log(LOG_WARNING, "This function requires a parameter name.\n");
12096 return -1;
12097 }
12098
12099 ast_channel_lock(chan);
12100 if (chan->tech != &sip_tech && chan->tech != &sip_tech_info) {
12101 ast_log(LOG_WARNING, "This function can only be used on SIP channels.\n");
12102 ast_channel_unlock(chan);
12103 return -1;
12104 }
12105
12106 p = chan->tech_pvt;
12107
12108
12109 if (!p) {
12110 ast_channel_unlock(chan);
12111 return -1;
12112 }
12113
12114 if (!strcasecmp(data, "peerip")) {
12115 ast_copy_string(buf, p->sa.sin_addr.s_addr ? ast_inet_ntoa(p->sa.sin_addr) : "", len);
12116 } else if (!strcasecmp(data, "recvip")) {
12117 ast_copy_string(buf, p->recv.sin_addr.s_addr ? ast_inet_ntoa(p->recv.sin_addr) : "", len);
12118 } else if (!strcasecmp(data, "from")) {
12119 ast_copy_string(buf, p->from, len);
12120 } else if (!strcasecmp(data, "uri")) {
12121 ast_copy_string(buf, p->uri, len);
12122 } else if (!strcasecmp(data, "useragent")) {
12123 ast_copy_string(buf, p->useragent, len);
12124 } else if (!strcasecmp(data, "peername")) {
12125 ast_copy_string(buf, p->peername, len);
12126 } else if (!strcasecmp(data, "t38passthrough")) {
12127 if (p->t38.state == T38_DISABLED)
12128 ast_copy_string(buf, "0", sizeof("0"));
12129 else
12130 ast_copy_string(buf, "1", sizeof("1"));
12131 } else {
12132 ast_channel_unlock(chan);
12133 return -1;
12134 }
12135 ast_channel_unlock(chan);
12136
12137 return 0;
12138 }
12139
12140
12141 static struct ast_custom_function sipchaninfo_function = {
12142 .name = "SIPCHANINFO",
12143 .synopsis = "Gets the specified SIP parameter from the current channel",
12144 .syntax = "SIPCHANINFO(item)",
12145 .read = function_sipchaninfo_read,
12146 .desc = "Valid items are:\n"
12147 "- peerip The IP address of the peer.\n"
12148 "- recvip The source IP address of the peer.\n"
12149 "- from The URI from the From: header.\n"
12150 "- uri The URI from the Contact: header.\n"
12151 "- useragent The useragent.\n"
12152 "- peername The name of the peer.\n"
12153 "- t38passthrough 1 if T38 is offered or enabled in this channel, otherwise 0\n"
12154 };
12155
12156
12157 static void parse_moved_contact(struct sip_pvt *p, struct sip_request *req)
12158 {
12159 char tmp[SIPBUFSIZE];
12160 char *s, *e, *uri, *t;
12161 char *domain;
12162
12163 ast_copy_string(tmp, get_header(req, "Contact"), sizeof(tmp));
12164 if ((t = strchr(tmp, ',')))
12165 *t = '\0';
12166 s = get_in_brackets(tmp);
12167 uri = ast_strdupa(s);
12168 if (ast_test_flag(&p->flags[0], SIP_PROMISCREDIR)) {
12169 if (!strncasecmp(s, "sip:", 4))
12170 s += 4;
12171 e = strchr(s, ';');
12172 if (e)
12173 *e = '\0';
12174 if (option_debug)
12175 ast_log(LOG_DEBUG, "Found promiscuous redirection to 'SIP/%s'\n", s);
12176 if (p->owner)
12177 ast_string_field_build(p->owner, call_forward, "SIP/%s", s);
12178 } else {
12179 e = strchr(tmp, '@');
12180 if (e) {
12181 *e++ = '\0';
12182 domain = e;
12183 } else {
12184
12185 domain = tmp;
12186 }
12187 e = strchr(s, ';');
12188 if (e)
12189 *e = '\0';
12190 e = strchr(domain, ';');
12191 if (e)
12192 *e = '\0';
12193
12194 if (!strncasecmp(s, "sip:", 4))
12195 s += 4;
12196 if (option_debug > 1)
12197 ast_log(LOG_DEBUG, "Received 302 Redirect to extension '%s' (domain %s)\n", s, domain);
12198 if (p->owner) {
12199 pbx_builtin_setvar_helper(p->owner, "SIPREDIRECTURI", uri);
12200 pbx_builtin_setvar_helper(p->owner, "SIPDOMAIN", domain);
12201 ast_string_field_set(p->owner, call_forward, s);
12202 }
12203 }
12204 }
12205
12206
12207 static void check_pendings(struct sip_pvt *p)
12208 {
12209 if (ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
12210
12211 if (p->invitestate == INV_PROCEEDING || p->invitestate == INV_EARLY_MEDIA)
12212 transmit_request(p, SIP_CANCEL, p->lastinvite, XMIT_RELIABLE, FALSE);
12213
12214
12215 else {
12216
12217
12218 if (p->pendinginvite)
12219 return;
12220
12221
12222 transmit_request_with_auth(p, SIP_BYE, 0, XMIT_RELIABLE, TRUE);
12223 }
12224 ast_clear_flag(&p->flags[0], SIP_PENDINGBYE);
12225 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
12226 } else if (ast_test_flag(&p->flags[0], SIP_NEEDREINVITE)) {
12227
12228 if (p->pendinginvite || p->invitestate == INV_CALLING || p->invitestate == INV_PROCEEDING || p->invitestate == INV_EARLY_MEDIA || p->waitid > 0) {
12229 if (option_debug)
12230 ast_log(LOG_DEBUG, "NOT Sending pending reinvite (yet) on '%s'\n", p->callid);
12231 } else {
12232 if (option_debug)
12233 ast_log(LOG_DEBUG, "Sending pending reinvite on '%s'\n", p->callid);
12234
12235 transmit_reinvite_with_sdp(p);
12236 ast_clear_flag(&p->flags[0], SIP_NEEDREINVITE);
12237 }
12238 }
12239 }
12240
12241
12242
12243
12244
12245 static int sip_reinvite_retry(const void *data)
12246 {
12247 struct sip_pvt *p = (struct sip_pvt *) data;
12248
12249 ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
12250 p->waitid = -1;
12251 return 0;
12252 }
12253
12254
12255
12256 static void handle_response_invite(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int seqno)
12257 {
12258 int outgoing = ast_test_flag(&p->flags[0], SIP_OUTGOING);
12259 int res = 0;
12260 int xmitres = 0;
12261 int reinvite = (p->owner && p->owner->_state == AST_STATE_UP);
12262 struct ast_channel *bridgepeer = NULL;
12263
12264 if (option_debug > 3) {
12265 if (reinvite)
12266 ast_log(LOG_DEBUG, "SIP response %d to RE-invite on %s call %s\n", resp, outgoing ? "outgoing" : "incoming", p->callid);
12267 else
12268 ast_log(LOG_DEBUG, "SIP response %d to standard invite\n", resp);
12269 }
12270
12271 if (ast_test_flag(&p->flags[0], SIP_ALREADYGONE)) {
12272 if (option_debug)
12273 ast_log(LOG_DEBUG, "Got response on call that is already terminated: %s (ignoring)\n", p->callid);
12274 return;
12275 }
12276
12277
12278
12279 AST_SCHED_DEL(sched, p->initid);
12280
12281
12282
12283
12284 if (resp > 100 && resp < 200 && resp!=101 && resp != 180 && resp != 182 && resp != 183)
12285 resp = 183;
12286
12287
12288 if (resp >= 100 && resp < 200 && p->invitestate == INV_CALLING)
12289 p->invitestate = INV_PROCEEDING;
12290
12291
12292 if (resp >= 300 && (p->invitestate == INV_CALLING || p->invitestate == INV_PROCEEDING || p->invitestate == INV_EARLY_MEDIA ))
12293 p->invitestate = INV_COMPLETED;
12294
12295
12296 switch (resp) {
12297 case 100:
12298 case 101:
12299 if (!ast_test_flag(req, SIP_PKT_IGNORE) && (p->invitestate != INV_CANCELLED) && sip_cancel_destroy(p))
12300 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
12301 check_pendings(p);
12302 break;
12303
12304 case 180:
12305 case 182:
12306 if (!ast_test_flag(req, SIP_PKT_IGNORE) && (p->invitestate != INV_CANCELLED) && sip_cancel_destroy(p))
12307 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
12308 if (!ast_test_flag(req, SIP_PKT_IGNORE) && p->owner) {
12309 ast_queue_control(p->owner, AST_CONTROL_RINGING);
12310 if (p->owner->_state != AST_STATE_UP) {
12311 ast_setstate(p->owner, AST_STATE_RINGING);
12312 }
12313 }
12314 if (find_sdp(req)) {
12315 if (p->invitestate != INV_CANCELLED)
12316 p->invitestate = INV_EARLY_MEDIA;
12317 res = process_sdp(p, req);
12318 if (!ast_test_flag(req, SIP_PKT_IGNORE) && p->owner) {
12319
12320 ast_queue_control(p->owner, AST_CONTROL_PROGRESS);
12321 }
12322 }
12323 check_pendings(p);
12324 break;
12325
12326 case 183:
12327 if (!ast_test_flag(req, SIP_PKT_IGNORE) && (p->invitestate != INV_CANCELLED) && sip_cancel_destroy(p))
12328 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
12329
12330 if (find_sdp(req)) {
12331 if (p->invitestate != INV_CANCELLED)
12332 p->invitestate = INV_EARLY_MEDIA;
12333 res = process_sdp(p, req);
12334 if (!ast_test_flag(req, SIP_PKT_IGNORE) && p->owner) {
12335
12336 ast_queue_control(p->owner, AST_CONTROL_PROGRESS);
12337 }
12338 }
12339 check_pendings(p);
12340 break;
12341
12342 case 200:
12343 if (!ast_test_flag(req, SIP_PKT_IGNORE) && (p->invitestate != INV_CANCELLED) && sip_cancel_destroy(p))
12344 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
12345 p->authtries = 0;
12346 if (find_sdp(req)) {
12347 if ((res = process_sdp(p, req)) && !ast_test_flag(req, SIP_PKT_IGNORE))
12348 if (!reinvite)
12349
12350
12351 ast_set_flag(&p->flags[0], SIP_PENDINGBYE);
12352 }
12353
12354
12355
12356
12357 if (outgoing) {
12358 update_call_counter(p, DEC_CALL_RINGING);
12359 parse_ok_contact(p, req);
12360
12361 if (!reinvite)
12362 build_route(p, req, 1);
12363
12364 if(set_address_from_contact(p)) {
12365
12366
12367 if (!p->route && !ast_test_flag(req, SIP_PKT_IGNORE))
12368 ast_set_flag(&p->flags[0], SIP_PENDINGBYE);
12369 }
12370
12371 }
12372
12373 if (p->owner && (p->owner->_state == AST_STATE_UP) && (bridgepeer = ast_bridged_channel(p->owner))) {
12374 struct sip_pvt *bridgepvt = NULL;
12375
12376 if (!bridgepeer->tech) {
12377 ast_log(LOG_WARNING, "Ooooh.. no tech! That's REALLY bad\n");
12378 break;
12379 }
12380 if (bridgepeer->tech == &sip_tech || bridgepeer->tech == &sip_tech_info) {
12381 bridgepvt = (struct sip_pvt*)(bridgepeer->tech_pvt);
12382 if (bridgepvt->udptl) {
12383 if (p->t38.state == T38_PEER_REINVITE) {
12384 sip_handle_t38_reinvite(bridgepeer, p, 0);
12385 ast_rtp_set_rtptimers_onhold(p->rtp);
12386 if (p->vrtp)
12387 ast_rtp_set_rtptimers_onhold(p->vrtp);
12388 } else if (p->t38.state == T38_DISABLED && bridgepeer && (bridgepvt->t38.state == T38_ENABLED)) {
12389 ast_log(LOG_WARNING, "RTP re-invite after T38 session not handled yet !\n");
12390
12391
12392 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
12393 }
12394 } else {
12395 if (option_debug > 1)
12396 ast_log(LOG_DEBUG, "Strange... The other side of the bridge does not have a udptl struct\n");
12397 ast_mutex_lock(&bridgepvt->lock);
12398 bridgepvt->t38.state = T38_DISABLED;
12399 ast_mutex_unlock(&bridgepvt->lock);
12400 if (option_debug)
12401 ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", bridgepvt->t38.state, bridgepeer->tech->type);
12402 p->t38.state = T38_DISABLED;
12403 if (option_debug > 1)
12404 ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
12405 }
12406 } else {
12407
12408 if (option_debug > 1)
12409 ast_log(LOG_DEBUG, "Strange... The other side of the bridge is not a SIP channel\n");
12410 p->t38.state = T38_DISABLED;
12411 if (option_debug > 1)
12412 ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
12413 }
12414 }
12415 if ((p->t38.state == T38_LOCAL_REINVITE) || (p->t38.state == T38_LOCAL_DIRECT)) {
12416
12417 p->t38.state = T38_ENABLED;
12418 if (option_debug)
12419 ast_log(LOG_DEBUG, "T38 changed state to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
12420 }
12421
12422 if (!ast_test_flag(req, SIP_PKT_IGNORE) && p->owner) {
12423 if (!reinvite) {
12424 ast_queue_control(p->owner, AST_CONTROL_ANSWER);
12425 } else {
12426 ast_queue_frame(p->owner, &ast_null_frame);
12427 }
12428 } else {
12429
12430
12431
12432 if (!ast_test_flag(req, SIP_PKT_IGNORE))
12433 ast_set_flag(&p->flags[0], SIP_PENDINGBYE);
12434 }
12435
12436 p->invitestate = INV_TERMINATED;
12437 ast_set_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
12438 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, TRUE);
12439 check_pendings(p);
12440 break;
12441 case 407:
12442 case 401:
12443
12444 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
12445 if (p->options)
12446 p->options->auth_type = (resp == 401 ? WWW_AUTH : PROXY_AUTH);
12447
12448
12449 ast_string_field_free(p, theirtag);
12450 if (!ast_test_flag(req, SIP_PKT_IGNORE)) {
12451 char *authenticate = (resp == 401 ? "WWW-Authenticate" : "Proxy-Authenticate");
12452 char *authorization = (resp == 401 ? "Authorization" : "Proxy-Authorization");
12453 if (p->authtries < MAX_AUTHTRIES)
12454 p->invitestate = INV_CALLING;
12455 if ((p->authtries == MAX_AUTHTRIES) || do_proxy_auth(p, req, authenticate, authorization, SIP_INVITE, 1)) {
12456 ast_log(LOG_NOTICE, "Failed to authenticate on INVITE to '%s'\n", get_header(&p->initreq, "From"));
12457 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12458 sip_alreadygone(p);
12459 if (p->owner)
12460 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12461 }
12462 }
12463 break;
12464
12465 case 403:
12466
12467 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
12468 ast_log(LOG_WARNING, "Received response: \"Forbidden\" from '%s'\n", get_header(&p->initreq, "From"));
12469 if (!ast_test_flag(req, SIP_PKT_IGNORE) && p->owner)
12470 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12471 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12472 sip_alreadygone(p);
12473 break;
12474
12475 case 404:
12476 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
12477 if (p->owner && !ast_test_flag(req, SIP_PKT_IGNORE))
12478 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12479 sip_alreadygone(p);
12480 break;
12481
12482 case 408:
12483 case 481:
12484
12485 ast_log(LOG_WARNING, "Re-invite to non-existing call leg on other UA. SIP dialog '%s'. Giving up.\n", p->callid);
12486 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
12487 if (p->owner)
12488 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12489 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
12490 break;
12491 case 487:
12492
12493
12494
12495 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
12496 if (p->owner && !ast_test_flag(req, SIP_PKT_IGNORE)) {
12497 ast_queue_hangup(p->owner);
12498 append_history(p, "Hangup", "Got 487 on CANCEL request from us. Queued AST hangup request");
12499 } else if (!ast_test_flag(req, SIP_PKT_IGNORE)) {
12500 update_call_counter(p, DEC_CALL_LIMIT);
12501 append_history(p, "Hangup", "Got 487 on CANCEL request from us on call without owner. Killing this dialog.");
12502 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12503 sip_alreadygone(p);
12504 }
12505 break;
12506 case 488:
12507 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
12508 if (reinvite && p->udptl) {
12509
12510
12511
12512
12513
12514 p->t38.state = T38_DISABLED;
12515
12516 ast_rtp_set_rtptimers_onhold(p->rtp);
12517 ast_log(LOG_ERROR, "Got error on T.38 re-invite. Bad configuration. Peer needs to have T.38 disabled.\n");
12518
12519
12520
12521
12522
12523 if (p->owner && !ast_test_flag(req, SIP_PKT_IGNORE))
12524 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12525 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12526 } else if (p->udptl && p->t38.state == T38_LOCAL_DIRECT) {
12527
12528
12529
12530 p->t38.state = T38_DISABLED;
12531
12532 ast_rtp_set_rtptimers_onhold(p->rtp);
12533 ast_log(LOG_ERROR, "Got error on T.38 initial invite. Bailing out.\n");
12534
12535
12536 if (p->owner && !ast_test_flag(req, SIP_PKT_IGNORE))
12537 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12538 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12539 sip_alreadygone(p);
12540 } else {
12541
12542 if (p->owner && !ast_test_flag(req, SIP_PKT_IGNORE))
12543 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12544 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12545
12546 if (!reinvite)
12547 sip_alreadygone(p);
12548 }
12549 break;
12550 case 491:
12551
12552
12553
12554
12555 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
12556 if (p->owner && !ast_test_flag(req, SIP_PKT_IGNORE)) {
12557 if (p->owner->_state != AST_STATE_UP) {
12558 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12559 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12560 } else {
12561
12562
12563
12564 int wait = 3 + ast_random() % 5;
12565 p->waitid = ast_sched_add(sched, wait, sip_reinvite_retry, p);
12566 if (option_debug > 2)
12567 ast_log(LOG_DEBUG, "Reinvite race. Waiting %d secs before retry\n", wait);
12568 }
12569 }
12570 break;
12571
12572 case 501:
12573 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
12574 if (p->owner)
12575 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12576 break;
12577 }
12578 if (xmitres == XMIT_ERROR)
12579 ast_log(LOG_WARNING, "Could not transmit message in dialog %s\n", p->callid);
12580 }
12581
12582
12583
12584
12585 static void handle_response_refer(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int seqno)
12586 {
12587 char *auth = "Proxy-Authenticate";
12588 char *auth2 = "Proxy-Authorization";
12589
12590
12591 if (!p->refer)
12592 return;
12593
12594 switch (resp) {
12595 case 202:
12596
12597
12598 p->refer->status = REFER_ACCEPTED;
12599
12600 if (option_debug > 2)
12601 ast_log(LOG_DEBUG, "Got 202 accepted on transfer\n");
12602
12603 break;
12604
12605 case 401:
12606 case 407:
12607 if (ast_strlen_zero(p->authname)) {
12608 ast_log(LOG_WARNING, "Asked to authenticate REFER to %s:%d but we have no matching peer or realm auth!\n",
12609 ast_inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));
12610 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12611 }
12612 if (resp == 401) {
12613 auth = "WWW-Authenticate";
12614 auth2 = "Authorization";
12615 }
12616 if ((p->authtries > 1) || do_proxy_auth(p, req, auth, auth2, SIP_REFER, 0)) {
12617 ast_log(LOG_NOTICE, "Failed to authenticate on REFER to '%s'\n", get_header(&p->initreq, "From"));
12618 p->refer->status = REFER_NOAUTH;
12619 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12620 }
12621 break;
12622 case 481:
12623
12624
12625
12626
12627 ast_log(LOG_WARNING, "Remote host can't match REFER request to call '%s'. Giving up.\n", p->callid);
12628 if (p->owner)
12629 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12630 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12631 break;
12632
12633 case 500:
12634 case 501:
12635
12636
12637 ast_log(LOG_NOTICE, "SIP transfer to %s failed, call miserably fails. \n", p->refer->refer_to);
12638 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12639 p->refer->status = REFER_FAILED;
12640 break;
12641 case 603:
12642 ast_log(LOG_NOTICE, "SIP transfer to %s declined, call miserably fails. \n", p->refer->refer_to);
12643 p->refer->status = REFER_FAILED;
12644 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12645 break;
12646 }
12647 }
12648
12649
12650 static int handle_response_register(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int ignore, int seqno)
12651 {
12652 int expires, expires_ms;
12653 struct sip_registry *r;
12654 r=p->registry;
12655
12656 switch (resp) {
12657 case 401:
12658 if ((p->authtries == MAX_AUTHTRIES) || do_register_auth(p, req, "WWW-Authenticate", "Authorization")) {
12659 ast_log(LOG_NOTICE, "Failed to authenticate on REGISTER to '%s@%s' (Tries %d)\n", p->registry->username, p->registry->hostname, p->authtries);
12660 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12661 }
12662 break;
12663 case 403:
12664 ast_log(LOG_WARNING, "Forbidden - wrong password on authentication for REGISTER for '%s' to '%s'\n", p->registry->username, p->registry->hostname);
12665 if (global_regattempts_max)
12666 p->registry->regattempts = global_regattempts_max+1;
12667 AST_SCHED_DEL(sched, r->timeout);
12668 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12669 break;
12670 case 404:
12671 ast_log(LOG_WARNING, "Got 404 Not found on SIP register to service %s@%s, giving up\n", p->registry->username,p->registry->hostname);
12672 if (global_regattempts_max)
12673 p->registry->regattempts = global_regattempts_max+1;
12674 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12675 r->call = NULL;
12676 AST_SCHED_DEL(sched, r->timeout);
12677 break;
12678 case 407:
12679 if ((p->authtries == MAX_AUTHTRIES) || do_register_auth(p, req, "Proxy-Authenticate", "Proxy-Authorization")) {
12680 ast_log(LOG_NOTICE, "Failed to authenticate on REGISTER to '%s' (tries '%d')\n", get_header(&p->initreq, "From"), p->authtries);
12681 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12682 }
12683 break;
12684 case 408:
12685
12686 r->regattempts = 0;
12687 break;
12688 case 479:
12689 ast_log(LOG_WARNING, "Got error 479 on register to %s@%s, giving up (check config)\n", p->registry->username,p->registry->hostname);
12690 if (global_regattempts_max)
12691 p->registry->regattempts = global_regattempts_max+1;
12692 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12693 r->call = NULL;
12694 AST_SCHED_DEL(sched, r->timeout);
12695 break;
12696 case 200:
12697 if (!r) {
12698 ast_log(LOG_WARNING, "Got 200 OK on REGISTER that isn't a register\n");
12699 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12700 return 0;
12701 }
12702
12703 r->regstate = REG_STATE_REGISTERED;
12704 r->regtime = time(NULL);
12705 manager_event(EVENT_FLAG_SYSTEM, "Registry", "ChannelDriver: SIP\r\nDomain: %s\r\nStatus: %s\r\n", r->hostname, regstate2str(r->regstate));
12706 r->regattempts = 0;
12707 if (option_debug)
12708 ast_log(LOG_DEBUG, "Registration successful\n");
12709 if (r->timeout > -1) {
12710 if (option_debug)
12711 ast_log(LOG_DEBUG, "Cancelling timeout %d\n", r->timeout);
12712 }
12713 AST_SCHED_DEL(sched, r->timeout);
12714 r->call = NULL;
12715 p->registry = NULL;
12716
12717 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
12718
12719
12720
12721
12722 AST_SCHED_DEL(sched, r->expire);
12723
12724
12725 expires = 0;
12726
12727
12728 if (!ast_strlen_zero(get_header(req, "Contact"))) {
12729 const char *contact = NULL;
12730 const char *tmptmp = NULL;
12731 int start = 0;
12732 for(;;) {
12733 contact = __get_header(req, "Contact", &start);
12734
12735 if(!ast_strlen_zero(contact)) {
12736 if( (tmptmp=strstr(contact, p->our_contact))) {
12737 contact=tmptmp;
12738 break;
12739 }
12740 } else
12741 break;
12742 }
12743 tmptmp = strcasestr(contact, "expires=");
12744 if (tmptmp) {
12745 if (sscanf(tmptmp + 8, "%d;", &expires) != 1)
12746 expires = 0;
12747 }
12748
12749 }
12750 if (!expires)
12751 expires=atoi(get_header(req, "expires"));
12752 if (!expires)
12753 expires=default_expiry;
12754
12755 expires_ms = expires * 1000;
12756 if (expires <= EXPIRY_GUARD_LIMIT)
12757 expires_ms -= MAX((expires_ms * EXPIRY_GUARD_PCT),EXPIRY_GUARD_MIN);
12758 else
12759 expires_ms -= EXPIRY_GUARD_SECS * 1000;
12760 if (sipdebug)
12761 ast_log(LOG_NOTICE, "Outbound Registration: Expiry for %s is %d sec (Scheduling reregistration in %d s)\n", r->hostname, expires, expires_ms/1000);
12762
12763 r->refresh= (int) expires_ms / 1000;
12764
12765
12766 AST_SCHED_DEL(sched, r->expire);
12767 r->expire = ast_sched_add(sched, expires_ms, sip_reregister, r);
12768 ASTOBJ_UNREF(r, sip_registry_destroy);
12769 }
12770 return 1;
12771 }
12772
12773
12774 static void handle_response_peerpoke(struct sip_pvt *p, int resp, struct sip_request *req)
12775 {
12776 struct sip_peer *peer = p->relatedpeer;
12777 int statechanged, is_reachable, was_reachable;
12778 int pingtime = ast_tvdiff_ms(ast_tvnow(), peer->ps);
12779
12780
12781
12782
12783
12784
12785 if (pingtime < 1)
12786 pingtime = 1;
12787
12788
12789
12790
12791
12792 was_reachable = peer->lastms > 0 && peer->lastms <= peer->maxms;
12793 is_reachable = pingtime <= peer->maxms;
12794 statechanged = peer->lastms == 0
12795 || was_reachable != is_reachable;
12796
12797 peer->lastms = pingtime;
12798 peer->call = NULL;
12799 if (statechanged) {
12800 const char *s = is_reachable ? "Reachable" : "Lagged";
12801
12802 ast_log(LOG_NOTICE, "Peer '%s' is now %s. (%dms / %dms)\n",
12803 peer->name, s, pingtime, peer->maxms);
12804 ast_device_state_changed("SIP/%s", peer->name);
12805 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus",
12806 "Peer: SIP/%s\r\nPeerStatus: %s\r\nTime: %d\r\n",
12807 peer->name, s, pingtime);
12808 }
12809
12810 if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
12811 struct sip_peer *peer_ptr = peer;
12812 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
12813 }
12814
12815 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12816
12817
12818 peer->pokeexpire = ast_sched_add(sched,
12819 is_reachable ? DEFAULT_FREQ_OK : DEFAULT_FREQ_NOTOK,
12820 sip_poke_peer_s, ASTOBJ_REF(peer));
12821
12822 if (peer->pokeexpire == -1) {
12823 ASTOBJ_UNREF(peer, sip_destroy_peer);
12824 }
12825 }
12826
12827
12828 static void stop_media_flows(struct sip_pvt *p)
12829 {
12830
12831 if (p->rtp)
12832 ast_rtp_stop(p->rtp);
12833 if (p->vrtp)
12834 ast_rtp_stop(p->vrtp);
12835 if (p->udptl)
12836 ast_udptl_stop(p->udptl);
12837 }
12838
12839
12840
12841 static void handle_response(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int ignore, int seqno)
12842 {
12843 struct ast_channel *owner;
12844 int sipmethod;
12845 int res = 1;
12846 const char *c = get_header(req, "Cseq");
12847
12848 char *c_copy = ast_strdupa(c);
12849
12850 const char *msg = ast_skip_blanks(ast_skip_nonblanks(c_copy));
12851
12852 if (!msg)
12853 msg = "";
12854
12855 sipmethod = find_sip_method(msg);
12856
12857 owner = p->owner;
12858 if (owner)
12859 owner->hangupcause = hangup_sip2cause(resp);
12860
12861
12862 if ((resp >= 100) && (resp <= 199))
12863 __sip_semi_ack(p, seqno, 0, sipmethod);
12864 else
12865 __sip_ack(p, seqno, 0, sipmethod);
12866
12867
12868 if (!p->owner && sipmethod == SIP_NOTIFY && p->pendinginvite)
12869 p->pendinginvite = 0;
12870
12871
12872 if (ast_strlen_zero(p->theirtag) || (resp >= 200)) {
12873 char tag[128];
12874
12875 gettag(req, "To", tag, sizeof(tag));
12876 ast_string_field_set(p, theirtag, tag);
12877 }
12878 if (p->relatedpeer && p->method == SIP_OPTIONS) {
12879
12880
12881
12882 if (resp != 100)
12883 handle_response_peerpoke(p, resp, req);
12884 } else if (ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
12885 switch(resp) {
12886 case 100:
12887 case 101:
12888 if (sipmethod == SIP_INVITE)
12889 handle_response_invite(p, resp, rest, req, seqno);
12890 break;
12891 case 183:
12892 if (sipmethod == SIP_INVITE)
12893 handle_response_invite(p, resp, rest, req, seqno);
12894 break;
12895 case 180:
12896 if (sipmethod == SIP_INVITE)
12897 handle_response_invite(p, resp, rest, req, seqno);
12898 break;
12899 case 182:
12900 if (sipmethod == SIP_INVITE)
12901 handle_response_invite(p, resp, rest, req, seqno);
12902 break;
12903 case 200:
12904 p->authtries = 0;
12905 if (sipmethod == SIP_MESSAGE || sipmethod == SIP_INFO) {
12906
12907
12908
12909 } else if (sipmethod == SIP_INVITE) {
12910 handle_response_invite(p, resp, rest, req, seqno);
12911 } else if (sipmethod == SIP_NOTIFY) {
12912
12913 if (p->owner) {
12914 if (!p->refer) {
12915 ast_log(LOG_WARNING, "Notify answer on an owned channel? - %s\n", p->owner->name);
12916 ast_queue_hangup(p->owner);
12917 } else if (option_debug > 3)
12918 ast_log(LOG_DEBUG, "Got OK on REFER Notify message\n");
12919 } else {
12920 if (p->subscribed == NONE)
12921 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12922 if (ast_test_flag(&p->flags[1], SIP_PAGE2_STATECHANGEQUEUE)) {
12923
12924 ast_clear_flag(&p->flags[1], SIP_PAGE2_STATECHANGEQUEUE);
12925 cb_extensionstate((char *)p->context, (char *)p->exten, p->laststate, (void *) p);
12926 }
12927 }
12928 } else if (sipmethod == SIP_REGISTER)
12929 res = handle_response_register(p, resp, rest, req, ignore, seqno);
12930 else if (sipmethod == SIP_BYE) {
12931 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12932 ast_clear_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
12933 } else if (sipmethod == SIP_SUBSCRIBE)
12934 ast_set_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
12935 break;
12936 case 202:
12937 if (sipmethod == SIP_REFER)
12938 handle_response_refer(p, resp, rest, req, seqno);
12939 break;
12940 case 401:
12941 if (sipmethod == SIP_INVITE)
12942 handle_response_invite(p, resp, rest, req, seqno);
12943 else if (sipmethod == SIP_REFER)
12944 handle_response_refer(p, resp, rest, req, seqno);
12945 else if (p->registry && sipmethod == SIP_REGISTER)
12946 res = handle_response_register(p, resp, rest, req, ignore, seqno);
12947 else if (sipmethod == SIP_BYE) {
12948 if (ast_strlen_zero(p->authname)) {
12949 ast_log(LOG_WARNING, "Asked to authenticate %s, to %s:%d but we have no matching peer!\n",
12950 msg, ast_inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));
12951 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12952 } else if ((p->authtries == MAX_AUTHTRIES) || do_proxy_auth(p, req, "WWW-Authenticate", "Authorization", sipmethod, 0)) {
12953 ast_log(LOG_NOTICE, "Failed to authenticate on %s to '%s'\n", msg, get_header(&p->initreq, "From"));
12954 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12955
12956
12957 }
12958 } else {
12959 ast_log(LOG_WARNING, "Got authentication request (401) on unknown %s to '%s'\n", sip_methods[sipmethod].text, get_header(req, "To"));
12960 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12961 }
12962 break;
12963 case 403:
12964 if (sipmethod == SIP_INVITE)
12965 handle_response_invite(p, resp, rest, req, seqno);
12966 else if (p->registry && sipmethod == SIP_REGISTER)
12967 res = handle_response_register(p, resp, rest, req, ignore, seqno);
12968 else {
12969 ast_log(LOG_WARNING, "Forbidden - maybe wrong password on authentication for %s\n", msg);
12970 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12971 }
12972 break;
12973 case 404:
12974 if (p->registry && sipmethod == SIP_REGISTER)
12975 res = handle_response_register(p, resp, rest, req, ignore, seqno);
12976 else if (sipmethod == SIP_INVITE)
12977 handle_response_invite(p, resp, rest, req, seqno);
12978 else if (owner)
12979 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12980 break;
12981 case 407:
12982 if (sipmethod == SIP_INVITE)
12983 handle_response_invite(p, resp, rest, req, seqno);
12984 else if (sipmethod == SIP_REFER)
12985 handle_response_refer(p, resp, rest, req, seqno);
12986 else if (p->registry && sipmethod == SIP_REGISTER)
12987 res = handle_response_register(p, resp, rest, req, ignore, seqno);
12988 else if (sipmethod == SIP_BYE) {
12989 if (ast_strlen_zero(p->authname)) {
12990 ast_log(LOG_WARNING, "Asked to authenticate %s, to %s:%d but we have no matching peer!\n",
12991 msg, ast_inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));
12992 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12993 } else if ((p->authtries == MAX_AUTHTRIES) || do_proxy_auth(p, req, "Proxy-Authenticate", "Proxy-Authorization", sipmethod, 0)) {
12994 ast_log(LOG_NOTICE, "Failed to authenticate on %s to '%s'\n", msg, get_header(&p->initreq, "From"));
12995 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12996 }
12997 } else
12998 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12999
13000 break;
13001 case 408:
13002 if (sipmethod == SIP_INVITE)
13003 handle_response_invite(p, resp, rest, req, seqno);
13004 else if (sipmethod == SIP_REGISTER)
13005 res = handle_response_register(p, resp, rest, req, ignore, seqno);
13006 else if (sipmethod == SIP_BYE) {
13007 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
13008 if (option_debug)
13009 ast_log(LOG_DEBUG, "Got timeout on bye. Thanks for the answer. Now, kill this call\n");
13010 } else {
13011 if (owner)
13012 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
13013 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
13014 }
13015 break;
13016 case 481:
13017 if (sipmethod == SIP_INVITE) {
13018 handle_response_invite(p, resp, rest, req, seqno);
13019 } else if (sipmethod == SIP_REFER) {
13020 handle_response_refer(p, resp, rest, req, seqno);
13021 } else if (sipmethod == SIP_BYE) {
13022
13023
13024 ast_log(LOG_WARNING, "Remote host can't match request %s to call '%s'. Giving up.\n", sip_methods[sipmethod].text, p->callid);
13025 } else if (sipmethod == SIP_CANCEL) {
13026
13027
13028 ast_log(LOG_WARNING, "Remote host can't match request %s to call '%s'. Giving up.\n", sip_methods[sipmethod].text, p->callid);
13029 } else {
13030 ast_log(LOG_WARNING, "Remote host can't match request %s to call '%s'. Giving up.\n", sip_methods[sipmethod].text, p->callid);
13031
13032 }
13033 break;
13034 case 487:
13035 if (sipmethod == SIP_INVITE)
13036 handle_response_invite(p, resp, rest, req, seqno);
13037 break;
13038 case 488:
13039 if (sipmethod == SIP_INVITE)
13040 handle_response_invite(p, resp, rest, req, seqno);
13041 break;
13042 case 491:
13043 if (sipmethod == SIP_INVITE)
13044 handle_response_invite(p, resp, rest, req, seqno);
13045 else {
13046 if (option_debug)
13047 ast_log(LOG_DEBUG, "Got 491 on %s, unspported. Call ID %s\n", sip_methods[sipmethod].text, p->callid);
13048 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
13049 }
13050 break;
13051 case 501:
13052 if (sipmethod == SIP_INVITE)
13053 handle_response_invite(p, resp, rest, req, seqno);
13054 else if (sipmethod == SIP_REFER)
13055 handle_response_refer(p, resp, rest, req, seqno);
13056 else
13057 ast_log(LOG_WARNING, "Host '%s' does not implement '%s'\n", ast_inet_ntoa(p->sa.sin_addr), msg);
13058 break;
13059 case 603:
13060 if (sipmethod == SIP_REFER) {
13061 handle_response_refer(p, resp, rest, req, seqno);
13062 break;
13063 }
13064
13065 default:
13066 if ((resp >= 300) && (resp < 700)) {
13067
13068 if ((option_verbose > 2) && (resp != 487))
13069 ast_verbose(VERBOSE_PREFIX_3 "Got SIP response %d \"%s\" back from %s\n", resp, rest, ast_inet_ntoa(p->sa.sin_addr));
13070
13071 if (sipmethod == SIP_INVITE)
13072 stop_media_flows(p);
13073
13074
13075 switch(resp) {
13076 case 300:
13077 case 301:
13078 case 302:
13079 case 305:
13080 parse_moved_contact(p, req);
13081
13082 case 486:
13083 case 600:
13084 case 603:
13085 if (p->owner)
13086 ast_queue_control(p->owner, AST_CONTROL_BUSY);
13087 break;
13088 case 482:
13089
13090
13091
13092
13093 if (option_debug)
13094 ast_log(LOG_DEBUG, "Hairpin detected, setting up call forward for what it's worth\n");
13095 if (p->owner)
13096 ast_string_field_build(p->owner, call_forward,
13097 "Local/%s@%s", p->username, p->context);
13098
13099 case 480:
13100 case 404:
13101 case 410:
13102 case 400:
13103 case 500:
13104 if (sipmethod == SIP_REFER) {
13105 handle_response_refer(p, resp, rest, req, seqno);
13106 break;
13107 }
13108
13109 case 502:
13110 case 503:
13111 case 504:
13112 if (owner)
13113 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
13114 break;
13115 default:
13116
13117 if (owner && sipmethod != SIP_MESSAGE && sipmethod != SIP_INFO && sipmethod != SIP_BYE)
13118 ast_queue_hangup(p->owner);
13119 break;
13120 }
13121
13122 if (sipmethod == SIP_INVITE)
13123 transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
13124 if (sipmethod != SIP_MESSAGE && sipmethod != SIP_INFO)
13125 sip_alreadygone(p);
13126 if (!p->owner)
13127 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
13128 } else if ((resp >= 100) && (resp < 200)) {
13129 if (sipmethod == SIP_INVITE) {
13130 if (!ast_test_flag(req, SIP_PKT_IGNORE) && sip_cancel_destroy(p))
13131 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
13132 if (find_sdp(req))
13133 process_sdp(p, req);
13134 if (p->owner) {
13135
13136 ast_queue_control(p->owner, AST_CONTROL_PROGRESS);
13137 }
13138 }
13139 } else
13140 ast_log(LOG_NOTICE, "Dont know how to handle a %d %s response from %s\n", resp, rest, p->owner ? p->owner->name : ast_inet_ntoa(p->sa.sin_addr));
13141 }
13142 } else {
13143
13144
13145 if (ast_test_flag(req, SIP_PKT_DEBUG))
13146 ast_verbose("SIP Response message for INCOMING dialog %s arrived\n", msg);
13147
13148 if (sipmethod == SIP_INVITE && resp == 200) {
13149
13150
13151 char tag[128];
13152
13153 gettag(req, "To", tag, sizeof(tag));
13154 ast_string_field_set(p, theirtag, tag);
13155 }
13156
13157 switch(resp) {
13158 case 200:
13159 if (sipmethod == SIP_INVITE) {
13160 handle_response_invite(p, resp, rest, req, seqno);
13161 } else if (sipmethod == SIP_CANCEL) {
13162 if (option_debug)
13163 ast_log(LOG_DEBUG, "Got 200 OK on CANCEL\n");
13164
13165
13166 } else if (sipmethod == SIP_NOTIFY) {
13167
13168 if (p->owner) {
13169 if (p->refer) {
13170 if (option_debug)
13171 ast_log(LOG_DEBUG, "Got 200 OK on NOTIFY for transfer\n");
13172 } else
13173 ast_log(LOG_WARNING, "Notify answer on an owned channel?\n");
13174
13175 } else {
13176 if (!p->subscribed && !p->refer)
13177 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
13178 if (ast_test_flag(&p->flags[1], SIP_PAGE2_STATECHANGEQUEUE)) {
13179
13180 ast_clear_flag(&p->flags[1], SIP_PAGE2_STATECHANGEQUEUE);
13181 cb_extensionstate((char *)p->context, (char *)p->exten, p->laststate, (void *) p);
13182 }
13183 }
13184 } else if (sipmethod == SIP_BYE)
13185 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
13186 else if (sipmethod == SIP_MESSAGE || sipmethod == SIP_INFO)
13187
13188
13189 ;
13190 else if (sipmethod == SIP_BYE)
13191
13192 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
13193 break;
13194 case 202:
13195 if (sipmethod == SIP_REFER)
13196 handle_response_refer(p, resp, rest, req, seqno);
13197 break;
13198 case 401:
13199 case 407:
13200 if (sipmethod == SIP_REFER)
13201 handle_response_refer(p, resp, rest, req, seqno);
13202 else if (sipmethod == SIP_INVITE)
13203 handle_response_invite(p, resp, rest, req, seqno);
13204 else if (sipmethod == SIP_BYE) {
13205 char *auth, *auth2;
13206
13207 auth = (resp == 407 ? "Proxy-Authenticate" : "WWW-Authenticate");
13208 auth2 = (resp == 407 ? "Proxy-Authorization" : "Authorization");
13209 if ((p->authtries == MAX_AUTHTRIES) || do_proxy_auth(p, req, auth, auth2, sipmethod, 0)) {
13210 ast_log(LOG_NOTICE, "Failed to authenticate on %s to '%s'\n", msg, get_header(&p->initreq, "From"));
13211 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
13212 }
13213 }
13214 break;
13215 case 481:
13216 if (sipmethod == SIP_INVITE) {
13217
13218 handle_response_invite(p, resp, rest, req, seqno);
13219 } else if (sipmethod == SIP_BYE) {
13220 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
13221 } else if (sipdebug) {
13222 ast_log (LOG_DEBUG, "Remote host can't match request %s to call '%s'. Giving up\n", sip_methods[sipmethod].text, p->callid);
13223 }
13224 break;
13225 case 501:
13226 if (sipmethod == SIP_INVITE)
13227 handle_response_invite(p, resp, rest, req, seqno);
13228 else if (sipmethod == SIP_REFER)
13229 handle_response_refer(p, resp, rest, req, seqno);
13230 break;
13231 case 603:
13232 if (sipmethod == SIP_REFER) {
13233 handle_response_refer(p, resp, rest, req, seqno);
13234 break;
13235 }
13236
13237 default:
13238 if ((resp >= 100) && (resp < 200)) {
13239 if (sipmethod == SIP_INVITE) {
13240 if (!ast_test_flag(req, SIP_PKT_IGNORE) && sip_cancel_destroy(p))
13241 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
13242 }
13243 }
13244 if ((resp >= 300) && (resp < 700)) {
13245 if ((option_verbose > 2) && (resp != 487))
13246 ast_verbose(VERBOSE_PREFIX_3 "Incoming call: Got SIP response %d \"%s\" back from %s\n", resp, rest, ast_inet_ntoa(p->sa.sin_addr));
13247 switch(resp) {
13248 case 488:
13249 case 603:
13250 case 500:
13251 case 502:
13252 case 503:
13253 case 504:
13254
13255
13256 if (sipmethod == SIP_INVITE && sip_cancel_destroy(p))
13257 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
13258 break;
13259 }
13260 }
13261 break;
13262 }
13263 }
13264 }
13265
13266
13267
13268
13269
13270
13271
13272 static void *sip_park_thread(void *stuff)
13273 {
13274 struct ast_channel *transferee, *transferer;
13275 struct sip_dual *d;
13276 struct sip_request req;
13277 int ext;
13278 int res;
13279
13280 d = stuff;
13281 transferee = d->chan1;
13282 transferer = d->chan2;
13283 copy_request(&req, &d->req);
13284 free(d);
13285
13286 if (!transferee || !transferer) {
13287 ast_log(LOG_ERROR, "Missing channels for parking! Transferer %s Transferee %s\n", transferer ? "<available>" : "<missing>", transferee ? "<available>" : "<missing>" );
13288 return NULL;
13289 }
13290 if (option_debug > 3)
13291 ast_log(LOG_DEBUG, "SIP Park: Transferer channel %s, Transferee %s\n", transferer->name, transferee->name);
13292
13293 ast_channel_lock(transferee);
13294 if (ast_do_masquerade(transferee)) {
13295 ast_log(LOG_WARNING, "Masquerade failed.\n");
13296 transmit_response(transferer->tech_pvt, "503 Internal error", &req);
13297 ast_channel_unlock(transferee);
13298 return NULL;
13299 }
13300 ast_channel_unlock(transferee);
13301
13302 res = ast_park_call(transferee, transferer, 0, &ext);
13303
13304
13305 #ifdef WHEN_WE_KNOW_THAT_THE_CLIENT_SUPPORTS_MESSAGE
13306 if (!res) {
13307 transmit_message_with_text(transferer->tech_pvt, "Unable to park call.\n");
13308 } else {
13309
13310 sprintf(buf, "Call parked on extension '%d'", ext);
13311 transmit_message_with_text(transferer->tech_pvt, buf);
13312 }
13313 #endif
13314
13315
13316
13317 transmit_response(transferer->tech_pvt, "202 Accepted", &req);
13318 if (!res) {
13319
13320 append_history(transferer->tech_pvt, "SIPpark","Parked call on %d", ext);
13321 transmit_notify_with_sipfrag(transferer->tech_pvt, d->seqno, "200 OK", TRUE);
13322 transferer->hangupcause = AST_CAUSE_NORMAL_CLEARING;
13323 ast_hangup(transferer);
13324 if (option_debug)
13325 ast_log(LOG_DEBUG, "SIP Call parked on extension '%d'\n", ext);
13326 } else {
13327 transmit_notify_with_sipfrag(transferer->tech_pvt, d->seqno, "503 Service Unavailable", TRUE);
13328 append_history(transferer->tech_pvt, "SIPpark","Parking failed\n");
13329 if (option_debug)
13330 ast_log(LOG_DEBUG, "SIP Call parked failed \n");
13331
13332 }
13333 return NULL;
13334 }
13335
13336
13337
13338
13339 static int sip_park(struct ast_channel *chan1, struct ast_channel *chan2, struct sip_request *req, int seqno)
13340 {
13341 struct sip_dual *d;
13342 struct ast_channel *transferee, *transferer;
13343
13344 pthread_t th;
13345
13346 transferee = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, chan1->accountcode, chan1->exten, chan1->context, chan1->amaflags, "Parking/%s", chan1->name);
13347 transferer = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, chan2->accountcode, chan2->exten, chan2->context, chan2->amaflags, "SIPPeer/%s", chan2->name);
13348 if ((!transferer) || (!transferee)) {
13349 if (transferee) {
13350 transferee->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
13351 ast_hangup(transferee);
13352 }
13353 if (transferer) {
13354 transferer->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
13355 ast_hangup(transferer);
13356 }
13357 return -1;
13358 }
13359
13360
13361 transferee->readformat = chan1->readformat;
13362 transferee->writeformat = chan1->writeformat;
13363
13364
13365 ast_channel_masquerade(transferee, chan1);
13366
13367
13368 ast_copy_string(transferee->context, chan1->context, sizeof(transferee->context));
13369 ast_copy_string(transferee->exten, chan1->exten, sizeof(transferee->exten));
13370 transferee->priority = chan1->priority;
13371
13372
13373
13374
13375
13376 transferer->readformat = chan2->readformat;
13377 transferer->writeformat = chan2->writeformat;
13378
13379
13380
13381
13382 while (ast_channel_trylock(chan2)) {
13383 struct sip_pvt *pvt = chan2->tech_pvt;
13384 DEADLOCK_AVOIDANCE(&pvt->lock);
13385 }
13386 ast_channel_masquerade(transferer, chan2);
13387 ast_channel_unlock(chan2);
13388
13389
13390 ast_copy_string(transferer->context, chan2->context, sizeof(transferer->context));
13391 ast_copy_string(transferer->exten, chan2->exten, sizeof(transferer->exten));
13392 transferer->priority = chan2->priority;
13393
13394 ast_channel_lock(transferer);
13395 if (ast_do_masquerade(transferer)) {
13396 ast_log(LOG_WARNING, "Masquerade failed :(\n");
13397 ast_channel_unlock(transferer);
13398 transferer->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
13399 ast_hangup(transferer);
13400 return -1;
13401 }
13402 ast_channel_unlock(transferer);
13403 if (!transferer || !transferee) {
13404 if (!transferer) {
13405 if (option_debug)
13406 ast_log(LOG_DEBUG, "No transferer channel, giving up parking\n");
13407 }
13408 if (!transferee) {
13409 if (option_debug)
13410 ast_log(LOG_DEBUG, "No transferee channel, giving up parking\n");
13411 }
13412 return -1;
13413 }
13414 if ((d = ast_calloc(1, sizeof(*d)))) {
13415 pthread_attr_t attr;
13416
13417 pthread_attr_init(&attr);
13418 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
13419
13420
13421 copy_request(&d->req, req);
13422 d->chan1 = transferee;
13423 d->chan2 = transferer;
13424 d->seqno = seqno;
13425 if (ast_pthread_create_background(&th, &attr, sip_park_thread, d) < 0) {
13426
13427 free(d);
13428
13429 pthread_attr_destroy(&attr);
13430 return 0;
13431 }
13432 pthread_attr_destroy(&attr);
13433 }
13434 return -1;
13435 }
13436
13437
13438
13439
13440 static void ast_quiet_chan(struct ast_channel *chan)
13441 {
13442 if (chan && chan->_state == AST_STATE_UP) {
13443 if (ast_test_flag(chan, AST_FLAG_MOH))
13444 ast_moh_stop(chan);
13445 else if (chan->generatordata)
13446 ast_deactivate_generator(chan);
13447 }
13448 }
13449
13450
13451
13452 static int attempt_transfer(struct sip_dual *transferer, struct sip_dual *target)
13453 {
13454 int res = 0;
13455 struct ast_channel *peera = NULL,
13456 *peerb = NULL,
13457 *peerc = NULL,
13458 *peerd = NULL;
13459
13460
13461
13462
13463 if (option_debug > 3) {
13464 ast_log(LOG_DEBUG, "Sip transfer:--------------------\n");
13465 if (transferer->chan1)
13466 ast_log(LOG_DEBUG, "-- Transferer to PBX channel: %s State %s\n", transferer->chan1->name, ast_state2str(transferer->chan1->_state));
13467 else
13468 ast_log(LOG_DEBUG, "-- No transferer first channel - odd??? \n");
13469 if (target->chan1)
13470 ast_log(LOG_DEBUG, "-- Transferer to PBX second channel (target): %s State %s\n", target->chan1->name, ast_state2str(target->chan1->_state));
13471 else
13472 ast_log(LOG_DEBUG, "-- No target first channel ---\n");
13473 if (transferer->chan2)
13474 ast_log(LOG_DEBUG, "-- Bridged call to transferee: %s State %s\n", transferer->chan2->name, ast_state2str(transferer->chan2->_state));
13475 else
13476 ast_log(LOG_DEBUG, "-- No bridged call to transferee\n");
13477 if (target->chan2)
13478 ast_log(LOG_DEBUG, "-- Bridged call to transfer target: %s State %s\n", target->chan2 ? target->chan2->name : "<none>", target->chan2 ? ast_state2str(target->chan2->_state) : "(none)");
13479 else
13480 ast_log(LOG_DEBUG, "-- No target second channel ---\n");
13481 ast_log(LOG_DEBUG, "-- END Sip transfer:--------------------\n");
13482 }
13483 if (transferer->chan2) {
13484 peera = transferer->chan1;
13485 peerb = target->chan1;
13486 peerc = transferer->chan2;
13487 peerd = target->chan2;
13488 if (option_debug > 2)
13489 ast_log(LOG_DEBUG, "SIP transfer: Four channels to handle\n");
13490 } else if (target->chan2) {
13491 peera = target->chan1;
13492 peerb = transferer->chan1;
13493 peerc = target->chan2;
13494 peerd = transferer->chan2;
13495 if (option_debug > 2)
13496 ast_log(LOG_DEBUG, "SIP transfer: Three channels to handle\n");
13497 }
13498
13499 if (peera && peerb && peerc && (peerb != peerc)) {
13500 ast_quiet_chan(peera);
13501 ast_quiet_chan(peerb);
13502 ast_quiet_chan(peerc);
13503 if (peerd)
13504 ast_quiet_chan(peerd);
13505
13506 if (option_debug > 3)
13507 ast_log(LOG_DEBUG, "SIP transfer: trying to masquerade %s into %s\n", peerc->name, peerb->name);
13508 if (ast_channel_masquerade(peerb, peerc)) {
13509 ast_log(LOG_WARNING, "Failed to masquerade %s into %s\n", peerb->name, peerc->name);
13510 res = -1;
13511 } else
13512 ast_log(LOG_DEBUG, "SIP transfer: Succeeded to masquerade channels.\n");
13513 return res;
13514 } else {
13515 ast_log(LOG_NOTICE, "SIP Transfer attempted with no appropriate bridged calls to transfer\n");
13516 if (transferer->chan1)
13517 ast_softhangup_nolock(transferer->chan1, AST_SOFTHANGUP_DEV);
13518 if (target->chan1)
13519 ast_softhangup_nolock(target->chan1, AST_SOFTHANGUP_DEV);
13520 return -2;
13521 }
13522 return 0;
13523 }
13524
13525
13526
13527
13528
13529
13530 static const char *gettag(const struct sip_request *req, const char *header, char *tagbuf, int tagbufsize)
13531 {
13532 const char *thetag;
13533
13534 if (!tagbuf)
13535 return NULL;
13536 tagbuf[0] = '\0';
13537 thetag = get_header(req, header);
13538 thetag = strcasestr(thetag, ";tag=");
13539 if (thetag) {
13540 thetag += 5;
13541 ast_copy_string(tagbuf, thetag, tagbufsize);
13542 return strsep(&tagbuf, ";");
13543 }
13544 return NULL;
13545 }
13546
13547
13548 static int handle_request_notify(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int seqno, char *e)
13549 {
13550
13551
13552 int res = 0;
13553 const char *event = get_header(req, "Event");
13554 char *eventid = NULL;
13555 char *sep;
13556
13557 if( (sep = strchr(event, ';')) ) {
13558 *sep++ = '\0';
13559 eventid = sep;
13560 }
13561
13562 if (option_debug > 1 && sipdebug)
13563 ast_log(LOG_DEBUG, "Got NOTIFY Event: %s\n", event);
13564
13565 if (strcmp(event, "refer")) {
13566
13567
13568 transmit_response(p, "489 Bad event", req);
13569 res = -1;
13570 } else {
13571
13572
13573
13574
13575
13576 char buf[1024];
13577 char *cmd, *code;
13578 int respcode;
13579 int success = TRUE;
13580
13581
13582
13583
13584
13585
13586
13587
13588 if (strncasecmp(get_header(req, "Content-Type"), "message/sipfrag", strlen("message/sipfrag"))) {
13589
13590 transmit_response(p, "400 Bad request", req);
13591 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
13592 return -1;
13593 }
13594
13595
13596 if (get_msg_text(buf, sizeof(buf), req)) {
13597 ast_log(LOG_WARNING, "Unable to retrieve attachment from NOTIFY %s\n", p->callid);
13598 transmit_response(p, "400 Bad request", req);
13599 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
13600 return -1;
13601 }
13602
13603
13604
13605
13606
13607
13608
13609
13610
13611
13612
13613
13614
13615
13616
13617
13618
13619
13620
13621
13622
13623 if (option_debug > 2)
13624 ast_log(LOG_DEBUG, "* SIP Transfer NOTIFY Attachment: \n---%s\n---\n", buf);
13625 cmd = ast_skip_blanks(buf);
13626 code = cmd;
13627
13628 while(*code && (*code > 32)) {
13629 code++;
13630 }
13631 *code++ = '\0';
13632 code = ast_skip_blanks(code);
13633 sep = code;
13634 sep++;
13635 while(*sep && (*sep > 32)) {
13636 sep++;
13637 }
13638 *sep++ = '\0';
13639 respcode = atoi(code);
13640 switch (respcode) {
13641 case 100:
13642 case 101:
13643
13644 break;
13645 case 183:
13646
13647 break;
13648 case 200:
13649
13650 break;
13651 case 301:
13652 case 302:
13653
13654 success = FALSE;
13655 break;
13656 case 503:
13657
13658 success = FALSE;
13659 break;
13660 case 603:
13661
13662 success = FALSE;
13663 break;
13664 }
13665 if (!success) {
13666 ast_log(LOG_NOTICE, "Transfer failed. Sorry. Nothing further to do with this call\n");
13667 }
13668
13669
13670 transmit_response(p, "200 OK", req);
13671 };
13672
13673 if (!p->lastinvite)
13674 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
13675
13676 return res;
13677 }
13678
13679
13680 static int handle_request_options(struct sip_pvt *p, struct sip_request *req)
13681 {
13682 int res;
13683
13684
13685
13686
13687 if (p->lastinvite) {
13688
13689 transmit_response_with_allow(p, "200 OK", req, 0);
13690 return 0;
13691 }
13692
13693 res = get_destination(p, req);
13694 build_contact(p);
13695
13696 if (ast_strlen_zero(p->context))
13697 ast_string_field_set(p, context, default_context);
13698
13699 if (ast_shutting_down())
13700 transmit_response_with_allow(p, "503 Unavailable", req, 0);
13701 else if (res < 0)
13702 transmit_response_with_allow(p, "404 Not Found", req, 0);
13703 else
13704 transmit_response_with_allow(p, "200 OK", req, 0);
13705
13706
13707
13708 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
13709
13710 return res;
13711 }
13712
13713
13714
13715 static int handle_invite_replaces(struct sip_pvt *p, struct sip_request *req, int debug, int ignore, int seqno, struct sockaddr_in *sin)
13716 {
13717 struct ast_frame *f;
13718 int earlyreplace = 0;
13719 int oneleggedreplace = 0;
13720 struct ast_channel *c = p->owner;
13721 struct ast_channel *replacecall = p->refer->refer_call->owner;
13722 struct ast_channel *targetcall;
13723
13724
13725 if (replacecall->_state == AST_STATE_RING)
13726 earlyreplace = 1;
13727
13728
13729 if (!(targetcall = ast_bridged_channel(replacecall))) {
13730
13731 if (!earlyreplace) {
13732 if (option_debug > 1)
13733 ast_log(LOG_DEBUG, " Attended transfer attempted to replace call with no bridge (maybe ringing). Channel %s!\n", replacecall->name);
13734 oneleggedreplace = 1;
13735 }
13736 }
13737 if (option_debug > 3 && targetcall && targetcall->_state == AST_STATE_RINGING)
13738 ast_log(LOG_DEBUG, "SIP transfer: Target channel is in ringing state\n");
13739
13740 if (option_debug > 3) {
13741 if (targetcall)
13742 ast_log(LOG_DEBUG, "SIP transfer: Invite Replace incoming channel should bridge to channel %s while hanging up channel %s\n", targetcall->name, replacecall->name);
13743 else
13744 ast_log(LOG_DEBUG, "SIP transfer: Invite Replace incoming channel should replace and hang up channel %s (one call leg)\n", replacecall->name);
13745 }
13746
13747 if (ignore) {
13748 ast_log(LOG_NOTICE, "Ignoring this INVITE with replaces in a stupid way.\n");
13749
13750
13751
13752 transmit_response_with_sdp(p, "200 OK", req, XMIT_RELIABLE);
13753
13754 ast_channel_unlock(c);
13755 ast_mutex_unlock(&p->refer->refer_call->lock);
13756 return 1;
13757 }
13758 if (!c) {
13759
13760 ast_log(LOG_ERROR, "Unable to create new channel. Invite/replace failed.\n");
13761 transmit_response_reliable(p, "503 Service Unavailable", req);
13762 append_history(p, "Xfer", "INVITE/Replace Failed. No new channel.");
13763 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
13764 ast_mutex_unlock(&p->refer->refer_call->lock);
13765 return 1;
13766 }
13767 append_history(p, "Xfer", "INVITE/Replace received");
13768
13769
13770
13771
13772
13773
13774
13775
13776
13777
13778
13779 transmit_response(p, "100 Trying", req);
13780 ast_setstate(c, AST_STATE_RING);
13781
13782
13783
13784
13785
13786 transmit_response_with_sdp(p, "200 OK", req, XMIT_RELIABLE);
13787
13788 ast_setstate(c, AST_STATE_UP);
13789
13790
13791 ast_quiet_chan(replacecall);
13792 ast_quiet_chan(targetcall);
13793 if (option_debug > 3)
13794 ast_log(LOG_DEBUG, "Invite/Replaces: preparing to masquerade %s into %s\n", c->name, replacecall->name);
13795
13796 if (!oneleggedreplace)
13797 ast_channel_unlock(c);
13798
13799
13800 ast_mutex_unlock(&p->refer->refer_call->lock);
13801
13802
13803 if (! earlyreplace && ! oneleggedreplace )
13804 ast_set_flag(&p->refer->refer_call->flags[0], SIP_DEFER_BYE_ON_TRANSFER);
13805
13806
13807 if(ast_channel_masquerade(replacecall, c))
13808 ast_log(LOG_ERROR, "Failed to masquerade C into Replacecall\n");
13809 else if (option_debug > 3)
13810 ast_log(LOG_DEBUG, "Invite/Replaces: Going to masquerade %s into %s\n", c->name, replacecall->name);
13811
13812
13813
13814
13815
13816 ast_channel_unlock(c);
13817
13818 if (earlyreplace || oneleggedreplace ) {
13819
13820 if ((f = ast_read(replacecall))) {
13821 ast_frfree(f);
13822 f = NULL;
13823 if (option_debug > 3)
13824 ast_log(LOG_DEBUG, "Invite/Replace: Could successfully read frame from RING channel!\n");
13825 } else {
13826 ast_log(LOG_WARNING, "Invite/Replace: Could not read frame from RING channel \n");
13827 }
13828 c->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
13829 if (!oneleggedreplace)
13830 ast_channel_unlock(replacecall);
13831 } else {
13832 if ((f = ast_read(replacecall))) {
13833
13834 ast_frfree(f);
13835 f = NULL;
13836 if (option_debug > 2)
13837 ast_log(LOG_DEBUG, "Invite/Replace: Could successfully read frame from channel! Masq done.\n");
13838 } else {
13839 ast_log(LOG_WARNING, "Invite/Replace: Could not read frame from channel. Transfer failed\n");
13840 }
13841 ast_channel_unlock(replacecall);
13842 }
13843 ast_mutex_unlock(&p->refer->refer_call->lock);
13844
13845 ast_setstate(c, AST_STATE_DOWN);
13846 if (option_debug > 3) {
13847 struct ast_channel *test;
13848 ast_log(LOG_DEBUG, "After transfer:----------------------------\n");
13849 ast_log(LOG_DEBUG, " -- C: %s State %s\n", c->name, ast_state2str(c->_state));
13850 if (replacecall)
13851 ast_log(LOG_DEBUG, " -- replacecall: %s State %s\n", replacecall->name, ast_state2str(replacecall->_state));
13852 if (p->owner) {
13853 ast_log(LOG_DEBUG, " -- P->owner: %s State %s\n", p->owner->name, ast_state2str(p->owner->_state));
13854 test = ast_bridged_channel(p->owner);
13855 if (test)
13856 ast_log(LOG_DEBUG, " -- Call bridged to P->owner: %s State %s\n", test->name, ast_state2str(test->_state));
13857 else
13858 ast_log(LOG_DEBUG, " -- No call bridged to C->owner \n");
13859 } else
13860 ast_log(LOG_DEBUG, " -- No channel yet \n");
13861 ast_log(LOG_DEBUG, "End After transfer:----------------------------\n");
13862 }
13863
13864 ast_channel_unlock(p->owner);
13865 if (!oneleggedreplace)
13866 ast_mutex_unlock(&p->lock);
13867
13868
13869 c->tech_pvt = NULL;
13870 ast_hangup(c);
13871 return 0;
13872 }
13873
13874
13875
13876
13877
13878
13879
13880
13881
13882
13883
13884
13885
13886
13887
13888
13889
13890 static int sip_uri_params_cmp(const char *input1, const char *input2)
13891 {
13892 char *params1 = ast_strdupa(input1);
13893 char *params2 = ast_strdupa(input2);
13894 char *pos1;
13895 char *pos2;
13896 int maddrmatch = 0;
13897 int ttlmatch = 0;
13898 int usermatch = 0;
13899 int methodmatch = 0;
13900
13901
13902
13903
13904 if (ast_strlen_zero(params1) && ast_strlen_zero(params2)) {
13905 return 0;
13906 }
13907
13908 pos1 = params1;
13909 while (!ast_strlen_zero(pos1)) {
13910 char *name1 = pos1;
13911 char *value1 = strchr(pos1, '=');
13912 char *semicolon1 = strchr(pos1, ';');
13913 int matched = 0;
13914 if (semicolon1) {
13915 *semicolon1++ = '\0';
13916 }
13917 if (!value1) {
13918 goto fail;
13919 }
13920 *value1++ = '\0';
13921
13922
13923
13924
13925
13926 pos2 = ast_strdupa(params2);
13927 while (!ast_strlen_zero(pos2)) {
13928 char *name2 = pos2;
13929 char *value2 = strchr(pos2, '=');
13930 char *semicolon2 = strchr(pos2, ';');
13931 if (semicolon2) {
13932 *semicolon2++ = '\0';
13933 }
13934 if (!value2) {
13935 goto fail;
13936 }
13937 *value2++ = '\0';
13938 if (!strcasecmp(name1, name2)) {
13939 if (strcasecmp(value1, value2)) {
13940 goto fail;
13941 } else {
13942 matched = 1;
13943 break;
13944 }
13945 }
13946 pos2 = semicolon2;
13947 }
13948
13949 if (!strcasecmp(name1, "maddr")) {
13950 if (matched) {
13951 maddrmatch = 1;
13952 } else {
13953 goto fail;
13954 }
13955 } else if (!strcasecmp(name1, "ttl")) {
13956 if (matched) {
13957 ttlmatch = 1;
13958 } else {
13959 goto fail;
13960 }
13961 } else if (!strcasecmp(name1, "user")) {
13962 if (matched) {
13963 usermatch = 1;
13964 } else {
13965 goto fail;
13966 }
13967 } else if (!strcasecmp(name1, "method")) {
13968 if (matched) {
13969 methodmatch = 1;
13970 } else {
13971 goto fail;
13972 }
13973 }
13974 pos1 = semicolon1;
13975 }
13976
13977
13978
13979
13980
13981 pos2 = params2;
13982 while (!ast_strlen_zero(pos2)) {
13983 char *name2 = pos2;
13984 char *value2 = strchr(pos2, '=');
13985 char *semicolon2 = strchr(pos2, ';');
13986 if (semicolon2) {
13987 *semicolon2++ = '\0';
13988 }
13989 if (!value2) {
13990 goto fail;
13991 }
13992 *value2++ = '\0';
13993 if ((!strcasecmp(name2, "maddr") && !maddrmatch) ||
13994 (!strcasecmp(name2, "ttl") && !ttlmatch) ||
13995 (!strcasecmp(name2, "user") && !usermatch) ||
13996 (!strcasecmp(name2, "method") && !methodmatch)) {
13997 goto fail;
13998 }
13999 }
14000 return 0;
14001
14002 fail:
14003 return 1;
14004 }
14005
14006
14007
14008
14009
14010
14011
14012
14013
14014
14015
14016
14017 static int sip_uri_headers_cmp(const char *input1, const char *input2)
14018 {
14019 char *headers1 = ast_strdupa(input1);
14020 char *headers2 = ast_strdupa(input2);
14021 int zerolength1 = ast_strlen_zero(headers1);
14022 int zerolength2 = ast_strlen_zero(headers2);
14023 int different = 0;
14024 char *header1;
14025
14026 if ((zerolength1 && !zerolength2) ||
14027 (zerolength2 && !zerolength1))
14028 return 1;
14029
14030 if (zerolength1 && zerolength2)
14031 return 0;
14032
14033
14034
14035
14036
14037 if (strlen(headers1) != strlen(headers2)) {
14038 return 1;
14039 }
14040
14041 for (header1 = strsep(&headers1, "&"); header1; header1 = strsep(&headers1, "&")) {
14042 if (!strcasestr(headers2, header1)) {
14043 different = 1;
14044 break;
14045 }
14046 }
14047
14048 return different;
14049 }
14050
14051 static int sip_uri_cmp(const char *input1, const char *input2)
14052 {
14053 char *uri1 = ast_strdupa(input1);
14054 char *uri2 = ast_strdupa(input2);
14055 char *host1;
14056 char *host2;
14057 char *params1;
14058 char *params2;
14059 char *headers1;
14060 char *headers2;
14061
14062
14063
14064
14065 strsep(&uri1, ":");
14066 strsep(&uri2, ":");
14067
14068 if ((host1 = strchr(uri1, '@'))) {
14069 *host1++ = '\0';
14070 }
14071 if ((host2 = strchr(uri2, '@'))) {
14072 *host2++ = '\0';
14073 }
14074
14075
14076
14077
14078 if ((host1 && !host2) ||
14079 (host2 && !host1) ||
14080 (host1 && host2 && strcmp(uri1, uri2))) {
14081 return 1;
14082 }
14083
14084 if (!host1)
14085 host1 = uri1;
14086 if (!host2)
14087 host2 = uri2;
14088
14089
14090
14091
14092
14093 if ((params1 = strchr(host1, ';'))) {
14094 *params1++ = '\0';
14095 }
14096 if ((params2 = strchr(host2, ';'))) {
14097 *params2++ = '\0';
14098 }
14099
14100
14101
14102
14103 if ((headers1 = strchr(S_OR(params1, host1), '?'))) {
14104 *headers1++ = '\0';
14105 }
14106 if ((headers2 = strchr(S_OR(params2, host2), '?'))) {
14107 *headers2++ = '\0';
14108 }
14109
14110
14111
14112
14113
14114
14115
14116
14117
14118
14119
14120 if (strcasecmp(host1, host2)) {
14121 return 1;
14122 }
14123
14124
14125 if (sip_uri_headers_cmp(headers1, headers2)) {
14126 return 1;
14127 }
14128
14129
14130 return sip_uri_params_cmp(params1, params2);
14131 }
14132
14133
14134
14135
14136
14137
14138
14139
14140 static int handle_request_invite(struct sip_pvt *p, struct sip_request *req, int debug, int seqno, struct sockaddr_in *sin, int *recount, char *e, int *nounlock)
14141 {
14142 int res = 1;
14143 int gotdest;
14144 const char *p_replaces;
14145 char *replace_id = NULL;
14146 const char *required;
14147 unsigned int required_profile = 0;
14148 struct ast_channel *c = NULL;
14149 int reinvite = 0;
14150
14151
14152 if (!p->sipoptions) {
14153 const char *supported = get_header(req, "Supported");
14154 if (!ast_strlen_zero(supported))
14155 parse_sip_options(p, supported);
14156 }
14157
14158
14159 required = get_header(req, "Require");
14160 if (!ast_strlen_zero(required)) {
14161 required_profile = parse_sip_options(NULL, required);
14162 if (required_profile && required_profile != SIP_OPT_REPLACES) {
14163
14164 transmit_response_with_unsupported(p, "420 Bad extension (unsupported)", req, required);
14165 ast_log(LOG_WARNING,"Received SIP INVITE with unsupported required extension: %s\n", required);
14166 p->invitestate = INV_COMPLETED;
14167 if (!p->lastinvite)
14168 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14169 return -1;
14170 }
14171 }
14172
14173
14174 if (ast_test_flag(&p->flags[0], SIP_OUTGOING) && p->owner && (p->owner->_state != AST_STATE_UP)) {
14175
14176
14177
14178
14179
14180 int different;
14181 if (pedanticsipchecking)
14182 different = sip_uri_cmp(p->initreq.rlPart2, req->rlPart2);
14183 else
14184 different = strcmp(p->initreq.rlPart2, req->rlPart2);
14185 if (!different) {
14186 transmit_response(p, "482 Loop Detected", req);
14187 p->invitestate = INV_COMPLETED;
14188 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14189 return 0;
14190 } else {
14191
14192
14193
14194
14195 char *uri = ast_strdupa(req->rlPart2);
14196 char *at = strchr(uri, '@');
14197 char *peerorhost;
14198 struct sip_pkt *pkt = NULL;
14199 if (option_debug > 2) {
14200 ast_log(LOG_DEBUG, "Potential spiral detected. Original RURI was %s, new RURI is %s\n", p->initreq.rlPart2, req->rlPart2);
14201 }
14202 if (at) {
14203 *at = '\0';
14204 }
14205
14206 if ((peerorhost = strchr(uri, ':'))) {
14207 *peerorhost++ = '\0';
14208 }
14209 create_addr(p, peerorhost);
14210 ast_string_field_free(p, theirtag);
14211 for (pkt = p->packets; pkt; pkt = pkt->next) {
14212 if (pkt->seqno == p->icseq && pkt->method == SIP_INVITE) {
14213 AST_SCHED_DEL(sched, pkt->retransid);
14214 }
14215 }
14216 return transmit_invite(p, SIP_INVITE, 1, 3);
14217 }
14218 }
14219
14220 if (!ast_test_flag(req, SIP_PKT_IGNORE) && p->pendinginvite) {
14221
14222 transmit_response_reliable(p, "491 Request Pending", req);
14223 if (option_debug)
14224 ast_log(LOG_DEBUG, "Got INVITE on call where we already have pending INVITE, deferring that - %s\n", p->callid);
14225
14226 return 0;
14227 }
14228
14229 p_replaces = get_header(req, "Replaces");
14230 if (!ast_strlen_zero(p_replaces)) {
14231
14232 char *ptr;
14233 char *fromtag = NULL;
14234 char *totag = NULL;
14235 char *start, *to;
14236 int error = 0;
14237
14238 if (p->owner) {
14239 if (option_debug > 2)
14240 ast_log(LOG_DEBUG, "INVITE w Replaces on existing call? Refusing action. [%s]\n", p->callid);
14241 transmit_response_reliable(p, "400 Bad request", req);
14242
14243 return -1;
14244 }
14245
14246 if (sipdebug && option_debug > 2)
14247 ast_log(LOG_DEBUG, "INVITE part of call transfer. Replaces [%s]\n", p_replaces);
14248
14249 replace_id = ast_strdupa(p_replaces);
14250 ast_uri_decode(replace_id);
14251
14252 if (!p->refer && !sip_refer_allocate(p)) {
14253 transmit_response_reliable(p, "500 Server Internal Error", req);
14254 append_history(p, "Xfer", "INVITE/Replace Failed. Out of memory.");
14255 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14256 p->invitestate = INV_COMPLETED;
14257 return -1;
14258 }
14259
14260
14261
14262
14263
14264
14265
14266
14267
14268
14269 replace_id = ast_skip_blanks(replace_id);
14270
14271 start = replace_id;
14272 while ( (ptr = strsep(&start, ";")) ) {
14273 ptr = ast_skip_blanks(ptr);
14274 if ( (to = strcasestr(ptr, "to-tag=") ) )
14275 totag = to + 7;
14276 else if ( (to = strcasestr(ptr, "from-tag=") ) ) {
14277 fromtag = to + 9;
14278 fromtag = strsep(&fromtag, "&");
14279 }
14280 }
14281
14282 if (sipdebug && option_debug > 3)
14283 ast_log(LOG_DEBUG,"Invite/replaces: Will use Replace-Call-ID : %s Fromtag: %s Totag: %s\n", replace_id, fromtag ? fromtag : "<no from tag>", totag ? totag : "<no to tag>");
14284
14285
14286
14287
14288
14289 if ((p->refer->refer_call = get_sip_pvt_byid_locked(replace_id, totag, fromtag)) == NULL) {
14290 ast_log(LOG_NOTICE, "Supervised transfer attempted to replace non-existent call id (%s)!\n", replace_id);
14291 transmit_response_reliable(p, "481 Call Leg Does Not Exist (Replaces)", req);
14292 error = 1;
14293 }
14294
14295
14296
14297
14298
14299
14300
14301 if (p->refer->refer_call == p) {
14302 ast_log(LOG_NOTICE, "INVITE with replaces into it's own call id (%s == %s)!\n", replace_id, p->callid);
14303 p->refer->refer_call = NULL;
14304 transmit_response_reliable(p, "400 Bad request", req);
14305 error = 1;
14306 }
14307
14308 if (!error && !p->refer->refer_call->owner) {
14309
14310 ast_log(LOG_NOTICE, "Supervised transfer attempted to replace non-existing call id (%s)!\n", replace_id);
14311
14312 transmit_response_reliable(p, "481 Call Leg Does Not Exist (Replace)", req);
14313 error = 1;
14314 }
14315
14316 if (!error && p->refer->refer_call->owner->_state != AST_STATE_RINGING && p->refer->refer_call->owner->_state != AST_STATE_RING && p->refer->refer_call->owner->_state != AST_STATE_UP ) {
14317 ast_log(LOG_NOTICE, "Supervised transfer attempted to replace non-ringing or active call id (%s)!\n", replace_id);
14318 transmit_response_reliable(p, "603 Declined (Replaces)", req);
14319 error = 1;
14320 }
14321
14322 if (error) {
14323 append_history(p, "Xfer", "INVITE/Replace Failed.");
14324 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14325 ast_mutex_unlock(&p->lock);
14326 if (p->refer->refer_call) {
14327 ast_mutex_unlock(&p->refer->refer_call->lock);
14328 ast_channel_unlock(p->refer->refer_call->owner);
14329 }
14330 p->invitestate = INV_COMPLETED;
14331 return -1;
14332 }
14333 }
14334
14335
14336
14337
14338
14339 if (!ast_test_flag(req, SIP_PKT_IGNORE)) {
14340 int newcall = (p->initreq.headers ? TRUE : FALSE);
14341
14342 if (sip_cancel_destroy(p))
14343 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
14344
14345 p->pendinginvite = seqno;
14346 check_via(p, req);
14347
14348 copy_request(&p->initreq, req);
14349 if (!p->owner) {
14350 if (debug)
14351 ast_verbose("Using INVITE request as basis request - %s\n", p->callid);
14352 if (newcall)
14353 append_history(p, "Invite", "New call: %s", p->callid);
14354 parse_ok_contact(p, req);
14355 } else {
14356 ast_clear_flag(&p->flags[0], SIP_OUTGOING);
14357
14358 if (find_sdp(req)) {
14359 if (process_sdp(p, req)) {
14360 transmit_response_reliable(p, "488 Not acceptable here", req);
14361 if (!p->lastinvite)
14362 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14363 return -1;
14364 }
14365 } else {
14366 p->jointcapability = p->capability;
14367 if (option_debug > 2)
14368 ast_log(LOG_DEBUG, "Hm.... No sdp for the moment\n");
14369
14370
14371
14372 if (ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD))
14373 change_hold_state(p, req, FALSE, 0);
14374 }
14375 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
14376 append_history(p, "ReInv", "Re-invite received");
14377 }
14378 } else if (debug)
14379 ast_verbose("Ignoring this INVITE request\n");
14380
14381
14382 if (!p->lastinvite && !ast_test_flag(req, SIP_PKT_IGNORE) && !p->owner) {
14383
14384
14385 res = check_user(p, req, SIP_INVITE, e, XMIT_RELIABLE, sin);
14386 if (res == AUTH_CHALLENGE_SENT) {
14387 p->invitestate = INV_COMPLETED;
14388 return 0;
14389 }
14390 if (res < 0) {
14391 if (res == AUTH_FAKE_AUTH) {
14392 ast_log(LOG_NOTICE, "Sending fake auth rejection for user %s\n", get_header(req, "From"));
14393 transmit_fake_auth_response(p, req, 1);
14394 } else {
14395 ast_log(LOG_NOTICE, "Failed to authenticate user %s\n", get_header(req, "From"));
14396 transmit_response_reliable(p, "403 Forbidden", req);
14397 }
14398 p->invitestate = INV_COMPLETED;
14399 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14400 ast_string_field_free(p, theirtag);
14401 return 0;
14402 }
14403
14404
14405 if (find_sdp(req)) {
14406 if (process_sdp(p, req)) {
14407
14408 transmit_response_reliable(p, "488 Not acceptable here", req);
14409 p->invitestate = INV_COMPLETED;
14410 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14411 if (option_debug)
14412 ast_log(LOG_DEBUG, "No compatible codecs for this SIP call.\n");
14413 return -1;
14414 }
14415 } else {
14416 p->jointcapability = p->capability;
14417 if (option_debug > 1)
14418 ast_log(LOG_DEBUG, "No SDP in Invite, third party call control\n");
14419 }
14420
14421
14422
14423 if (p->owner)
14424 ast_queue_frame(p->owner, &ast_null_frame);
14425
14426
14427
14428 if (ast_strlen_zero(p->context))
14429 ast_string_field_set(p, context, default_context);
14430
14431
14432
14433 if (option_debug)
14434 ast_log(LOG_DEBUG, "Checking SIP call limits for device %s\n", p->username);
14435 if ((res = update_call_counter(p, INC_CALL_LIMIT))) {
14436 if (res < 0) {
14437 ast_log(LOG_NOTICE, "Failed to place call for user %s, too many calls\n", p->username);
14438 transmit_response_reliable(p, "480 Temporarily Unavailable (Call limit) ", req);
14439 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14440 p->invitestate = INV_COMPLETED;
14441 }
14442 return 0;
14443 }
14444 gotdest = get_destination(p, NULL);
14445 get_rdnis(p, NULL);
14446 extract_uri(p, req);
14447 build_contact(p);
14448
14449 if (p->rtp) {
14450 ast_rtp_setdtmf(p->rtp, ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833);
14451 ast_rtp_setdtmfcompensate(p->rtp, ast_test_flag(&p->flags[1], SIP_PAGE2_RFC2833_COMPENSATE));
14452 }
14453
14454 if (!replace_id && gotdest) {
14455 if (gotdest == 1 && ast_test_flag(&p->flags[1], SIP_PAGE2_ALLOWOVERLAP))
14456 transmit_response_reliable(p, "484 Address Incomplete", req);
14457 else {
14458 char *decoded_exten = ast_strdupa(p->exten);
14459
14460 transmit_response_reliable(p, "404 Not Found", req);
14461 ast_uri_decode(decoded_exten);
14462 ast_log(LOG_NOTICE, "Call from '%s' to extension"
14463 " '%s' rejected because extension not found.\n",
14464 S_OR(p->username, p->peername), decoded_exten);
14465 }
14466 p->invitestate = INV_COMPLETED;
14467 update_call_counter(p, DEC_CALL_LIMIT);
14468 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14469 return 0;
14470 } else {
14471
14472
14473 if (ast_strlen_zero(p->exten))
14474 ast_string_field_set(p, exten, "s");
14475
14476
14477 make_our_tag(p->tag, sizeof(p->tag));
14478
14479 c = sip_new(p, AST_STATE_DOWN, S_OR(p->username, NULL));
14480 *recount = 1;
14481
14482
14483 build_route(p, req, 0);
14484
14485 if (c) {
14486
14487 ast_channel_lock(c);
14488 }
14489 }
14490 } else {
14491 if (option_debug > 1 && sipdebug) {
14492 if (!ast_test_flag(req, SIP_PKT_IGNORE))
14493 ast_log(LOG_DEBUG, "Got a SIP re-invite for call %s\n", p->callid);
14494 else
14495 ast_log(LOG_DEBUG, "Got a SIP re-transmit of INVITE for call %s\n", p->callid);
14496 }
14497 if (!ast_test_flag(req, SIP_PKT_IGNORE))
14498 reinvite = 1;
14499 c = p->owner;
14500 }
14501
14502 if (!ast_test_flag(req, SIP_PKT_IGNORE) && p)
14503 p->lastinvite = seqno;
14504
14505 if (replace_id) {
14506
14507 if (sipdebug && option_debug > 3)
14508 ast_log(LOG_DEBUG, "Sending this call to the invite/replcaes handler %s\n", p->callid);
14509 return handle_invite_replaces(p, req, debug, ast_test_flag(req, SIP_PKT_IGNORE), seqno, sin);
14510 }
14511
14512
14513 if (c) {
14514 switch(c->_state) {
14515 case AST_STATE_DOWN:
14516 if (option_debug > 1)
14517 ast_log(LOG_DEBUG, "%s: New call is still down.... Trying... \n", c->name);
14518 transmit_response(p, "100 Trying", req);
14519 p->invitestate = INV_PROCEEDING;
14520 ast_setstate(c, AST_STATE_RING);
14521 if (strcmp(p->exten, ast_pickup_ext())) {
14522 enum ast_pbx_result res;
14523
14524 res = ast_pbx_start(c);
14525
14526 switch(res) {
14527 case AST_PBX_FAILED:
14528 ast_log(LOG_WARNING, "Failed to start PBX :(\n");
14529 p->invitestate = INV_COMPLETED;
14530 if (ast_test_flag(req, SIP_PKT_IGNORE))
14531 transmit_response(p, "503 Unavailable", req);
14532 else
14533 transmit_response_reliable(p, "503 Unavailable", req);
14534 break;
14535 case AST_PBX_CALL_LIMIT:
14536 ast_log(LOG_WARNING, "Failed to start PBX (call limit reached) \n");
14537 p->invitestate = INV_COMPLETED;
14538 if (ast_test_flag(req, SIP_PKT_IGNORE))
14539 transmit_response(p, "480 Temporarily Unavailable", req);
14540 else
14541 transmit_response_reliable(p, "480 Temporarily Unavailable", req);
14542 break;
14543 case AST_PBX_SUCCESS:
14544
14545 break;
14546 }
14547
14548 if (res) {
14549
14550
14551 ast_mutex_unlock(&c->lock);
14552 ast_mutex_unlock(&p->lock);
14553 ast_hangup(c);
14554 ast_mutex_lock(&p->lock);
14555 c = NULL;
14556 }
14557 } else {
14558 ast_channel_unlock(c);
14559 *nounlock = 1;
14560 if (ast_pickup_call(c)) {
14561 ast_log(LOG_NOTICE, "Nothing to pick up for %s\n", p->callid);
14562 if (ast_test_flag(req, SIP_PKT_IGNORE))
14563 transmit_response(p, "503 Unavailable", req);
14564 else
14565 transmit_response_reliable(p, "503 Unavailable", req);
14566 sip_alreadygone(p);
14567
14568 ast_mutex_unlock(&p->lock);
14569 c->hangupcause = AST_CAUSE_CALL_REJECTED;
14570 } else {
14571 ast_mutex_unlock(&p->lock);
14572 ast_setstate(c, AST_STATE_DOWN);
14573 c->hangupcause = AST_CAUSE_NORMAL_CLEARING;
14574 }
14575 p->invitestate = INV_COMPLETED;
14576 ast_hangup(c);
14577 ast_mutex_lock(&p->lock);
14578 c = NULL;
14579 }
14580 break;
14581 case AST_STATE_RING:
14582 transmit_response(p, "100 Trying", req);
14583 p->invitestate = INV_PROCEEDING;
14584 break;
14585 case AST_STATE_RINGING:
14586 transmit_response(p, "180 Ringing", req);
14587 p->invitestate = INV_PROCEEDING;
14588 break;
14589 case AST_STATE_UP:
14590 if (option_debug > 1)
14591 ast_log(LOG_DEBUG, "%s: This call is UP.... \n", c->name);
14592
14593 transmit_response(p, "100 Trying", req);
14594
14595 if (p->t38.state == T38_PEER_REINVITE) {
14596 struct ast_channel *bridgepeer = NULL;
14597 struct sip_pvt *bridgepvt = NULL;
14598
14599 if ((bridgepeer = ast_bridged_channel(p->owner))) {
14600
14601
14602 if (bridgepeer->tech == &sip_tech || bridgepeer->tech == &sip_tech_info) {
14603 bridgepvt = (struct sip_pvt*)bridgepeer->tech_pvt;
14604 if (bridgepvt->t38.state == T38_DISABLED) {
14605 if (bridgepvt->udptl) {
14606
14607 sip_handle_t38_reinvite(bridgepeer, p, 1);
14608 } else {
14609 ast_log(LOG_WARNING, "Strange... The other side of the bridge don't have udptl struct\n");
14610 ast_mutex_lock(&bridgepvt->lock);
14611 bridgepvt->t38.state = T38_DISABLED;
14612 ast_mutex_unlock(&bridgepvt->lock);
14613 if (option_debug > 1)
14614 ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", bridgepvt->t38.state, bridgepeer->name);
14615 if (ast_test_flag(req, SIP_PKT_IGNORE))
14616 transmit_response(p, "488 Not acceptable here", req);
14617 else
14618 transmit_response_reliable(p, "488 Not acceptable here", req);
14619
14620 }
14621 } else {
14622
14623 ast_set_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
14624 transmit_response_with_t38_sdp(p, "200 OK", req, XMIT_CRITICAL);
14625 p->t38.state = T38_ENABLED;
14626 if (option_debug)
14627 ast_log(LOG_DEBUG, "T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
14628 }
14629 } else {
14630
14631 if (ast_test_flag(req, SIP_PKT_IGNORE))
14632 transmit_response(p, "488 Not acceptable here", req);
14633 else
14634 transmit_response_reliable(p, "488 Not acceptable here", req);
14635 p->t38.state = T38_DISABLED;
14636 if (option_debug > 1)
14637 ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
14638
14639 if (!p->lastinvite)
14640 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14641 }
14642 } else {
14643
14644 ast_set_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
14645 transmit_response_with_t38_sdp(p, "200 OK", req, XMIT_CRITICAL);
14646 p->t38.state = T38_ENABLED;
14647 if (option_debug)
14648 ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
14649 }
14650 } else if (p->t38.state == T38_DISABLED) {
14651 int sendok = TRUE;
14652
14653
14654
14655 struct ast_channel *bridgepeer = NULL;
14656 struct sip_pvt *bridgepvt = NULL;
14657 if ((bridgepeer = ast_bridged_channel(p->owner))) {
14658 if ((bridgepeer->tech == &sip_tech || bridgepeer->tech == &sip_tech_info) && !ast_check_hangup(bridgepeer)) {
14659 bridgepvt = (struct sip_pvt*)bridgepeer->tech_pvt;
14660
14661 if (bridgepvt->t38.state == T38_ENABLED) {
14662 ast_log(LOG_WARNING, "RTP re-invite after T38 session not handled yet !\n");
14663
14664 if (ast_test_flag(req, SIP_PKT_IGNORE))
14665 transmit_response(p, "488 Not Acceptable Here (unsupported)", req);
14666 else
14667 transmit_response_reliable(p, "488 Not Acceptable Here (unsupported)", req);
14668 sendok = FALSE;
14669 }
14670
14671 }
14672 }
14673
14674 if (sendok) {
14675
14676 ast_set_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
14677 transmit_response_with_sdp(p, "200 OK", req, (reinvite ? XMIT_RELIABLE : (ast_test_flag(req, SIP_PKT_IGNORE) ? XMIT_UNRELIABLE : XMIT_CRITICAL)));
14678 }
14679 }
14680 p->invitestate = INV_TERMINATED;
14681 break;
14682 default:
14683 ast_log(LOG_WARNING, "Don't know how to handle INVITE in state %d\n", c->_state);
14684 transmit_response(p, "100 Trying", req);
14685 break;
14686 }
14687 } else {
14688 if (p && (p->autokillid == -1)) {
14689 const char *msg;
14690
14691 if (!p->jointcapability)
14692 msg = "488 Not Acceptable Here (codec error)";
14693 else {
14694 ast_log(LOG_NOTICE, "Unable to create/find SIP channel for this INVITE\n");
14695 msg = "503 Unavailable";
14696 }
14697 if (ast_test_flag(req, SIP_PKT_IGNORE))
14698 transmit_response(p, msg, req);
14699 else
14700 transmit_response_reliable(p, msg, req);
14701 p->invitestate = INV_COMPLETED;
14702 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14703 }
14704 }
14705 return res;
14706 }
14707
14708
14709
14710 static int local_attended_transfer(struct sip_pvt *transferer, struct sip_dual *current, struct sip_request *req, int seqno)
14711 {
14712 struct sip_dual target;
14713
14714 int res = 0;
14715 struct sip_pvt *targetcall_pvt;
14716
14717
14718 if (!(targetcall_pvt = get_sip_pvt_byid_locked(transferer->refer->replaces_callid, transferer->refer->replaces_callid_totag,
14719 transferer->refer->replaces_callid_fromtag))) {
14720 if (transferer->refer->localtransfer) {
14721
14722 transmit_response(transferer, "202 Accepted", req);
14723
14724
14725 transmit_notify_with_sipfrag(transferer, seqno, "481 Call leg/transaction does not exist", TRUE);
14726 append_history(transferer, "Xfer", "Refer failed");
14727 ast_clear_flag(&transferer->flags[0], SIP_GOTREFER);
14728 transferer->refer->status = REFER_FAILED;
14729 return -1;
14730 }
14731
14732 if (option_debug > 2)
14733 ast_log(LOG_DEBUG, "SIP attended transfer: Not our call - generating INVITE with replaces\n");
14734 return 0;
14735 }
14736
14737
14738 transmit_response(transferer, "202 Accepted", req);
14739 append_history(transferer, "Xfer", "Refer accepted");
14740 if (!targetcall_pvt->owner) {
14741 if (option_debug > 3)
14742 ast_log(LOG_DEBUG, "SIP attended transfer: Error: No owner of target call\n");
14743
14744 transmit_notify_with_sipfrag(transferer, seqno, "503 Service Unavailable", TRUE);
14745 append_history(transferer, "Xfer", "Refer failed");
14746 ast_clear_flag(&transferer->flags[0], SIP_GOTREFER);
14747 transferer->refer->status = REFER_FAILED;
14748 ast_mutex_unlock(&targetcall_pvt->lock);
14749 ast_channel_unlock(current->chan1);
14750 return -1;
14751 }
14752
14753
14754 target.chan1 = targetcall_pvt->owner;
14755 target.chan2 = ast_bridged_channel(targetcall_pvt->owner);
14756
14757 if (!target.chan2 || !(target.chan2->_state == AST_STATE_UP || target.chan2->_state == AST_STATE_RINGING) ) {
14758
14759 if (option_debug > 3) {
14760 if (target.chan2)
14761 ast_log(LOG_DEBUG, "SIP attended transfer: Error: Wrong state of target call: %s\n", ast_state2str(target.chan2->_state));
14762 else if (target.chan1->_state != AST_STATE_RING)
14763 ast_log(LOG_DEBUG, "SIP attended transfer: Error: No target channel\n");
14764 else
14765 ast_log(LOG_DEBUG, "SIP attended transfer: Attempting transfer in ringing state\n");
14766 }
14767 }
14768
14769
14770 if (option_debug > 3 && sipdebug) {
14771 if (current->chan2)
14772 ast_log(LOG_DEBUG, "SIP attended transfer: trying to bridge %s and %s\n", target.chan1->name, current->chan2->name);
14773 else
14774 ast_log(LOG_DEBUG, "SIP attended transfer: trying to make %s take over (masq) %s\n", target.chan1->name, current->chan1->name);
14775 }
14776
14777 ast_set_flag(&transferer->flags[0], SIP_DEFER_BYE_ON_TRANSFER);
14778
14779
14780 res = attempt_transfer(current, &target);
14781 ast_mutex_unlock(&targetcall_pvt->lock);
14782 if (res) {
14783
14784 transmit_notify_with_sipfrag(transferer, seqno, "486 Busy Here", TRUE);
14785 append_history(transferer, "Xfer", "Refer failed");
14786 transferer->refer->status = REFER_FAILED;
14787 if (targetcall_pvt->owner)
14788 ast_channel_unlock(targetcall_pvt->owner);
14789
14790 if (res != -2)
14791 ast_hangup(transferer->owner);
14792 else
14793 ast_clear_flag(&transferer->flags[0], SIP_DEFER_BYE_ON_TRANSFER);
14794 } else {
14795
14796
14797
14798 transmit_notify_with_sipfrag(transferer, seqno, "200 OK", TRUE);
14799 append_history(transferer, "Xfer", "Refer succeeded");
14800 transferer->refer->status = REFER_200OK;
14801 if (targetcall_pvt->owner) {
14802 if (option_debug)
14803 ast_log(LOG_DEBUG, "SIP attended transfer: Unlocking channel %s\n", targetcall_pvt->owner->name);
14804 ast_channel_unlock(targetcall_pvt->owner);
14805 }
14806 }
14807 return 1;
14808 }
14809
14810
14811
14812
14813
14814
14815
14816
14817
14818
14819
14820
14821
14822
14823
14824
14825
14826
14827
14828
14829
14830
14831
14832
14833
14834
14835
14836
14837
14838
14839
14840
14841
14842
14843
14844
14845
14846
14847
14848
14849
14850
14851
14852
14853
14854
14855
14856
14857
14858
14859
14860
14861
14862
14863
14864
14865
14866
14867
14868
14869
14870
14871
14872
14873
14874 static int handle_request_refer(struct sip_pvt *p, struct sip_request *req, int debug, int ignore, int seqno, int *nounlock)
14875 {
14876 struct sip_dual current;
14877
14878
14879 int res = 0;
14880
14881 if (ast_test_flag(req, SIP_PKT_DEBUG))
14882 ast_verbose("Call %s got a SIP call transfer from %s: (REFER)!\n", p->callid, ast_test_flag(&p->flags[0], SIP_OUTGOING) ? "callee" : "caller");
14883
14884 if (!p->owner) {
14885
14886
14887 if (option_debug > 2)
14888 ast_log(LOG_DEBUG, "Call %s: Declined REFER, outside of dialog...\n", p->callid);
14889 transmit_response(p, "603 Declined (No dialog)", req);
14890 if (!ast_test_flag(req, SIP_PKT_IGNORE)) {
14891 append_history(p, "Xfer", "Refer failed. Outside of dialog.");
14892 sip_alreadygone(p);
14893 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
14894 }
14895 return 0;
14896 }
14897
14898
14899
14900 if (p->allowtransfer == TRANSFER_CLOSED ) {
14901
14902 transmit_response(p, "603 Declined (policy)", req);
14903 append_history(p, "Xfer", "Refer failed. Allowtransfer == closed.");
14904
14905 return 0;
14906 }
14907
14908 if(!ignore && ast_test_flag(&p->flags[0], SIP_GOTREFER)) {
14909
14910 transmit_response(p, "491 Request pending", req);
14911 append_history(p, "Xfer", "Refer failed. Request pending.");
14912 return 0;
14913 }
14914
14915
14916 if (!p->refer && !sip_refer_allocate(p)) {
14917 transmit_response(p, "500 Internal Server Error", req);
14918 append_history(p, "Xfer", "Refer failed. Memory allocation error.");
14919 return -3;
14920 }
14921
14922 res = get_refer_info(p, req);
14923
14924 p->refer->status = REFER_SENT;
14925
14926 if (res != 0) {
14927 switch (res) {
14928 case -2:
14929 transmit_response(p, "400 Bad Request (Refer-to missing)", req);
14930 append_history(p, "Xfer", "Refer failed. Refer-to missing.");
14931 if (ast_test_flag(req, SIP_PKT_DEBUG) && option_debug)
14932 ast_log(LOG_DEBUG, "SIP transfer to black hole can't be handled (no refer-to: )\n");
14933 break;
14934 case -3:
14935 transmit_response(p, "603 Declined (Non sip: uri)", req);
14936 append_history(p, "Xfer", "Refer failed. Non SIP uri");
14937 if (ast_test_flag(req, SIP_PKT_DEBUG) && option_debug)
14938 ast_log(LOG_DEBUG, "SIP transfer to non-SIP uri denied\n");
14939 break;
14940 default:
14941
14942 transmit_response(p, "202 Accepted", req);
14943 append_history(p, "Xfer", "Refer failed. Bad extension.");
14944 transmit_notify_with_sipfrag(p, seqno, "404 Not found", TRUE);
14945 ast_clear_flag(&p->flags[0], SIP_GOTREFER);
14946 if (ast_test_flag(req, SIP_PKT_DEBUG) && option_debug)
14947 ast_log(LOG_DEBUG, "SIP transfer to bad extension: %s\n", p->refer->refer_to);
14948 break;
14949 }
14950 return 0;
14951 }
14952 if (ast_strlen_zero(p->context))
14953 ast_string_field_set(p, context, default_context);
14954
14955
14956 if (allow_external_domains && check_sip_domain(p->refer->refer_to_domain, NULL, 0)) {
14957 p->refer->localtransfer = 1;
14958 if (sipdebug && option_debug > 2)
14959 ast_log(LOG_DEBUG, "This SIP transfer is local : %s\n", p->refer->refer_to_domain);
14960 } else if (AST_LIST_EMPTY(&domain_list) || check_sip_domain(p->refer->refer_to_domain, NULL, 0)) {
14961
14962 p->refer->localtransfer = 1;
14963 } else if (sipdebug && option_debug > 2)
14964 ast_log(LOG_DEBUG, "This SIP transfer is to a remote SIP extension (remote domain %s)\n", p->refer->refer_to_domain);
14965
14966
14967
14968 if (ignore)
14969 return res;
14970
14971
14972
14973
14974
14975
14976
14977
14978
14979
14980
14981
14982
14983
14984
14985
14986
14987
14988
14989
14990
14991
14992
14993
14994
14995
14996
14997 current.chan1 = p->owner;
14998
14999
15000 current.chan2 = ast_bridged_channel(current.chan1);
15001
15002 if (sipdebug && option_debug > 2)
15003 ast_log(LOG_DEBUG, "SIP %s transfer: Transferer channel %s, transferee channel %s\n", p->refer->attendedtransfer ? "attended" : "blind", current.chan1->name, current.chan2 ? current.chan2->name : "<none>");
15004
15005 if (!current.chan2 && !p->refer->attendedtransfer) {
15006
15007
15008
15009 if (sipdebug && option_debug > 2)
15010 ast_log(LOG_DEBUG,"Refused SIP transfer on non-bridged channel.\n");
15011 p->refer->status = REFER_FAILED;
15012 append_history(p, "Xfer", "Refer failed. Non-bridged channel.");
15013 transmit_response(p, "603 Declined", req);
15014 return -1;
15015 }
15016
15017 if (current.chan2) {
15018 if (sipdebug && option_debug > 3)
15019 ast_log(LOG_DEBUG, "Got SIP transfer, applying to bridged peer '%s'\n", current.chan2->name);
15020
15021 ast_queue_control(current.chan1, AST_CONTROL_UNHOLD);
15022 }
15023
15024 ast_set_flag(&p->flags[0], SIP_GOTREFER);
15025
15026
15027 if (p->refer->attendedtransfer) {
15028 if ((res = local_attended_transfer(p, ¤t, req, seqno)))
15029 return res;
15030
15031 if (sipdebug && option_debug > 3)
15032 ast_log(LOG_DEBUG, "SIP attended transfer: Still not our call - generating INVITE with replaces\n");
15033
15034 }
15035
15036
15037
15038 if (p->refer->localtransfer && !strcmp(p->refer->refer_to, ast_parking_ext())) {
15039
15040 *nounlock = 1;
15041 ast_channel_unlock(current.chan1);
15042 copy_request(¤t.req, req);
15043 ast_clear_flag(&p->flags[0], SIP_GOTREFER);
15044 p->refer->status = REFER_200OK;
15045 append_history(p, "Xfer", "REFER to call parking.");
15046 if (sipdebug && option_debug > 3)
15047 ast_log(LOG_DEBUG, "SIP transfer to parking: trying to park %s. Parked by %s\n", current.chan2->name, current.chan1->name);
15048 sip_park(current.chan2, current.chan1, req, seqno);
15049 return res;
15050 }
15051
15052
15053 transmit_response(p, "202 Accepted", req);
15054
15055 if (current.chan1 && current.chan2) {
15056 if (option_debug > 2)
15057 ast_log(LOG_DEBUG, "chan1->name: %s\n", current.chan1->name);
15058 pbx_builtin_setvar_helper(current.chan1, "BLINDTRANSFER", current.chan2->name);
15059 }
15060 if (current.chan2) {
15061 pbx_builtin_setvar_helper(current.chan2, "BLINDTRANSFER", current.chan1->name);
15062 pbx_builtin_setvar_helper(current.chan2, "SIPDOMAIN", p->refer->refer_to_domain);
15063 pbx_builtin_setvar_helper(current.chan2, "SIPTRANSFER", "yes");
15064
15065 pbx_builtin_setvar_helper(current.chan2, "_SIPTRANSFER", "yes");
15066
15067 if (p->refer->referred_by)
15068 pbx_builtin_setvar_helper(current.chan2, "_SIPTRANSFER_REFERER", p->refer->referred_by);
15069 }
15070
15071 if (p->refer->replaces_callid && !ast_strlen_zero(p->refer->replaces_callid)) {
15072 char tempheader[SIPBUFSIZE];
15073 snprintf(tempheader, sizeof(tempheader), "%s%s%s%s%s", p->refer->replaces_callid,
15074 p->refer->replaces_callid_totag ? ";to-tag=" : "",
15075 p->refer->replaces_callid_totag,
15076 p->refer->replaces_callid_fromtag ? ";from-tag=" : "",
15077 p->refer->replaces_callid_fromtag);
15078 if (current.chan2)
15079 pbx_builtin_setvar_helper(current.chan2, "_SIPTRANSFER_REPLACES", tempheader);
15080 }
15081
15082
15083 *nounlock = 1;
15084 ast_channel_unlock(current.chan1);
15085
15086
15087
15088
15089 if (!p->refer->attendedtransfer)
15090 transmit_notify_with_sipfrag(p, seqno, "183 Ringing", FALSE);
15091
15092
15093
15094
15095
15096 if (!current.chan2) {
15097
15098
15099
15100
15101
15102
15103
15104 p->refer->status = REFER_FAILED;
15105 transmit_notify_with_sipfrag(p, seqno, "503 Service Unavailable (can't handle one-legged xfers)", TRUE);
15106 ast_clear_flag(&p->flags[0], SIP_GOTREFER);
15107 append_history(p, "Xfer", "Refer failed (only bridged calls).");
15108 return -1;
15109 }
15110 ast_set_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER);
15111
15112
15113
15114 res = ast_async_goto(current.chan2, p->refer->refer_to_context, p->refer->refer_to, 1);
15115
15116 if (!res) {
15117
15118 if (option_debug > 2)
15119 ast_log(LOG_DEBUG, "%s transfer succeeded. Telling transferer.\n", p->refer->attendedtransfer? "Attended" : "Blind");
15120 transmit_notify_with_sipfrag(p, seqno, "200 Ok", TRUE);
15121 if (p->refer->localtransfer)
15122 p->refer->status = REFER_200OK;
15123 if (p->owner)
15124 p->owner->hangupcause = AST_CAUSE_NORMAL_CLEARING;
15125 append_history(p, "Xfer", "Refer succeeded.");
15126 ast_clear_flag(&p->flags[0], SIP_GOTREFER);
15127
15128
15129 res = 0;
15130 } else {
15131 ast_clear_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER);
15132 if (option_debug > 2)
15133 ast_log(LOG_DEBUG, "%s transfer failed. Resuming original call.\n", p->refer->attendedtransfer? "Attended" : "Blind");
15134 append_history(p, "Xfer", "Refer failed.");
15135
15136 p->refer->status = REFER_FAILED;
15137 transmit_notify_with_sipfrag(p, seqno, "503 Service Unavailable", TRUE);
15138 ast_clear_flag(&p->flags[0], SIP_GOTREFER);
15139 res = -1;
15140 }
15141 return res;
15142 }
15143
15144
15145 static int handle_request_cancel(struct sip_pvt *p, struct sip_request *req)
15146 {
15147
15148 check_via(p, req);
15149 sip_alreadygone(p);
15150
15151
15152
15153
15154
15155
15156 if (p->invitestate == INV_TERMINATED)
15157 __sip_pretend_ack(p);
15158 else
15159 p->invitestate = INV_CANCELLED;
15160
15161 if (p->owner && p->owner->_state == AST_STATE_UP) {
15162
15163 transmit_response(p, "200 OK", req);
15164 if (option_debug)
15165 ast_log(LOG_DEBUG, "Got CANCEL on an answered call. Ignoring... \n");
15166 return 0;
15167 }
15168
15169 if (ast_test_flag(&p->flags[0], SIP_INC_COUNT) || ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD))
15170 update_call_counter(p, DEC_CALL_LIMIT);
15171
15172 stop_media_flows(p);
15173 if (p->owner)
15174 ast_queue_hangup(p->owner);
15175 else
15176 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
15177 if (p->initreq.len > 0) {
15178 transmit_response_reliable(p, "487 Request Terminated", &p->initreq);
15179 transmit_response(p, "200 OK", req);
15180 return 1;
15181 } else {
15182 transmit_response(p, "481 Call Leg Does Not Exist", req);
15183 return 0;
15184 }
15185 }
15186
15187 static int acf_channel_read(struct ast_channel *chan, char *funcname, char *preparse, char *buf, size_t buflen)
15188 {
15189 struct ast_rtp_quality qos;
15190 struct sip_pvt *p = chan->tech_pvt;
15191 char *all = "", *parse = ast_strdupa(preparse);
15192 AST_DECLARE_APP_ARGS(args,
15193 AST_APP_ARG(param);
15194 AST_APP_ARG(type);
15195 AST_APP_ARG(field);
15196 );
15197 AST_STANDARD_APP_ARGS(args, parse);
15198
15199
15200 if (chan->tech != &sip_tech && chan->tech != &sip_tech_info) {
15201 ast_log(LOG_ERROR, "Cannot call %s on a non-SIP channel\n", funcname);
15202 return 0;
15203 }
15204
15205 if (strcasecmp(args.param, "rtpqos"))
15206 return 0;
15207
15208
15209 if (ast_strlen_zero(args.type))
15210 args.type = "audio";
15211 if (ast_strlen_zero(args.field))
15212 args.field = "all";
15213
15214 memset(buf, 0, buflen);
15215 memset(&qos, 0, sizeof(qos));
15216
15217 if (strcasecmp(args.type, "AUDIO") == 0) {
15218 all = ast_rtp_get_quality(p->rtp, &qos);
15219 } else if (strcasecmp(args.type, "VIDEO") == 0) {
15220 all = ast_rtp_get_quality(p->vrtp, &qos);
15221 }
15222
15223 if (strcasecmp(args.field, "local_ssrc") == 0)
15224 snprintf(buf, buflen, "%u", qos.local_ssrc);
15225 else if (strcasecmp(args.field, "local_lostpackets") == 0)
15226 snprintf(buf, buflen, "%u", qos.local_lostpackets);
15227 else if (strcasecmp(args.field, "local_jitter") == 0)
15228 snprintf(buf, buflen, "%.0lf", qos.local_jitter * 1000.0);
15229 else if (strcasecmp(args.field, "local_count") == 0)
15230 snprintf(buf, buflen, "%u", qos.local_count);
15231 else if (strcasecmp(args.field, "remote_ssrc") == 0)
15232 snprintf(buf, buflen, "%u", qos.remote_ssrc);
15233 else if (strcasecmp(args.field, "remote_lostpackets") == 0)
15234 snprintf(buf, buflen, "%u", qos.remote_lostpackets);
15235 else if (strcasecmp(args.field, "remote_jitter") == 0)
15236 snprintf(buf, buflen, "%.0lf", qos.remote_jitter * 1000.0);
15237 else if (strcasecmp(args.field, "remote_count") == 0)
15238 snprintf(buf, buflen, "%u", qos.remote_count);
15239 else if (strcasecmp(args.field, "rtt") == 0)
15240 snprintf(buf, buflen, "%.0lf", qos.rtt * 1000.0);
15241 else if (strcasecmp(args.field, "all") == 0)
15242 ast_copy_string(buf, all, buflen);
15243 else {
15244 ast_log(LOG_WARNING, "Unrecognized argument '%s' to %s\n", preparse, funcname);
15245 return -1;
15246 }
15247 return 0;
15248 }
15249
15250
15251 static int handle_request_bye(struct sip_pvt *p, struct sip_request *req)
15252 {
15253 struct ast_channel *c=NULL;
15254 int res;
15255 struct ast_channel *bridged_to;
15256
15257
15258 if (p->pendinginvite && !ast_test_flag(&p->flags[0], SIP_OUTGOING) && !ast_test_flag(req, SIP_PKT_IGNORE) && !p->owner)
15259 transmit_response_reliable(p, "487 Request Terminated", &p->initreq);
15260
15261 __sip_pretend_ack(p);
15262
15263 p->invitestate = INV_TERMINATED;
15264
15265 copy_request(&p->initreq, req);
15266 check_via(p, req);
15267 sip_alreadygone(p);
15268
15269
15270 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY) || p->owner) {
15271 char *audioqos, *videoqos;
15272 if (p->rtp) {
15273 audioqos = ast_rtp_get_quality(p->rtp, NULL);
15274 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
15275 append_history(p, "RTCPaudio", "Quality:%s", audioqos);
15276 if (p->owner)
15277 pbx_builtin_setvar_helper(p->owner, "RTPAUDIOQOS", audioqos);
15278 }
15279 if (p->vrtp) {
15280 videoqos = ast_rtp_get_quality(p->vrtp, NULL);
15281 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
15282 append_history(p, "RTCPvideo", "Quality:%s", videoqos);
15283 if (p->owner)
15284 pbx_builtin_setvar_helper(p->owner, "RTPVIDEOQOS", videoqos);
15285 }
15286 }
15287
15288 stop_media_flows(p);
15289
15290 if (!ast_strlen_zero(get_header(req, "Also"))) {
15291 ast_log(LOG_NOTICE, "Client '%s' using deprecated BYE/Also transfer method. Ask vendor to support REFER instead\n",
15292 ast_inet_ntoa(p->recv.sin_addr));
15293 if (ast_strlen_zero(p->context))
15294 ast_string_field_set(p, context, default_context);
15295 res = get_also_info(p, req);
15296 if (!res) {
15297 c = p->owner;
15298 if (c) {
15299 bridged_to = ast_bridged_channel(c);
15300 if (bridged_to) {
15301
15302 ast_queue_control(c, AST_CONTROL_UNHOLD);
15303 ast_async_goto(bridged_to, p->context, p->refer->refer_to,1);
15304 } else
15305 ast_queue_hangup(p->owner);
15306 }
15307 } else {
15308 ast_log(LOG_WARNING, "Invalid transfer information from '%s'\n", ast_inet_ntoa(p->recv.sin_addr));
15309 if (p->owner)
15310 ast_queue_hangup(p->owner);
15311 }
15312 } else if (p->owner) {
15313 ast_queue_hangup(p->owner);
15314 if (option_debug > 2)
15315 ast_log(LOG_DEBUG, "Received bye, issuing owner hangup\n");
15316 } else {
15317 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
15318 if (option_debug > 2)
15319 ast_log(LOG_DEBUG, "Received bye, no owner, selfdestruct soon.\n");
15320 }
15321 ast_clear_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
15322 transmit_response(p, "200 OK", req);
15323
15324 return 1;
15325 }
15326
15327
15328 static int handle_request_message(struct sip_pvt *p, struct sip_request *req)
15329 {
15330 if (!ast_test_flag(req, SIP_PKT_IGNORE)) {
15331 if (ast_test_flag(req, SIP_PKT_DEBUG))
15332 ast_verbose("Receiving message!\n");
15333 receive_message(p, req);
15334 } else
15335 transmit_response(p, "202 Accepted", req);
15336 return 1;
15337 }
15338
15339
15340 static int handle_request_subscribe(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int seqno, char *e)
15341 {
15342 int gotdest;
15343 int res = 0;
15344 int firststate = AST_EXTENSION_REMOVED;
15345 struct sip_peer *authpeer = NULL;
15346 const char *eventheader = get_header(req, "Event");
15347 const char *accept = get_header(req, "Accept");
15348 int resubscribe = (p->subscribed != NONE);
15349 char *temp, *event;
15350
15351 if (p->initreq.headers) {
15352
15353 if (p->initreq.method != SIP_SUBSCRIBE) {
15354
15355
15356 transmit_response(p, "403 Forbidden (within dialog)", req);
15357
15358 if (option_debug)
15359 ast_log(LOG_DEBUG, "Got a subscription within the context of another call, can't handle that - %s (Method %s)\n", p->callid, sip_methods[p->initreq.method].text);
15360 return 0;
15361 } else if (ast_test_flag(req, SIP_PKT_DEBUG)) {
15362 if (option_debug) {
15363 if (resubscribe)
15364 ast_log(LOG_DEBUG, "Got a re-subscribe on existing subscription %s\n", p->callid);
15365 else
15366 ast_log(LOG_DEBUG, "Got a new subscription %s (possibly with auth)\n", p->callid);
15367 }
15368 }
15369 }
15370
15371
15372
15373
15374 if (!global_allowsubscribe) {
15375 transmit_response(p, "403 Forbidden (policy)", req);
15376 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15377 return 0;
15378 }
15379
15380 if (!ast_test_flag(req, SIP_PKT_IGNORE) && !resubscribe) {
15381 const char *to = get_header(req, "To");
15382 char totag[128];
15383
15384
15385 if (!ast_strlen_zero(to) && gettag(req, "To", totag, sizeof(totag))) {
15386 if (ast_test_flag(req, SIP_PKT_DEBUG))
15387 ast_verbose("Received resubscription for a dialog we no longer know about. Telling remote side to subscribe again.\n");
15388 transmit_response(p, "481 Subscription does not exist", req);
15389 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15390 return 0;
15391 }
15392
15393
15394 if (ast_test_flag(req, SIP_PKT_DEBUG))
15395 ast_verbose("Creating new subscription\n");
15396
15397 copy_request(&p->initreq, req);
15398 check_via(p, req);
15399 } else if (ast_test_flag(req, SIP_PKT_DEBUG) && ast_test_flag(req, SIP_PKT_IGNORE))
15400 ast_verbose("Ignoring this SUBSCRIBE request\n");
15401
15402
15403 if (ast_strlen_zero(eventheader)) {
15404 transmit_response(p, "489 Bad Event", req);
15405 if (option_debug > 1)
15406 ast_log(LOG_DEBUG, "Received SIP subscribe for unknown event package: <none>\n");
15407 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15408 return 0;
15409 }
15410
15411 if ( (strchr(eventheader, ';'))) {
15412 event = ast_strdupa(eventheader);
15413 temp = strchr(event, ';');
15414 *temp = '\0';
15415
15416 } else
15417 event = (char *) eventheader;
15418
15419
15420 res = check_user_full(p, req, SIP_SUBSCRIBE, e, 0, sin, &authpeer);
15421
15422 if (res == AUTH_CHALLENGE_SENT) {
15423 if (authpeer)
15424 ASTOBJ_UNREF(authpeer, sip_destroy_peer);
15425 return 0;
15426 }
15427 if (res < 0) {
15428 if (res == AUTH_FAKE_AUTH) {
15429 ast_log(LOG_NOTICE, "Sending fake auth rejection for user %s\n", get_header(req, "From"));
15430 transmit_fake_auth_response(p, req, 1);
15431 } else {
15432 ast_log(LOG_NOTICE, "Failed to authenticate user %s for SUBSCRIBE\n", get_header(req, "From"));
15433 transmit_response_reliable(p, "403 Forbidden", req);
15434 }
15435 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15436 if (authpeer)
15437 ASTOBJ_UNREF(authpeer, sip_destroy_peer);
15438 return 0;
15439 }
15440
15441
15442 if (!ast_test_flag(&p->flags[1], SIP_PAGE2_ALLOWSUBSCRIBE)) {
15443 transmit_response(p, "403 Forbidden (policy)", req);
15444 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15445 if (authpeer)
15446 ASTOBJ_UNREF(authpeer, sip_destroy_peer);
15447 return 0;
15448 }
15449
15450
15451 gotdest = get_destination(p, NULL);
15452
15453
15454 parse_ok_contact(p, req);
15455
15456 build_contact(p);
15457 if (strcmp(event, "message-summary") && gotdest) {
15458 transmit_response(p, "404 Not Found", req);
15459 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15460 if (authpeer)
15461 ASTOBJ_UNREF(authpeer, sip_destroy_peer);
15462 return 0;
15463 }
15464
15465
15466 if (ast_strlen_zero(p->tag))
15467 make_our_tag(p->tag, sizeof(p->tag));
15468
15469 if (!strcmp(event, "presence") || !strcmp(event, "dialog")) {
15470 if (authpeer)
15471 ASTOBJ_UNREF(authpeer, sip_destroy_peer);
15472
15473
15474
15475
15476
15477 if (strstr(p->useragent, "Polycom")) {
15478 p->subscribed = XPIDF_XML;
15479 } else if (strstr(accept, "application/pidf+xml")) {
15480 p->subscribed = PIDF_XML;
15481 } else if (strstr(accept, "application/dialog-info+xml")) {
15482 p->subscribed = DIALOG_INFO_XML;
15483
15484 } else if (strstr(accept, "application/cpim-pidf+xml")) {
15485 p->subscribed = CPIM_PIDF_XML;
15486 } else if (strstr(accept, "application/xpidf+xml")) {
15487 p->subscribed = XPIDF_XML;
15488 } else if (ast_strlen_zero(accept)) {
15489 if (p->subscribed == NONE) {
15490 transmit_response(p, "489 Bad Event", req);
15491
15492 ast_log(LOG_WARNING,"SUBSCRIBE failure: no Accept header: pvt: stateid: %d, laststate: %d, dialogver: %d, subscribecont: '%s', subscribeuri: '%s'\n",
15493 p->stateid, p->laststate, p->dialogver, p->subscribecontext, p->subscribeuri);
15494 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15495 return 0;
15496 }
15497
15498
15499 } else {
15500
15501 char mybuf[200];
15502 snprintf(mybuf,sizeof(mybuf),"489 Bad Event (format %s)", accept);
15503 transmit_response(p, mybuf, req);
15504
15505 ast_log(LOG_WARNING,"SUBSCRIBE failure: unrecognized format: '%s' pvt: subscribed: %d, stateid: %d, laststate: %d, dialogver: %d, subscribecont: '%s', subscribeuri: '%s'\n",
15506 accept, (int)p->subscribed, p->stateid, p->laststate, p->dialogver, p->subscribecontext, p->subscribeuri);
15507 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15508 return 0;
15509 }
15510 } else if (!strcmp(event, "message-summary")) {
15511 if (!ast_strlen_zero(accept) && strcmp(accept, "application/simple-message-summary")) {
15512
15513 transmit_response(p, "406 Not Acceptable", req);
15514 if (option_debug > 1)
15515 ast_log(LOG_DEBUG, "Received SIP mailbox subscription for unknown format: %s\n", accept);
15516 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15517 if (authpeer)
15518 ASTOBJ_UNREF(authpeer, sip_destroy_peer);
15519 return 0;
15520 }
15521
15522
15523
15524
15525
15526 if (!authpeer || ast_strlen_zero(authpeer->mailbox)) {
15527 transmit_response(p, "404 Not found (no mailbox)", req);
15528 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15529 ast_log(LOG_NOTICE, "Received SIP subscribe for peer without mailbox: %s\n", authpeer->name);
15530 if (authpeer)
15531 ASTOBJ_UNREF(authpeer, sip_destroy_peer);
15532 return 0;
15533 }
15534
15535 p->subscribed = MWI_NOTIFICATION;
15536 if (authpeer->mwipvt && authpeer->mwipvt != p)
15537
15538 sip_destroy(authpeer->mwipvt);
15539 authpeer->mwipvt = p;
15540 p->relatedpeer = ASTOBJ_REF(authpeer);
15541 } else {
15542 transmit_response(p, "489 Bad Event", req);
15543 if (option_debug > 1)
15544 ast_log(LOG_DEBUG, "Received SIP subscribe for unknown event package: %s\n", event);
15545 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15546 if (authpeer)
15547 ASTOBJ_UNREF(authpeer, sip_destroy_peer);
15548 return 0;
15549 }
15550
15551 if (p->subscribed != MWI_NOTIFICATION && !resubscribe) {
15552 if (p->stateid > -1)
15553 ast_extension_state_del(p->stateid, cb_extensionstate);
15554 p->stateid = ast_extension_state_add(p->context, p->exten, cb_extensionstate, p);
15555 }
15556
15557 if (!ast_test_flag(req, SIP_PKT_IGNORE) && p)
15558 p->lastinvite = seqno;
15559 if (p && !ast_test_flag(&p->flags[0], SIP_NEEDDESTROY)) {
15560 p->expiry = atoi(get_header(req, "Expires"));
15561
15562
15563 if (p->expiry > max_expiry)
15564 p->expiry = max_expiry;
15565 if (p->expiry < min_expiry && p->expiry > 0)
15566 p->expiry = min_expiry;
15567
15568 if (sipdebug || option_debug > 1) {
15569 if (p->subscribed == MWI_NOTIFICATION && p->relatedpeer)
15570 ast_log(LOG_DEBUG, "Adding subscription for mailbox notification - peer %s Mailbox %s\n", p->relatedpeer->name, p->relatedpeer->mailbox);
15571 else
15572 ast_log(LOG_DEBUG, "Adding subscription for extension %s context %s for peer %s\n", p->exten, p->context, p->username);
15573 }
15574 if (p->autokillid > -1 && sip_cancel_destroy(p))
15575 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
15576 if (p->expiry > 0)
15577 sip_scheddestroy(p, (p->expiry + 10) * 1000);
15578
15579 if (p->subscribed == MWI_NOTIFICATION) {
15580 ast_set_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
15581 transmit_response(p, "200 OK", req);
15582 if (p->relatedpeer) {
15583 ASTOBJ_WRLOCK(p->relatedpeer);
15584 sip_send_mwi_to_peer(p->relatedpeer);
15585 ASTOBJ_UNLOCK(p->relatedpeer);
15586 }
15587 } else {
15588 struct sip_pvt *p_old;
15589
15590 if ((firststate = ast_extension_state(NULL, p->context, p->exten)) < 0) {
15591
15592 ast_log(LOG_NOTICE, "Got SUBSCRIBE for extension %s@%s from %s, but there is no hint for that extension.\n", p->exten, p->context, ast_inet_ntoa(p->sa.sin_addr));
15593 transmit_response(p, "404 Not found", req);
15594 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15595 return 0;
15596 }
15597 ast_set_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
15598 transmit_response(p, "200 OK", req);
15599 transmit_state_notify(p, firststate, 1, FALSE);
15600 append_history(p, "Subscribestatus", "%s", ast_extension_state2str(firststate));
15601
15602 ast_string_field_build(p, subscribeuri, "%s@%s", p->exten, p->context);
15603
15604
15605
15606
15607
15608
15609 ast_mutex_lock(&iflock);
15610 for (p_old = iflist; p_old; p_old = p_old->next) {
15611 if (p_old == p)
15612 continue;
15613 if (p_old->initreq.method != SIP_SUBSCRIBE)
15614 continue;
15615 if (p_old->subscribed == NONE)
15616 continue;
15617 ast_mutex_lock(&p_old->lock);
15618 if (!strcmp(p_old->username, p->username)) {
15619 if (!strcmp(p_old->exten, p->exten) &&
15620 !strcmp(p_old->context, p->context)) {
15621 ast_set_flag(&p_old->flags[0], SIP_NEEDDESTROY);
15622 ast_mutex_unlock(&p_old->lock);
15623 break;
15624 }
15625 }
15626 ast_mutex_unlock(&p_old->lock);
15627 }
15628 ast_mutex_unlock(&iflock);
15629 }
15630 if (!p->expiry)
15631 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15632 }
15633 return 1;
15634 }
15635
15636
15637 static int handle_request_register(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, char *e)
15638 {
15639 enum check_auth_result res;
15640
15641
15642 if (ast_test_flag(req, SIP_PKT_DEBUG))
15643 ast_verbose("Using latest REGISTER request as basis request\n");
15644 copy_request(&p->initreq, req);
15645 check_via(p, req);
15646 if ((res = register_verify(p, sin, req, e)) < 0) {
15647 const char *reason;
15648
15649 switch (res) {
15650 case AUTH_SECRET_FAILED:
15651 reason = "Wrong password";
15652 break;
15653 case AUTH_USERNAME_MISMATCH:
15654 reason = "Username/auth name mismatch";
15655 break;
15656 case AUTH_NOT_FOUND:
15657 reason = "No matching peer found";
15658 break;
15659 case AUTH_UNKNOWN_DOMAIN:
15660 reason = "Not a local domain";
15661 break;
15662 case AUTH_PEER_NOT_DYNAMIC:
15663 reason = "Peer is not supposed to register";
15664 break;
15665 case AUTH_ACL_FAILED:
15666 reason = "Device does not match ACL";
15667 break;
15668 default:
15669 reason = "Unknown failure";
15670 break;
15671 }
15672 ast_log(LOG_NOTICE, "Registration from '%s' failed for '%s' - %s\n",
15673 get_header(req, "To"), ast_inet_ntoa(sin->sin_addr),
15674 reason);
15675 append_history(p, "RegRequest", "Failed : Account %s : %s", get_header(req, "To"), reason);
15676 } else
15677 append_history(p, "RegRequest", "Succeeded : Account %s", get_header(req, "To"));
15678
15679 if (res < 1) {
15680
15681
15682 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
15683 }
15684 return res;
15685 }
15686
15687
15688
15689
15690 static int handle_request(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int *recount, int *nounlock)
15691 {
15692
15693
15694 const char *cmd;
15695 const char *cseq;
15696 const char *useragent;
15697 int seqno;
15698 int len;
15699 int ignore = FALSE;
15700 int respid;
15701 int res = 0;
15702 int debug = sip_debug_test_pvt(p);
15703 char *e;
15704 int error = 0;
15705
15706
15707 cseq = get_header(req, "Cseq");
15708 cmd = req->header[0];
15709
15710
15711 if (ast_strlen_zero(cmd) || ast_strlen_zero(cseq)) {
15712 ast_log(LOG_ERROR, "Missing Cseq. Dropping this SIP message, it's incomplete.\n");
15713 error = 1;
15714 }
15715 if (!error && sscanf(cseq, "%d%n", &seqno, &len) != 1) {
15716 ast_log(LOG_ERROR, "No seqno in '%s'. Dropping incomplete message.\n", cmd);
15717 error = 1;
15718 }
15719 if (error) {
15720 if (!p->initreq.headers)
15721 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15722 return -1;
15723 }
15724
15725
15726 cmd = req->rlPart1;
15727 e = req->rlPart2;
15728
15729
15730 useragent = get_header(req, "User-Agent");
15731 if (!ast_strlen_zero(useragent))
15732 ast_string_field_set(p, useragent, useragent);
15733
15734
15735 if (req->method == SIP_RESPONSE) {
15736
15737 if (!p->initreq.headers) {
15738 if (option_debug)
15739 ast_log(LOG_DEBUG, "That's odd... Got a response on a call we dont know about. Cseq %d Cmd %s\n", seqno, cmd);
15740 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15741 return 0;
15742 } else if (p->ocseq && (p->ocseq < seqno) && (seqno != p->lastnoninvite)) {
15743 if (option_debug)
15744 ast_log(LOG_DEBUG, "Ignoring out of order response %d (expecting %d)\n", seqno, p->ocseq);
15745 return -1;
15746 } else if (p->ocseq && (p->ocseq != seqno) && (seqno != p->lastnoninvite)) {
15747
15748
15749 ignore = TRUE;
15750 ast_set_flag(req, SIP_PKT_IGNORE);
15751 ast_set_flag(req, SIP_PKT_IGNORE_RESP);
15752 append_history(p, "Ignore", "Ignoring this retransmit\n");
15753 } else if (e) {
15754 e = ast_skip_blanks(e);
15755 if (sscanf(e, "%d %n", &respid, &len) != 1) {
15756 ast_log(LOG_WARNING, "Invalid response: '%s'\n", e);
15757 } else {
15758 if (respid <= 0) {
15759 ast_log(LOG_WARNING, "Invalid SIP response code: '%d'\n", respid);
15760 return 0;
15761 }
15762
15763 if ((respid == 200) || ((respid >= 300) && (respid <= 399)))
15764 extract_uri(p, req);
15765 handle_response(p, respid, e + len, req, ignore, seqno);
15766 }
15767 }
15768 return 0;
15769 }
15770
15771
15772
15773
15774
15775 p->method = req->method;
15776 if (option_debug > 3)
15777 ast_log(LOG_DEBUG, "**** Received %s (%d) - Command in SIP %s\n", sip_methods[p->method].text, sip_methods[p->method].id, cmd);
15778
15779 if (p->icseq && (p->icseq > seqno) ) {
15780 if (p->pendinginvite && seqno == p->pendinginvite && (req->method == SIP_ACK || req->method == SIP_CANCEL)) {
15781 if (option_debug > 2)
15782 ast_log(LOG_DEBUG, "Got CANCEL or ACK on INVITE with transactions in between.\n");
15783 } else {
15784 if (option_debug)
15785 ast_log(LOG_DEBUG, "Ignoring too old SIP packet packet %d (expecting >= %d)\n", seqno, p->icseq);
15786 if (req->method != SIP_ACK)
15787 transmit_response(p, "503 Server error", req);
15788 return -1;
15789 }
15790 } else if (p->icseq &&
15791 p->icseq == seqno &&
15792 req->method != SIP_ACK &&
15793 (p->method != SIP_CANCEL || ast_test_flag(&p->flags[0], SIP_ALREADYGONE))) {
15794
15795
15796
15797 ignore = 2;
15798 ast_set_flag(req, SIP_PKT_IGNORE);
15799 ast_set_flag(req, SIP_PKT_IGNORE_REQ);
15800 if (option_debug > 2)
15801 ast_log(LOG_DEBUG, "Ignoring SIP message because of retransmit (%s Seqno %d, ours %d)\n", sip_methods[p->method].text, p->icseq, seqno);
15802 }
15803
15804 if (seqno >= p->icseq)
15805
15806
15807
15808 p->icseq = seqno;
15809
15810
15811 if (ast_strlen_zero(p->theirtag)) {
15812 char tag[128];
15813
15814 gettag(req, "From", tag, sizeof(tag));
15815 ast_string_field_set(p, theirtag, tag);
15816 }
15817 snprintf(p->lastmsg, sizeof(p->lastmsg), "Rx: %s", cmd);
15818
15819 if (pedanticsipchecking) {
15820
15821
15822
15823
15824 if (!p->initreq.headers && ast_test_flag(req, SIP_PKT_WITH_TOTAG)) {
15825
15826 if (!ast_test_flag(req, SIP_PKT_IGNORE) && req->method == SIP_INVITE) {
15827 transmit_response_reliable(p, "481 Call/Transaction Does Not Exist", req);
15828
15829 } else if (req->method != SIP_ACK) {
15830 transmit_response(p, "481 Call/Transaction Does Not Exist", req);
15831 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
15832 }
15833 return res;
15834 }
15835 }
15836
15837 if (!e && (p->method == SIP_INVITE || p->method == SIP_SUBSCRIBE || p->method == SIP_REGISTER || p->method == SIP_NOTIFY)) {
15838 transmit_response(p, "400 Bad request", req);
15839 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
15840 return -1;
15841 }
15842
15843
15844 switch (p->method) {
15845 case SIP_OPTIONS:
15846 res = handle_request_options(p, req);
15847 break;
15848 case SIP_INVITE:
15849 res = handle_request_invite(p, req, debug, seqno, sin, recount, e, nounlock);
15850 break;
15851 case SIP_REFER:
15852 res = handle_request_refer(p, req, debug, ignore, seqno, nounlock);
15853 break;
15854 case SIP_CANCEL:
15855 res = handle_request_cancel(p, req);
15856 break;
15857 case SIP_BYE:
15858 res = handle_request_bye(p, req);
15859 break;
15860 case SIP_MESSAGE:
15861 res = handle_request_message(p, req);
15862 break;
15863 case SIP_SUBSCRIBE:
15864 res = handle_request_subscribe(p, req, sin, seqno, e);
15865 break;
15866 case SIP_REGISTER:
15867 res = handle_request_register(p, req, sin, e);
15868 break;
15869 case SIP_INFO:
15870 if (ast_test_flag(req, SIP_PKT_DEBUG))
15871 ast_verbose("Receiving INFO!\n");
15872 if (!ignore)
15873 handle_request_info(p, req);
15874 else
15875 transmit_response(p, "200 OK", req);
15876 break;
15877 case SIP_NOTIFY:
15878 res = handle_request_notify(p, req, sin, seqno, e);
15879 break;
15880 case SIP_ACK:
15881
15882 if (seqno == p->pendinginvite) {
15883 p->invitestate = INV_TERMINATED;
15884 p->pendinginvite = 0;
15885 __sip_ack(p, seqno, FLAG_RESPONSE, 0);
15886 if (find_sdp(req)) {
15887 if (process_sdp(p, req))
15888 return -1;
15889 }
15890 check_pendings(p);
15891 }
15892
15893 if (!p->lastinvite && ast_strlen_zero(p->randdata))
15894 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15895 break;
15896 default:
15897 transmit_response_with_allow(p, "501 Method Not Implemented", req, 0);
15898 ast_log(LOG_NOTICE, "Unknown SIP command '%s' from '%s'\n",
15899 cmd, ast_inet_ntoa(p->sa.sin_addr));
15900
15901 if (!p->initreq.headers)
15902 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15903 break;
15904 }
15905 return res;
15906 }
15907
15908
15909
15910
15911
15912
15913 static int sipsock_read(int *id, int fd, short events, void *ignore)
15914 {
15915 struct sip_request req;
15916 struct sockaddr_in sin = { 0, };
15917 struct sip_pvt *p;
15918 int res;
15919 socklen_t len = sizeof(sin);
15920 int nounlock;
15921 int recount = 0;
15922 int lockretry;
15923
15924 memset(&req, 0, sizeof(req));
15925 if (fd == sipsock)
15926 res = recvfrom(fd, req.data, sizeof(req.data) - 1, 0, (struct sockaddr *)&sin, &len);
15927 else {
15928 if (getpeername(fd, (struct sockaddr *)&sin, &len) < 0) {
15929 close(fd);
15930 return 1;
15931 }
15932 if ((res = read(fd, req.data, sizeof(req.data) - 1)) == 0) {
15933 close(fd);
15934 return 1;
15935 }
15936 }
15937 if (res < 0) {
15938 #if !defined(__FreeBSD__)
15939 if (errno == EAGAIN)
15940 ast_log(LOG_NOTICE, "SIP: Received packet with bad UDP checksum\n");
15941 else
15942 #endif
15943 if (errno != ECONNREFUSED)
15944 ast_log(LOG_WARNING, "Recv error: %s\n", strerror(errno));
15945 return 1;
15946 }
15947 if (option_debug && res == sizeof(req.data) - 1)
15948 ast_log(LOG_DEBUG, "Received packet exceeds buffer. Data is possibly lost\n");
15949
15950 req.data[res] = '\0';
15951 req.len = res;
15952 if(sip_debug_test_addr(&sin))
15953 ast_set_flag(&req, SIP_PKT_DEBUG);
15954 if (pedanticsipchecking)
15955 req.len = lws2sws(req.data, req.len);
15956 if (ast_test_flag(&req, SIP_PKT_DEBUG))
15957 ast_verbose("\n<--- SIP read from %s:%d:%s --->\n%s\n<------------->\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port),
15958 fd == sipsock ? "UDP" : "TCP",req.data);
15959
15960 if(parse_request(&req) == -1)
15961 return 1;
15962
15963 req.method = find_sip_method(req.rlPart1);
15964
15965 if (ast_test_flag(&req, SIP_PKT_DEBUG))
15966 ast_verbose("--- (%d headers %d lines)%s ---\n", req.headers, req.lines, (req.headers + req.lines == 0) ? " Nat keepalive" : "");
15967
15968 if (req.headers < 2)
15969 return 1;
15970
15971
15972 for (lockretry = 100; lockretry > 0; lockretry--) {
15973 ast_mutex_lock(&netlock);
15974
15975
15976 p = find_call(&req, &sin, req.method);
15977 if (p == NULL) {
15978 if (option_debug)
15979 ast_log(LOG_DEBUG, "Invalid SIP message - rejected , no callid, len %d\n", req.len);
15980 ast_mutex_unlock(&netlock);
15981 return 1;
15982 }
15983
15984
15985 if (!p->owner || !ast_channel_trylock(p->owner))
15986 break;
15987 if (lockretry == 1) {
15988 if (option_debug) {
15989 ast_log(LOG_DEBUG, "Failed to grab owner channel lock. (SIP call %s)\n", p->callid);
15990 }
15991 } else {
15992 if (option_debug) {
15993 ast_log(LOG_DEBUG, "Failed to grab owner channel lock, trying again. (SIP call %s)\n", p->callid);
15994 }
15995 ast_mutex_unlock(&p->lock);
15996 ast_mutex_unlock(&netlock);
15997
15998 usleep(1);
15999 }
16000 }
16001 p->recv = sin;
16002
16003 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
16004 append_history(p, "Rx", "%s / %s / %s", req.data, get_header(&req, "CSeq"), req.rlPart2);
16005
16006 if (!lockretry) {
16007
16008
16009 if (p->owner)
16010 ast_log(LOG_ERROR, "We could NOT get the channel lock for %s! \n", S_OR(p->owner->name, "- no channel name ??? - "));
16011 ast_log(LOG_ERROR, "SIP transaction failed: %s \n", p->callid);
16012 if (req.method != SIP_ACK)
16013 transmit_response(p, "503 Server error", &req);
16014
16015 append_history(p, "LockFail", "Owner lock failed, transaction failed.");
16016 ast_mutex_unlock(&p->lock);
16017 ast_mutex_unlock(&netlock);
16018 return 1;
16019 }
16020 nounlock = 0;
16021
16022 if (fd != sipsock) {
16023 p->sockfd=fd;
16024 ast_set_flag(&p->flags[1], SIP_PAGE2_TCP);
16025 } else {
16026 p->sockfd=-1;
16027 }
16028 if (handle_request(p, &req, &sin, &recount, &nounlock) == -1) {
16029
16030 if (option_debug)
16031 ast_log(LOG_DEBUG, "SIP message could not be handled, bad request: %-70.70s\n", p->callid[0] ? p->callid : "<no callid>");
16032 }
16033
16034 if (p->owner && !nounlock)
16035 ast_channel_unlock(p->owner);
16036 ast_mutex_unlock(&p->lock);
16037 ast_mutex_unlock(&netlock);
16038 if (recount)
16039 ast_update_use_count();
16040
16041 return 1;
16042 }
16043
16044
16045 static int siptcpsock_accept(int *id, int fd, short events, void *ignore)
16046 {
16047 struct sockaddr_in sa;
16048 socklen_t sa_len=sizeof(sa);
16049 int newfd;
16050
16051 if ((newfd=accept(siptcpsock, (struct sockaddr *)&sa, &sa_len)) >= 0)
16052 ast_io_add(io, newfd, sipsock_read, AST_IO_IN, NULL);
16053 return 1;
16054 }
16055
16056
16057 static int sip_send_mwi_to_peer(struct sip_peer *peer)
16058 {
16059
16060 struct sip_pvt *p;
16061 int newmsgs, oldmsgs;
16062
16063
16064 if (!peer->addr.sin_addr.s_addr && !peer->defaddr.sin_addr.s_addr)
16065 return 0;
16066
16067
16068 ast_app_inboxcount(peer->mailbox, &newmsgs, &oldmsgs);
16069
16070 peer->lastmsgcheck = time(NULL);
16071
16072
16073 if (((newmsgs > 0x7fff ? 0x7fff0000 : (newmsgs << 16)) | (oldmsgs > 0xffff ? 0xffff : oldmsgs)) == peer->lastmsgssent) {
16074 return 0;
16075 }
16076
16077
16078 peer->lastmsgssent = ((newmsgs > 0x7fff ? 0x7fff0000 : (newmsgs << 16)) | (oldmsgs > 0xffff ? 0xffff : oldmsgs));
16079
16080 if (peer->mwipvt) {
16081
16082 p = peer->mwipvt;
16083 } else {
16084
16085 if (!(p = sip_alloc(NULL, NULL, 0, SIP_NOTIFY)))
16086 return -1;
16087 if (create_addr_from_peer(p, peer)) {
16088
16089 sip_destroy(p);
16090 return 0;
16091 }
16092
16093 if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
16094 p->ourip = __ourip;
16095 build_via(p);
16096 build_callid_pvt(p);
16097
16098 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
16099 }
16100
16101 ast_set_flag(&p->flags[0], SIP_OUTGOING);
16102 transmit_notify_with_mwi(p, newmsgs, oldmsgs, peer->vmexten);
16103 return 0;
16104 }
16105
16106
16107 static int does_peer_need_mwi(struct sip_peer *peer)
16108 {
16109 time_t t = time(NULL);
16110
16111 if (ast_test_flag(&peer->flags[1], SIP_PAGE2_SUBSCRIBEMWIONLY) &&
16112 !peer->mwipvt) {
16113 peer->lastmsgcheck = t;
16114 return FALSE;
16115 }
16116
16117 if (!ast_strlen_zero(peer->mailbox) && (t - peer->lastmsgcheck) > global_mwitime)
16118 return TRUE;
16119
16120 return FALSE;
16121 }
16122
16123
16124
16125
16126
16127
16128 static void *do_monitor(void *data)
16129 {
16130 int res;
16131 struct sip_pvt *sip;
16132 struct sip_peer *peer = NULL;
16133 time_t t;
16134 int fastrestart = FALSE;
16135 int lastpeernum = -1;
16136 int curpeernum;
16137 int reloading;
16138
16139
16140 if (sipsock > -1)
16141 sipsock_read_id = ast_io_add(io, sipsock, sipsock_read, AST_IO_IN, NULL);
16142 if (siptcpsock > -1)
16143 siptcpsock_read_id = ast_io_add(io, siptcpsock, siptcpsock_accept, AST_IO_IN, NULL);
16144
16145
16146 for(;;) {
16147
16148 ast_mutex_lock(&sip_reload_lock);
16149 reloading = sip_reloading;
16150 sip_reloading = FALSE;
16151 ast_mutex_unlock(&sip_reload_lock);
16152 if (reloading) {
16153 if (option_verbose > 0)
16154 ast_verbose(VERBOSE_PREFIX_1 "Reloading SIP\n");
16155 sip_do_reload(sip_reloadreason);
16156
16157
16158 if (sipsock > -1) {
16159 if (sipsock_read_id)
16160 sipsock_read_id = ast_io_change(io, sipsock_read_id, sipsock, NULL, 0, NULL);
16161 else
16162 sipsock_read_id = ast_io_add(io, sipsock, sipsock_read, AST_IO_IN, NULL);
16163 } else if (sipsock_read_id) {
16164 ast_io_remove(io, sipsock_read_id);
16165 sipsock_read_id = NULL;
16166 }
16167
16168 if (siptcpsock > -1) {
16169 if (siptcpsock_read_id)
16170 siptcpsock_read_id = ast_io_change(io, siptcpsock_read_id, siptcpsock, NULL, 0, NULL);
16171 else
16172 siptcpsock_read_id = ast_io_add(io, siptcpsock, siptcpsock_accept, AST_IO_IN, NULL);
16173 }
16174 }
16175 restartsearch:
16176
16177 ast_mutex_lock(&iflock);
16178 t = time(NULL);
16179
16180
16181
16182
16183 for (sip = iflist; !fastrestart && sip; sip = sip->next) {
16184
16185
16186
16187
16188
16189 if (ast_mutex_trylock(&sip->lock))
16190 continue;
16191
16192
16193 if (sip->rtp && sip->owner &&
16194 (sip->owner->_state == AST_STATE_UP) &&
16195 !sip->redirip.sin_addr.s_addr &&
16196 sip->t38.state != T38_ENABLED) {
16197 if (sip->lastrtptx &&
16198 ast_rtp_get_rtpkeepalive(sip->rtp) &&
16199 (t > sip->lastrtptx + ast_rtp_get_rtpkeepalive(sip->rtp))) {
16200
16201 sip->lastrtptx = time(NULL);
16202 ast_rtp_sendcng(sip->rtp, 0);
16203 }
16204 if (sip->lastrtprx &&
16205 (ast_rtp_get_rtptimeout(sip->rtp) || ast_rtp_get_rtpholdtimeout(sip->rtp)) &&
16206 (t > sip->lastrtprx + ast_rtp_get_rtptimeout(sip->rtp))) {
16207
16208 struct sockaddr_in sin;
16209 ast_rtp_get_peer(sip->rtp, &sin);
16210 if (sin.sin_addr.s_addr ||
16211 (ast_rtp_get_rtpholdtimeout(sip->rtp) &&
16212 (t > sip->lastrtprx + ast_rtp_get_rtpholdtimeout(sip->rtp)))) {
16213
16214 if (ast_rtp_get_rtptimeout(sip->rtp)) {
16215 while (sip->owner && ast_channel_trylock(sip->owner)) {
16216 DEADLOCK_AVOIDANCE(&sip->lock);
16217 }
16218 if (sip->owner) {
16219 ast_log(LOG_NOTICE,
16220 "Disconnecting call '%s' for lack of RTP activity in %ld seconds\n",
16221 sip->owner->name,
16222 (long) (t - sip->lastrtprx));
16223
16224 ast_softhangup_nolock(sip->owner, AST_SOFTHANGUP_DEV);
16225 ast_channel_unlock(sip->owner);
16226
16227
16228
16229
16230 ast_rtp_set_rtptimeout(sip->rtp, 0);
16231 ast_rtp_set_rtpholdtimeout(sip->rtp, 0);
16232 if (sip->vrtp) {
16233 ast_rtp_set_rtptimeout(sip->vrtp, 0);
16234 ast_rtp_set_rtpholdtimeout(sip->vrtp, 0);
16235 }
16236 }
16237 }
16238 }
16239 }
16240 }
16241
16242 if (ast_test_flag(&sip->flags[0], SIP_NEEDDESTROY) && !sip->packets &&
16243 !sip->owner) {
16244 ast_mutex_unlock(&sip->lock);
16245 __sip_destroy(sip, 1);
16246 ast_mutex_unlock(&iflock);
16247 usleep(1);
16248 goto restartsearch;
16249 }
16250 ast_mutex_unlock(&sip->lock);
16251 }
16252 ast_mutex_unlock(&iflock);
16253
16254
16255
16256
16257
16258
16259
16260 pthread_testcancel();
16261
16262 res = ast_sched_wait(sched);
16263 if ((res < 0) || (res > 1000))
16264 res = 1000;
16265
16266 if (fastrestart)
16267 res = 1;
16268 res = ast_io_wait(io, res);
16269 if (option_debug && res > 20)
16270 ast_log(LOG_DEBUG, "chan_sip: ast_io_wait ran %d all at once\n", res);
16271 ast_mutex_lock(&monlock);
16272 res = ast_sched_runq(sched);
16273 if (option_debug && res >= 20)
16274 ast_log(LOG_DEBUG, "chan_sip: ast_sched_runq ran %d all at once\n", res);
16275
16276
16277 t = time(NULL);
16278 fastrestart = FALSE;
16279 curpeernum = 0;
16280 peer = NULL;
16281
16282 ASTOBJ_CONTAINER_TRAVERSE(&peerl, !peer, do {
16283 if ((curpeernum > lastpeernum) && does_peer_need_mwi(iterator)) {
16284 fastrestart = TRUE;
16285 lastpeernum = curpeernum;
16286 peer = ASTOBJ_REF(iterator);
16287 };
16288 curpeernum++;
16289 } while (0)
16290 );
16291
16292 if (peer) {
16293 ASTOBJ_WRLOCK(peer);
16294 sip_send_mwi_to_peer(peer);
16295 ASTOBJ_UNLOCK(peer);
16296 ASTOBJ_UNREF(peer,sip_destroy_peer);
16297 } else {
16298
16299 lastpeernum = -1;
16300 }
16301 ast_mutex_unlock(&monlock);
16302 }
16303
16304 return NULL;
16305
16306 }
16307
16308
16309 static int restart_monitor(void)
16310 {
16311
16312 if (monitor_thread == AST_PTHREADT_STOP)
16313 return 0;
16314 ast_mutex_lock(&monlock);
16315 if (monitor_thread == pthread_self()) {
16316 ast_mutex_unlock(&monlock);
16317 ast_log(LOG_WARNING, "Cannot kill myself\n");
16318 return -1;
16319 }
16320 if (monitor_thread != AST_PTHREADT_NULL) {
16321
16322 pthread_kill(monitor_thread, SIGURG);
16323 } else {
16324
16325 if (ast_pthread_create_background(&monitor_thread, NULL, do_monitor, NULL) < 0) {
16326 ast_mutex_unlock(&monlock);
16327 ast_log(LOG_ERROR, "Unable to start monitor thread.\n");
16328 return -1;
16329 }
16330 }
16331 ast_mutex_unlock(&monlock);
16332 return 0;
16333 }
16334
16335
16336 static int sip_poke_noanswer(const void *data)
16337 {
16338 struct sip_peer *peer = (struct sip_peer *)data;
16339
16340 peer->pokeexpire = -1;
16341 if (peer->lastms > -1) {
16342 ast_log(LOG_NOTICE, "Peer '%s' is now UNREACHABLE! Last qualify: %d\n", peer->name, peer->lastms);
16343 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "Peer: SIP/%s\r\nPeerStatus: Unreachable\r\nTime: %d\r\n", peer->name, -1);
16344 }
16345 if (peer->call)
16346 sip_destroy(peer->call);
16347 peer->call = NULL;
16348 peer->lastms = -1;
16349 ast_device_state_changed("SIP/%s", peer->name);
16350
16351
16352 if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
16353 struct sip_peer *peer_ptr = peer;
16354 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
16355 }
16356
16357
16358
16359 peer->pokeexpire = ast_sched_add(sched, DEFAULT_FREQ_NOTOK, sip_poke_peer_s, peer);
16360 if (peer->pokeexpire == -1) {
16361 ASTOBJ_UNREF(peer, sip_destroy_peer);
16362 }
16363
16364 return 0;
16365 }
16366
16367
16368
16369
16370 static int sip_poke_peer(struct sip_peer *peer)
16371 {
16372 struct sip_pvt *p;
16373 int xmitres = 0;
16374
16375 if (!peer->maxms || !peer->addr.sin_addr.s_addr) {
16376
16377
16378 if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
16379 struct sip_peer *peer_ptr = peer;
16380 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
16381 }
16382 peer->lastms = 0;
16383 peer->call = NULL;
16384 return 0;
16385 }
16386 if (peer->call) {
16387 if (sipdebug)
16388 ast_log(LOG_NOTICE, "Still have a QUALIFY dialog active, deleting\n");
16389 sip_destroy(peer->call);
16390 }
16391 if (!(p = peer->call = sip_alloc(NULL, NULL, 0, SIP_OPTIONS)))
16392 return -1;
16393
16394 p->sa = peer->addr;
16395 p->recv = peer->addr;
16396 ast_copy_flags(&p->flags[0], &peer->flags[0], SIP_FLAGS_TO_COPY);
16397 ast_copy_flags(&p->flags[1], &peer->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
16398 ast_copy_flags(&p->flags[1], &peer->flags[1], SIP_PAGE2_TCP | SIP_PAGE2_TCP_CONNECTED);
16399 p->sockfd = peer->sockfd;
16400
16401
16402 if (!ast_strlen_zero(peer->fullcontact))
16403 ast_string_field_set(p, fullcontact, peer->fullcontact);
16404
16405 if (!ast_strlen_zero(peer->tohost))
16406 ast_string_field_set(p, tohost, peer->tohost);
16407 else
16408 ast_string_field_set(p, tohost, ast_inet_ntoa(peer->addr.sin_addr));
16409
16410
16411 if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
16412 p->ourip = __ourip;
16413 build_via(p);
16414 build_callid_pvt(p);
16415
16416 if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
16417 struct sip_peer *peer_ptr = peer;
16418 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
16419 }
16420
16421 p->relatedpeer = ASTOBJ_REF(peer);
16422 ast_set_flag(&p->flags[0], SIP_OUTGOING);
16423 #ifdef VOCAL_DATA_HACK
16424 ast_copy_string(p->username, "__VOCAL_DATA_SHOULD_READ_THE_SIP_SPEC__", sizeof(p->username));
16425 xmitres = transmit_invite(p, SIP_INVITE, 0, 2);
16426 #else
16427 xmitres = transmit_invite(p, SIP_OPTIONS, 0, 2);
16428 #endif
16429 gettimeofday(&peer->ps, NULL);
16430 if (xmitres == XMIT_ERROR) {
16431 sip_poke_noanswer(ASTOBJ_REF(peer));
16432 } else {
16433 if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
16434 struct sip_peer *peer_ptr = peer;
16435 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
16436 }
16437 peer->pokeexpire = ast_sched_add(sched, peer->maxms * 2, sip_poke_noanswer, ASTOBJ_REF(peer));
16438 if (peer->pokeexpire == -1) {
16439 struct sip_peer *peer_ptr = peer;
16440 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
16441 }
16442 }
16443
16444 return 0;
16445 }
16446
16447
16448
16449
16450
16451
16452
16453
16454
16455
16456
16457
16458
16459
16460
16461
16462
16463
16464
16465
16466
16467
16468
16469
16470
16471
16472
16473
16474
16475
16476
16477
16478
16479
16480 static int sip_devicestate(void *data)
16481 {
16482 char *host;
16483 char *tmp;
16484
16485 struct hostent *hp;
16486 struct ast_hostent ahp;
16487 struct sip_peer *p;
16488
16489 int res = AST_DEVICE_INVALID;
16490
16491
16492 host = ast_strdupa(data ? data : "");
16493 if ((tmp = strchr(host, '@')))
16494 host = tmp + 1;
16495
16496 if (option_debug > 2)
16497 ast_log(LOG_DEBUG, "Checking device state for peer %s\n", host);
16498
16499
16500
16501
16502
16503
16504
16505
16506 if ((p = find_peer(host, NULL, 0, 1))) {
16507 if (p->addr.sin_addr.s_addr || p->defaddr.sin_addr.s_addr) {
16508
16509
16510
16511
16512
16513
16514
16515
16516
16517
16518
16519 if (p->onHold)
16520
16521 res = AST_DEVICE_ONHOLD;
16522 else if (p->inRinging) {
16523 if (p->inRinging == p->inUse)
16524 res = AST_DEVICE_RINGING;
16525 else
16526 res = AST_DEVICE_RINGINUSE;
16527 } else if (p->call_limit && (p->inUse == p->call_limit))
16528
16529 res = AST_DEVICE_BUSY;
16530 else if (p->call_limit && p->inUse)
16531
16532 res = AST_DEVICE_INUSE;
16533 else if (p->maxms && ((p->lastms > p->maxms) || (p->lastms < 0)))
16534
16535 res = AST_DEVICE_UNAVAILABLE;
16536 else
16537 res = AST_DEVICE_NOT_INUSE;
16538 } else {
16539
16540 res = AST_DEVICE_UNAVAILABLE;
16541 }
16542 ASTOBJ_UNREF(p,sip_destroy_peer);
16543 } else {
16544 char *port = strchr(host, ':');
16545 if (port)
16546 *port = '\0';
16547 hp = ast_gethostbyname(host, &ahp);
16548 if (hp)
16549 res = AST_DEVICE_UNKNOWN;
16550 }
16551
16552 return res;
16553 }
16554
16555
16556
16557 static struct ast_channel *sip_request_call(const char *type, int format, void *data, int *cause)
16558 {
16559 int oldformat;
16560 struct sip_pvt *p;
16561 struct ast_channel *tmpc = NULL;
16562 char *ext, *host;
16563 char tmp[256];
16564 char *dest = data;
16565
16566 oldformat = format;
16567 if (!(format &= ((AST_FORMAT_MAX_AUDIO << 1) - 1))) {
16568 ast_log(LOG_NOTICE, "Asked to get a channel of unsupported format %s while capability is %s\n", ast_getformatname(oldformat), ast_getformatname(global_capability));
16569 *cause = AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
16570 return NULL;
16571 }
16572 if (option_debug)
16573 ast_log(LOG_DEBUG, "Asked to create a SIP channel with formats: %s\n", ast_getformatname_multiple(tmp, sizeof(tmp), oldformat));
16574
16575 if (!(p = sip_alloc(NULL, NULL, 0, SIP_INVITE))) {
16576 ast_log(LOG_ERROR, "Unable to build sip pvt data for '%s' (Out of memory or socket error)\n", (char *)data);
16577 *cause = AST_CAUSE_SWITCH_CONGESTION;
16578 return NULL;
16579 }
16580
16581 ast_set_flag(&p->flags[1], SIP_PAGE2_OUTGOING_CALL);
16582
16583 if (!(p->options = ast_calloc(1, sizeof(*p->options)))) {
16584 sip_destroy(p);
16585 ast_log(LOG_ERROR, "Unable to build option SIP data structure - Out of memory\n");
16586 *cause = AST_CAUSE_SWITCH_CONGESTION;
16587 return NULL;
16588 }
16589
16590 ast_copy_string(tmp, dest, sizeof(tmp));
16591 host = strchr(tmp, '@');
16592 if (host) {
16593 *host++ = '\0';
16594 ext = tmp;
16595 } else {
16596 ext = strchr(tmp, '/');
16597 if (ext)
16598 *ext++ = '\0';
16599 host = tmp;
16600 }
16601
16602 if (create_addr(p, host)) {
16603 *cause = AST_CAUSE_UNREGISTERED;
16604 if (option_debug > 2)
16605 ast_log(LOG_DEBUG, "Cant create SIP call - target device not registred\n");
16606 sip_destroy(p);
16607 return NULL;
16608 }
16609 if (ast_strlen_zero(p->peername) && ext)
16610 ast_string_field_set(p, peername, ext);
16611
16612 if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
16613 p->ourip = __ourip;
16614 build_via(p);
16615 build_callid_pvt(p);
16616
16617
16618
16619
16620
16621 if (ext) {
16622 ast_string_field_set(p, username, ext);
16623 ast_string_field_free(p, fullcontact);
16624 }
16625 #if 0
16626 printf("Setting up to call extension '%s' at '%s'\n", ext ? ext : "<none>", host);
16627 #endif
16628 p->prefcodec = oldformat;
16629 ast_mutex_lock(&p->lock);
16630 tmpc = sip_new(p, AST_STATE_DOWN, host);
16631 ast_mutex_unlock(&p->lock);
16632 if (!tmpc)
16633 sip_destroy(p);
16634 ast_update_use_count();
16635 restart_monitor();
16636 return tmpc;
16637 }
16638
16639
16640
16641
16642
16643
16644
16645 static void set_insecure_flags(struct ast_flags *flags, const char *value, int lineno)
16646 {
16647 static int dep_insecure_very = 0;
16648 static int dep_insecure_yes = 0;
16649
16650 if (ast_strlen_zero(value))
16651 return;
16652
16653 if (!strcasecmp(value, "very")) {
16654 ast_set_flag(flags, SIP_INSECURE_PORT | SIP_INSECURE_INVITE);
16655 if(!dep_insecure_very) {
16656 if(lineno != -1)
16657 ast_log(LOG_WARNING, "insecure=very at line %d is deprecated; use insecure=port,invite instead\n", lineno);
16658 else
16659 ast_log(LOG_WARNING, "insecure=very is deprecated; use insecure=port,invite instead\n");
16660 dep_insecure_very = 1;
16661 }
16662 }
16663 else if (ast_true(value)) {
16664 ast_set_flag(flags, SIP_INSECURE_PORT);
16665 if(!dep_insecure_yes) {
16666 if(lineno != -1)
16667 ast_log(LOG_WARNING, "insecure=%s at line %d is deprecated; use insecure=port instead\n", value, lineno);
16668 else
16669 ast_log(LOG_WARNING, "insecure=%s is deprecated; use insecure=port instead\n", value);
16670 dep_insecure_yes = 1;
16671 }
16672 }
16673 else if (!ast_false(value)) {
16674 char buf[64];
16675 char *word, *next;
16676 ast_copy_string(buf, value, sizeof(buf));
16677 next = buf;
16678 while ((word = strsep(&next, ","))) {
16679 if (!strcasecmp(word, "port"))
16680 ast_set_flag(flags, SIP_INSECURE_PORT);
16681 else if (!strcasecmp(word, "invite"))
16682 ast_set_flag(flags, SIP_INSECURE_INVITE);
16683 else
16684 ast_log(LOG_WARNING, "Unknown insecure mode '%s' on line %d\n", value, lineno);
16685 }
16686 }
16687 }
16688
16689
16690
16691
16692
16693
16694
16695
16696 static int handle_common_options(struct ast_flags *flags, struct ast_flags *mask, struct ast_variable *v)
16697 {
16698 int res = 1;
16699
16700 if (!strcasecmp(v->name, "trustrpid")) {
16701 ast_set_flag(&mask[0], SIP_TRUSTRPID);
16702 ast_set2_flag(&flags[0], ast_true(v->value), SIP_TRUSTRPID);
16703 } else if (!strcasecmp(v->name, "sendrpid")) {
16704 ast_set_flag(&mask[0], SIP_SENDRPID);
16705 ast_set2_flag(&flags[0], ast_true(v->value), SIP_SENDRPID);
16706 } else if (!strcasecmp(v->name, "g726nonstandard")) {
16707 ast_set_flag(&mask[0], SIP_G726_NONSTANDARD);
16708 ast_set2_flag(&flags[0], ast_true(v->value), SIP_G726_NONSTANDARD);
16709 } else if (!strcasecmp(v->name, "useclientcode")) {
16710 ast_set_flag(&mask[0], SIP_USECLIENTCODE);
16711 ast_set2_flag(&flags[0], ast_true(v->value), SIP_USECLIENTCODE);
16712 } else if (!strcasecmp(v->name, "dtmfmode")) {
16713 ast_set_flag(&mask[0], SIP_DTMF);
16714 ast_clear_flag(&flags[0], SIP_DTMF);
16715 if (!strcasecmp(v->value, "inband"))
16716 ast_set_flag(&flags[0], SIP_DTMF_INBAND);
16717 else if (!strcasecmp(v->value, "rfc2833"))
16718 ast_set_flag(&flags[0], SIP_DTMF_RFC2833);
16719 else if (!strcasecmp(v->value, "info"))
16720 ast_set_flag(&flags[0], SIP_DTMF_INFO);
16721 else if (!strcasecmp(v->value, "auto"))
16722 ast_set_flag(&flags[0], SIP_DTMF_AUTO);
16723 else {
16724 ast_log(LOG_WARNING, "Unknown dtmf mode '%s' on line %d, using rfc2833\n", v->value, v->lineno);
16725 ast_set_flag(&flags[0], SIP_DTMF_RFC2833);
16726 }
16727 } else if (!strcasecmp(v->name, "nat")) {
16728 ast_set_flag(&mask[0], SIP_NAT);
16729 ast_clear_flag(&flags[0], SIP_NAT);
16730 if (!strcasecmp(v->value, "never"))
16731 ast_set_flag(&flags[0], SIP_NAT_NEVER);
16732 else if (!strcasecmp(v->value, "route"))
16733 ast_set_flag(&flags[0], SIP_NAT_ROUTE);
16734 else if (ast_true(v->value))
16735 ast_set_flag(&flags[0], SIP_NAT_ALWAYS);
16736 else
16737 ast_set_flag(&flags[0], SIP_NAT_RFC3581);
16738 } else if (!strcasecmp(v->name, "canreinvite")) {
16739 ast_set_flag(&mask[0], SIP_REINVITE);
16740 ast_clear_flag(&flags[0], SIP_REINVITE);
16741 if(ast_true(v->value)) {
16742 ast_set_flag(&flags[0], SIP_CAN_REINVITE | SIP_CAN_REINVITE_NAT);
16743 } else if (!ast_false(v->value)) {
16744 char buf[64];
16745 char *word, *next = buf;
16746
16747 ast_copy_string(buf, v->value, sizeof(buf));
16748 while ((word = strsep(&next, ","))) {
16749 if(!strcasecmp(word, "update")) {
16750 ast_set_flag(&flags[0], SIP_REINVITE_UPDATE | SIP_CAN_REINVITE);
16751 } else if(!strcasecmp(word, "nonat")) {
16752 ast_set_flag(&flags[0], SIP_CAN_REINVITE);
16753 ast_clear_flag(&flags[0], SIP_CAN_REINVITE_NAT);
16754 } else {
16755 ast_log(LOG_WARNING, "Unknown canreinvite mode '%s' on line %d\n", v->value, v->lineno);
16756 }
16757 }
16758 }
16759 } else if (!strcasecmp(v->name, "insecure")) {
16760 ast_set_flag(&mask[0], SIP_INSECURE_PORT | SIP_INSECURE_INVITE);
16761 ast_clear_flag(&flags[0], SIP_INSECURE_PORT | SIP_INSECURE_INVITE);
16762 set_insecure_flags(flags, v->value, v->lineno);
16763 } else if (!strcasecmp(v->name, "progressinband")) {
16764 ast_set_flag(&mask[0], SIP_PROG_INBAND);
16765 ast_clear_flag(&flags[0], SIP_PROG_INBAND);
16766 if (ast_true(v->value))
16767 ast_set_flag(&flags[0], SIP_PROG_INBAND_YES);
16768 else if (strcasecmp(v->value, "never"))
16769 ast_set_flag(&flags[0], SIP_PROG_INBAND_NO);
16770 } else if (!strcasecmp(v->name, "promiscredir")) {
16771 ast_set_flag(&mask[0], SIP_PROMISCREDIR);
16772 ast_set2_flag(&flags[0], ast_true(v->value), SIP_PROMISCREDIR);
16773 } else if (!strcasecmp(v->name, "videosupport")) {
16774 ast_set_flag(&mask[1], SIP_PAGE2_VIDEOSUPPORT);
16775 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_VIDEOSUPPORT);
16776 } else if (!strcasecmp(v->name, "allowoverlap")) {
16777 ast_set_flag(&mask[1], SIP_PAGE2_ALLOWOVERLAP);
16778 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_ALLOWOVERLAP);
16779 } else if (!strcasecmp(v->name, "allowsubscribe")) {
16780 ast_set_flag(&mask[1], SIP_PAGE2_ALLOWSUBSCRIBE);
16781 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_ALLOWSUBSCRIBE);
16782 } else if (!strcasecmp(v->name, "t38pt_udptl")) {
16783 ast_set_flag(&mask[1], SIP_PAGE2_T38SUPPORT_UDPTL);
16784 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_T38SUPPORT_UDPTL);
16785 #ifdef WHEN_WE_HAVE_T38_FOR_OTHER_TRANSPORTS
16786 } else if (!strcasecmp(v->name, "t38pt_rtp")) {
16787 ast_set_flag(&mask[1], SIP_PAGE2_T38SUPPORT_RTP);
16788 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_T38SUPPORT_RTP);
16789 } else if (!strcasecmp(v->name, "t38pt_tcp")) {
16790 ast_set_flag(&mask[1], SIP_PAGE2_T38SUPPORT_TCP);
16791 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_T38SUPPORT_TCP);
16792 #endif
16793 } else if (!strcasecmp(v->name, "rfc2833compensate")) {
16794 ast_set_flag(&mask[1], SIP_PAGE2_RFC2833_COMPENSATE);
16795 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_RFC2833_COMPENSATE);
16796 } else if (!strcasecmp(v->name, "buggymwi")) {
16797 ast_set_flag(&mask[1], SIP_PAGE2_BUGGY_MWI);
16798 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_BUGGY_MWI);
16799 } else if (!strcasecmp(v->name, "t38pt_usertpsource")) {
16800 ast_set_flag(&mask[1], SIP_PAGE2_UDPTL_DESTINATION);
16801 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_UDPTL_DESTINATION);
16802 } else
16803 res = 0;
16804
16805 return res;
16806 }
16807
16808
16809 static int add_sip_domain(const char *domain, const enum domain_mode mode, const char *context)
16810 {
16811 struct domain *d;
16812
16813 if (ast_strlen_zero(domain)) {
16814 ast_log(LOG_WARNING, "Zero length domain.\n");
16815 return 1;
16816 }
16817
16818 if (!(d = ast_calloc(1, sizeof(*d))))
16819 return 0;
16820
16821 ast_copy_string(d->domain, domain, sizeof(d->domain));
16822
16823 if (!ast_strlen_zero(context))
16824 ast_copy_string(d->context, context, sizeof(d->context));
16825
16826 d->mode = mode;
16827
16828 AST_LIST_LOCK(&domain_list);
16829 AST_LIST_INSERT_TAIL(&domain_list, d, list);
16830 AST_LIST_UNLOCK(&domain_list);
16831
16832 if (sipdebug)
16833 ast_log(LOG_DEBUG, "Added local SIP domain '%s'\n", domain);
16834
16835 return 1;
16836 }
16837
16838
16839 static int check_sip_domain(const char *domain, char *context, size_t len)
16840 {
16841 struct domain *d;
16842 int result = 0;
16843
16844 AST_LIST_LOCK(&domain_list);
16845 AST_LIST_TRAVERSE(&domain_list, d, list) {
16846 if (strcasecmp(d->domain, domain))
16847 continue;
16848
16849 if (len && !ast_strlen_zero(d->context))
16850 ast_copy_string(context, d->context, len);
16851
16852 result = 1;
16853 break;
16854 }
16855 AST_LIST_UNLOCK(&domain_list);
16856
16857 return result;
16858 }
16859
16860
16861 static void clear_sip_domains(void)
16862 {
16863 struct domain *d;
16864
16865 AST_LIST_LOCK(&domain_list);
16866 while ((d = AST_LIST_REMOVE_HEAD(&domain_list, list)))
16867 free(d);
16868 AST_LIST_UNLOCK(&domain_list);
16869 }
16870
16871
16872
16873 static struct sip_auth *add_realm_authentication(struct sip_auth *authlist, char *configuration, int lineno)
16874 {
16875 char authcopy[256];
16876 char *username=NULL, *realm=NULL, *secret=NULL, *md5secret=NULL;
16877 char *stringp;
16878 struct sip_auth *a, *b, *auth;
16879
16880 if (ast_strlen_zero(configuration))
16881 return authlist;
16882
16883 if (option_debug)
16884 ast_log(LOG_DEBUG, "Auth config :: %s\n", configuration);
16885
16886 ast_copy_string(authcopy, configuration, sizeof(authcopy));
16887 stringp = authcopy;
16888
16889 username = stringp;
16890 realm = strrchr(stringp, '@');
16891 if (realm)
16892 *realm++ = '\0';
16893 if (ast_strlen_zero(username) || ast_strlen_zero(realm)) {
16894 ast_log(LOG_WARNING, "Format for authentication entry is user[:secret]@realm at line %d\n", lineno);
16895 return authlist;
16896 }
16897 stringp = username;
16898 username = strsep(&stringp, ":");
16899 if (username) {
16900 secret = strsep(&stringp, ":");
16901 if (!secret) {
16902 stringp = username;
16903 md5secret = strsep(&stringp,"#");
16904 }
16905 }
16906 if (!(auth = ast_calloc(1, sizeof(*auth))))
16907 return authlist;
16908
16909 ast_copy_string(auth->realm, realm, sizeof(auth->realm));
16910 ast_copy_string(auth->username, username, sizeof(auth->username));
16911 if (secret)
16912 ast_copy_string(auth->secret, secret, sizeof(auth->secret));
16913 if (md5secret)
16914 ast_copy_string(auth->md5secret, md5secret, sizeof(auth->md5secret));
16915
16916
16917 for (b = NULL, a = authlist; a ; b = a, a = a->next)
16918 ;
16919 if (b)
16920 b->next = auth;
16921 else
16922 authlist = auth;
16923
16924 if (option_verbose > 2)
16925 ast_verbose("Added authentication for realm %s\n", realm);
16926
16927 return authlist;
16928
16929 }
16930
16931
16932 static int clear_realm_authentication(struct sip_auth *authlist)
16933 {
16934 struct sip_auth *a = authlist;
16935 struct sip_auth *b;
16936
16937 while (a) {
16938 b = a;
16939 a = a->next;
16940 free(b);
16941 }
16942
16943 return 1;
16944 }
16945
16946
16947 static struct sip_auth *find_realm_authentication(struct sip_auth *authlist, const char *realm)
16948 {
16949 struct sip_auth *a;
16950
16951 for (a = authlist; a; a = a->next) {
16952 if (!strcasecmp(a->realm, realm))
16953 break;
16954 }
16955
16956 return a;
16957 }
16958
16959
16960 static struct sip_user *build_user(const char *name, struct ast_variable *v, struct ast_variable *alt, int realtime)
16961 {
16962 struct sip_user *user;
16963 int format;
16964 struct ast_ha *oldha = NULL;
16965 char *varname = NULL, *varval = NULL;
16966 struct ast_variable *tmpvar = NULL;
16967 struct ast_flags userflags[2] = {{(0)}};
16968 struct ast_flags mask[2] = {{(0)}};
16969
16970
16971 if (!(user = ast_calloc(1, sizeof(*user))))
16972 return NULL;
16973
16974 suserobjs++;
16975 ASTOBJ_INIT(user);
16976 ast_copy_string(user->name, name, sizeof(user->name));
16977 oldha = user->ha;
16978 user->ha = NULL;
16979 ast_copy_flags(&user->flags[0], &global_flags[0], SIP_FLAGS_TO_COPY);
16980 ast_copy_flags(&user->flags[1], &global_flags[1], SIP_PAGE2_FLAGS_TO_COPY);
16981 user->capability = global_capability;
16982 user->allowtransfer = global_allowtransfer;
16983 user->maxcallbitrate = default_maxcallbitrate;
16984 user->autoframing = global_autoframing;
16985 user->prefs = default_prefs;
16986
16987 strcpy(user->context, default_context);
16988 strcpy(user->language, default_language);
16989 strcpy(user->mohinterpret, default_mohinterpret);
16990 strcpy(user->mohsuggest, default_mohsuggest);
16991
16992 for (; v || ((v = alt) && !(alt=NULL)); v = v->next) {
16993 if (handle_common_options(&userflags[0], &mask[0], v))
16994 continue;
16995
16996 if (!strcasecmp(v->name, "context")) {
16997 ast_copy_string(user->context, v->value, sizeof(user->context));
16998 } else if (!strcasecmp(v->name, "subscribecontext")) {
16999 ast_copy_string(user->subscribecontext, v->value, sizeof(user->subscribecontext));
17000 } else if (!strcasecmp(v->name, "setvar")) {
17001 varname = ast_strdupa(v->value);
17002 if ((varval = strchr(varname,'='))) {
17003 *varval++ = '\0';
17004 if ((tmpvar = ast_variable_new(varname, varval))) {
17005 tmpvar->next = user->chanvars;
17006 user->chanvars = tmpvar;
17007 }
17008 }
17009 } else if (!strcasecmp(v->name, "permit") ||
17010 !strcasecmp(v->name, "deny")) {
17011 user->ha = ast_append_ha(v->name, v->value, user->ha);
17012 } else if (!strcasecmp(v->name, "allowtransfer")) {
17013 user->allowtransfer = ast_true(v->value) ? TRANSFER_OPENFORALL : TRANSFER_CLOSED;
17014 } else if (!strcasecmp(v->name, "secret")) {
17015 ast_copy_string(user->secret, v->value, sizeof(user->secret));
17016 } else if (!strcasecmp(v->name, "md5secret")) {
17017 ast_copy_string(user->md5secret, v->value, sizeof(user->md5secret));
17018 } else if (!strcasecmp(v->name, "callerid")) {
17019 ast_callerid_split(v->value, user->cid_name, sizeof(user->cid_name), user->cid_num, sizeof(user->cid_num));
17020 } else if (!strcasecmp(v->name, "fullname")) {
17021 ast_copy_string(user->cid_name, v->value, sizeof(user->cid_name));
17022 } else if (!strcasecmp(v->name, "cid_number")) {
17023 ast_copy_string(user->cid_num, v->value, sizeof(user->cid_num));
17024 } else if (!strcasecmp(v->name, "callgroup")) {
17025 user->callgroup = ast_get_group(v->value);
17026 } else if (!strcasecmp(v->name, "pickupgroup")) {
17027 user->pickupgroup = ast_get_group(v->value);
17028 } else if (!strcasecmp(v->name, "language")) {
17029 ast_copy_string(user->language, v->value, sizeof(user->language));
17030 } else if (!strcasecmp(v->name, "mohinterpret")
17031 || !strcasecmp(v->name, "musicclass") || !strcasecmp(v->name, "musiconhold")) {
17032 ast_copy_string(user->mohinterpret, v->value, sizeof(user->mohinterpret));
17033 } else if (!strcasecmp(v->name, "mohsuggest")) {
17034 ast_copy_string(user->mohsuggest, v->value, sizeof(user->mohsuggest));
17035 } else if (!strcasecmp(v->name, "accountcode")) {
17036 ast_copy_string(user->accountcode, v->value, sizeof(user->accountcode));
17037 } else if (!strcasecmp(v->name, "call-limit")) {
17038 user->call_limit = atoi(v->value);
17039 if (user->call_limit < 0)
17040 user->call_limit = 0;
17041 } else if (!strcasecmp(v->name, "amaflags")) {
17042 format = ast_cdr_amaflags2int(v->value);
17043 if (format < 0) {
17044 ast_log(LOG_WARNING, "Invalid AMA Flags: %s at line %d\n", v->value, v->lineno);
17045 } else {
17046 user->amaflags = format;
17047 }
17048 } else if (!strcasecmp(v->name, "allow")) {
17049 ast_parse_allow_disallow(&user->prefs, &user->capability, v->value, 1);
17050 } else if (!strcasecmp(v->name, "disallow")) {
17051 ast_parse_allow_disallow(&user->prefs, &user->capability, v->value, 0);
17052 } else if (!strcasecmp(v->name, "autoframing")) {
17053 user->autoframing = ast_true(v->value);
17054 } else if (!strcasecmp(v->name, "callingpres")) {
17055 user->callingpres = ast_parse_caller_presentation(v->value);
17056 if (user->callingpres == -1)
17057 user->callingpres = atoi(v->value);
17058 } else if (!strcasecmp(v->name, "maxcallbitrate")) {
17059 user->maxcallbitrate = atoi(v->value);
17060 if (user->maxcallbitrate < 0)
17061 user->maxcallbitrate = default_maxcallbitrate;
17062 }
17063
17064
17065
17066 }
17067 ast_copy_flags(&user->flags[0], &userflags[0], mask[0].flags);
17068 ast_copy_flags(&user->flags[1], &userflags[1], mask[1].flags);
17069 if (ast_test_flag(&user->flags[1], SIP_PAGE2_ALLOWSUBSCRIBE))
17070 global_allowsubscribe = TRUE;
17071 ast_free_ha(oldha);
17072 return user;
17073 }
17074
17075
17076 static void set_peer_defaults(struct sip_peer *peer)
17077 {
17078 if (peer->expire == 0) {
17079
17080
17081
17082 peer->expire = -1;
17083 peer->pokeexpire = -1;
17084 peer->addr.sin_port = htons(STANDARD_SIP_PORT);
17085 }
17086 ast_copy_flags(&peer->flags[0], &global_flags[0], SIP_FLAGS_TO_COPY);
17087 ast_copy_flags(&peer->flags[1], &global_flags[1], SIP_PAGE2_FLAGS_TO_COPY);
17088 strcpy(peer->context, default_context);
17089 strcpy(peer->subscribecontext, default_subscribecontext);
17090 strcpy(peer->language, default_language);
17091 strcpy(peer->mohinterpret, default_mohinterpret);
17092 strcpy(peer->mohsuggest, default_mohsuggest);
17093 peer->addr.sin_family = AF_INET;
17094 peer->defaddr.sin_family = AF_INET;
17095 peer->capability = global_capability;
17096 peer->maxcallbitrate = default_maxcallbitrate;
17097 peer->rtptimeout = global_rtptimeout;
17098 peer->rtpholdtimeout = global_rtpholdtimeout;
17099 peer->rtpkeepalive = global_rtpkeepalive;
17100 peer->allowtransfer = global_allowtransfer;
17101 peer->autoframing = global_autoframing;
17102 strcpy(peer->vmexten, default_vmexten);
17103 peer->secret[0] = '\0';
17104 peer->md5secret[0] = '\0';
17105 peer->cid_num[0] = '\0';
17106 peer->cid_name[0] = '\0';
17107 peer->fromdomain[0] = '\0';
17108 peer->fromuser[0] = '\0';
17109 peer->regexten[0] = '\0';
17110 peer->mailbox[0] = '\0';
17111 peer->callgroup = 0;
17112 peer->pickupgroup = 0;
17113 peer->maxms = default_qualify;
17114 peer->prefs = default_prefs;
17115 }
17116
17117
17118 static struct sip_peer *temp_peer(const char *name)
17119 {
17120 struct sip_peer *peer;
17121
17122 if (!(peer = ast_calloc(1, sizeof(*peer))))
17123 return NULL;
17124
17125 apeerobjs++;
17126 ASTOBJ_INIT(peer);
17127 set_peer_defaults(peer);
17128
17129 ast_copy_string(peer->name, name, sizeof(peer->name));
17130
17131 ast_set_flag(&peer->flags[1], SIP_PAGE2_SELFDESTRUCT);
17132 ast_set_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC);
17133 peer->prefs = default_prefs;
17134 reg_source_db(peer);
17135
17136 return peer;
17137 }
17138
17139
17140 static struct sip_peer *build_peer(const char *name, struct ast_variable *v, struct ast_variable *alt, int realtime)
17141 {
17142 struct sip_peer *peer = NULL;
17143 struct ast_ha *oldha = NULL;
17144 int obproxyfound=0;
17145 int found=0;
17146 int firstpass=1;
17147 int format=0;
17148 time_t regseconds = 0;
17149 char *varname = NULL, *varval = NULL;
17150 struct ast_variable *tmpvar = NULL;
17151 struct ast_flags peerflags[2] = {{(0)}};
17152 struct ast_flags mask[2] = {{(0)}};
17153 char fullcontact[sizeof(peer->fullcontact)] = "";
17154
17155 if (!realtime || ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS))
17156
17157
17158
17159
17160
17161 peer = ASTOBJ_CONTAINER_FIND_UNLINK_FULL(&peerl, name, name, 0, 0, strcmp);
17162
17163 if (peer) {
17164
17165 found = 1;
17166 if (!(peer->objflags & ASTOBJ_FLAG_MARKED))
17167 firstpass = 0;
17168 } else {
17169 if (!(peer = ast_calloc(1, sizeof(*peer))))
17170 return NULL;
17171
17172 if (realtime && !ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS))
17173 rpeerobjs++;
17174 else
17175 speerobjs++;
17176 ASTOBJ_INIT(peer);
17177 }
17178
17179 if (firstpass) {
17180 peer->lastmsgssent = -1;
17181 oldha = peer->ha;
17182 peer->ha = NULL;
17183 set_peer_defaults(peer);
17184 }
17185 if (!found && name)
17186 ast_copy_string(peer->name, name, sizeof(peer->name));
17187
17188
17189 if (peer->chanvars) {
17190 ast_variables_destroy(peer->chanvars);
17191 peer->chanvars = NULL;
17192
17193 }
17194
17195
17196 clear_realm_authentication(peer->auth);
17197 peer->auth = NULL;
17198 peer->sockfd = -1;
17199
17200 for (; v || ((v = alt) && !(alt=NULL)); v = v->next) {
17201 if (handle_common_options(&peerflags[0], &mask[0], v))
17202 continue;
17203 if (realtime && !strcasecmp(v->name, "regseconds")) {
17204 ast_get_time_t(v->value, ®seconds, 0, NULL);
17205 } else if (realtime && !strcasecmp(v->name, "ipaddr") && !ast_strlen_zero(v->value) ) {
17206 inet_aton(v->value, &(peer->addr.sin_addr));
17207 } else if (realtime && !strcasecmp(v->name, "name"))
17208 ast_copy_string(peer->name, v->value, sizeof(peer->name));
17209 else if (realtime && !strcasecmp(v->name, "fullcontact")) {
17210
17211 if (!ast_strlen_zero(fullcontact)) {
17212 strncat(fullcontact, ";", sizeof(fullcontact) - strlen(fullcontact) - 1);
17213 strncat(fullcontact, v->value, sizeof(fullcontact) - strlen(fullcontact) - 1);
17214 } else {
17215 ast_copy_string(fullcontact, v->value, sizeof(fullcontact));
17216 ast_set_flag(&peer->flags[1], SIP_PAGE2_RT_FROMCONTACT);
17217 }
17218 } else if (!strcasecmp(v->name, "secret"))
17219 ast_copy_string(peer->secret, v->value, sizeof(peer->secret));
17220 else if (!strcasecmp(v->name, "md5secret"))
17221 ast_copy_string(peer->md5secret, v->value, sizeof(peer->md5secret));
17222 else if (!strcasecmp(v->name, "auth"))
17223 peer->auth = add_realm_authentication(peer->auth, v->value, v->lineno);
17224 else if (!strcasecmp(v->name, "callerid")) {
17225 ast_callerid_split(v->value, peer->cid_name, sizeof(peer->cid_name), peer->cid_num, sizeof(peer->cid_num));
17226 } else if (!strcasecmp(v->name, "fullname")) {
17227 ast_copy_string(peer->cid_name, v->value, sizeof(peer->cid_name));
17228 } else if (!strcasecmp(v->name, "cid_number")) {
17229 ast_copy_string(peer->cid_num, v->value, sizeof(peer->cid_num));
17230 } else if (!strcasecmp(v->name, "context")) {
17231 ast_copy_string(peer->context, v->value, sizeof(peer->context));
17232 } else if (!strcasecmp(v->name, "subscribecontext")) {
17233 ast_copy_string(peer->subscribecontext, v->value, sizeof(peer->subscribecontext));
17234 } else if (!strcasecmp(v->name, "fromdomain")) {
17235 ast_copy_string(peer->fromdomain, v->value, sizeof(peer->fromdomain));
17236 } else if (!strcasecmp(v->name, "usereqphone")) {
17237 ast_set2_flag(&peer->flags[0], ast_true(v->value), SIP_USEREQPHONE);
17238 } else if (!strcasecmp(v->name, "fromuser")) {
17239 ast_copy_string(peer->fromuser, v->value, sizeof(peer->fromuser));
17240 } else if (!strcasecmp(v->name, "host") || !strcasecmp(v->name, "outboundproxy")) {
17241 if (!strcasecmp(v->value, "dynamic")) {
17242 if (!strcasecmp(v->name, "outboundproxy") || obproxyfound) {
17243 ast_log(LOG_WARNING, "You can't have a dynamic outbound proxy, you big silly head at line %d.\n", v->lineno);
17244 } else {
17245
17246 if (!found || !ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC)) {
17247
17248
17249 memset(&peer->addr.sin_addr, 0, 4);
17250 if (peer->addr.sin_port) {
17251
17252 peer->defaddr.sin_port = peer->addr.sin_port;
17253 peer->addr.sin_port = 0;
17254 }
17255 }
17256 ast_set_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC);
17257 }
17258 } else {
17259
17260 if (!AST_SCHED_DEL(sched, peer->expire)) {
17261 struct sip_peer *peer_ptr = peer;
17262 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
17263 }
17264 ast_clear_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC);
17265 if (!obproxyfound || !strcasecmp(v->name, "outboundproxy")) {
17266 if (ast_get_ip_or_srv(&peer->addr, v->value, srvlookup ? "_sip._udp" : NULL)) {
17267 ASTOBJ_UNREF(peer, sip_destroy_peer);
17268 return NULL;
17269 }
17270 }
17271 if (!strcasecmp(v->name, "outboundproxy"))
17272 obproxyfound=1;
17273 else {
17274 ast_copy_string(peer->tohost, v->value, sizeof(peer->tohost));
17275 if (!peer->addr.sin_port)
17276 peer->addr.sin_port = htons(STANDARD_SIP_PORT);
17277 }
17278 }
17279 } else if (!strcasecmp(v->name, "defaultip")) {
17280 if (ast_get_ip(&peer->defaddr, v->value)) {
17281 ASTOBJ_UNREF(peer, sip_destroy_peer);
17282 return NULL;
17283 }
17284 } else if (!strcasecmp(v->name, "permit") || !strcasecmp(v->name, "deny")) {
17285 peer->ha = ast_append_ha(v->name, v->value, peer->ha);
17286 } else if (!strcasecmp(v->name, "port")) {
17287 if (!realtime && ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC))
17288 peer->defaddr.sin_port = htons(atoi(v->value));
17289 else
17290 peer->addr.sin_port = htons(atoi(v->value));
17291 } else if (!strcasecmp(v->name, "callingpres")) {
17292 peer->callingpres = ast_parse_caller_presentation(v->value);
17293 if (peer->callingpres == -1)
17294 peer->callingpres = atoi(v->value);
17295 } else if (!strcasecmp(v->name, "username")) {
17296 ast_copy_string(peer->username, v->value, sizeof(peer->username));
17297 } else if (!strcasecmp(v->name, "language")) {
17298 ast_copy_string(peer->language, v->value, sizeof(peer->language));
17299 } else if (!strcasecmp(v->name, "regexten")) {
17300 ast_copy_string(peer->regexten, v->value, sizeof(peer->regexten));
17301 } else if (!strcasecmp(v->name, "call-limit") || !strcasecmp(v->name, "incominglimit")) {
17302 peer->call_limit = atoi(v->value);
17303 if (peer->call_limit < 0)
17304 peer->call_limit = 0;
17305 } else if (!strcasecmp(v->name, "amaflags")) {
17306 format = ast_cdr_amaflags2int(v->value);
17307 if (format < 0) {
17308 ast_log(LOG_WARNING, "Invalid AMA Flags for peer: %s at line %d\n", v->value, v->lineno);
17309 } else {
17310 peer->amaflags = format;
17311 }
17312 } else if (!strcasecmp(v->name, "accountcode")) {
17313 ast_copy_string(peer->accountcode, v->value, sizeof(peer->accountcode));
17314 } else if (!strcasecmp(v->name, "mohinterpret")
17315 || !strcasecmp(v->name, "musicclass") || !strcasecmp(v->name, "musiconhold")) {
17316 ast_copy_string(peer->mohinterpret, v->value, sizeof(peer->mohinterpret));
17317 } else if (!strcasecmp(v->name, "mohsuggest")) {
17318 ast_copy_string(peer->mohsuggest, v->value, sizeof(peer->mohsuggest));
17319 } else if (!strcasecmp(v->name, "mailbox")) {
17320 ast_copy_string(peer->mailbox, v->value, sizeof(peer->mailbox));
17321 } else if (!strcasecmp(v->name, "hasvoicemail")) {
17322
17323
17324 if (ast_true(v->value) && ast_strlen_zero(peer->mailbox)) {
17325 ast_copy_string(peer->mailbox, name, sizeof(peer->mailbox));
17326 }
17327 } else if (!strcasecmp(v->name, "subscribemwi")) {
17328 ast_set2_flag(&peer->flags[1], ast_true(v->value), SIP_PAGE2_SUBSCRIBEMWIONLY);
17329 } else if (!strcasecmp(v->name, "vmexten")) {
17330 ast_copy_string(peer->vmexten, v->value, sizeof(peer->vmexten));
17331 } else if (!strcasecmp(v->name, "callgroup")) {
17332 peer->callgroup = ast_get_group(v->value);
17333 } else if (!strcasecmp(v->name, "allowtransfer")) {
17334 peer->allowtransfer = ast_true(v->value) ? TRANSFER_OPENFORALL : TRANSFER_CLOSED;
17335 } else if (!strcasecmp(v->name, "pickupgroup")) {
17336 peer->pickupgroup = ast_get_group(v->value);
17337 } else if (!strcasecmp(v->name, "allow")) {
17338 ast_parse_allow_disallow(&peer->prefs, &peer->capability, v->value, 1);
17339 } else if (!strcasecmp(v->name, "disallow")) {
17340 ast_parse_allow_disallow(&peer->prefs, &peer->capability, v->value, 0);
17341 } else if (!strcasecmp(v->name, "autoframing")) {
17342 peer->autoframing = ast_true(v->value);
17343 } else if (!strcasecmp(v->name, "rtptimeout")) {
17344 if ((sscanf(v->value, "%d", &peer->rtptimeout) != 1) || (peer->rtptimeout < 0)) {
17345 ast_log(LOG_WARNING, "'%s' is not a valid RTP hold time at line %d. Using default.\n", v->value, v->lineno);
17346 peer->rtptimeout = global_rtptimeout;
17347 }
17348 } else if (!strcasecmp(v->name, "rtpholdtimeout")) {
17349 if ((sscanf(v->value, "%d", &peer->rtpholdtimeout) != 1) || (peer->rtpholdtimeout < 0)) {
17350 ast_log(LOG_WARNING, "'%s' is not a valid RTP hold time at line %d. Using default.\n", v->value, v->lineno);
17351 peer->rtpholdtimeout = global_rtpholdtimeout;
17352 }
17353 } else if (!strcasecmp(v->name, "rtpkeepalive")) {
17354 if ((sscanf(v->value, "%d", &peer->rtpkeepalive) != 1) || (peer->rtpkeepalive < 0)) {
17355 ast_log(LOG_WARNING, "'%s' is not a valid RTP keepalive time at line %d. Using default.\n", v->value, v->lineno);
17356 peer->rtpkeepalive = global_rtpkeepalive;
17357 }
17358 } else if (!strcasecmp(v->name, "setvar")) {
17359
17360 varname = ast_strdupa(v->value);
17361 if ((varval = strchr(varname, '='))) {
17362 *varval++ = '\0';
17363 if ((tmpvar = ast_variable_new(varname, varval))) {
17364 tmpvar->next = peer->chanvars;
17365 peer->chanvars = tmpvar;
17366 }
17367 }
17368 } else if (!strcasecmp(v->name, "qualify")) {
17369 if (!strcasecmp(v->value, "no")) {
17370 peer->maxms = 0;
17371 } else if (!strcasecmp(v->value, "yes")) {
17372 peer->maxms = default_qualify ? default_qualify : DEFAULT_MAXMS;
17373 } else if (sscanf(v->value, "%d", &peer->maxms) != 1) {
17374 ast_log(LOG_WARNING, "Qualification of peer '%s' should be 'yes', 'no', or a number of milliseconds at line %d of sip.conf\n", peer->name, v->lineno);
17375 peer->maxms = 0;
17376 }
17377 } else if (!strcasecmp(v->name, "maxcallbitrate")) {
17378 peer->maxcallbitrate = atoi(v->value);
17379 if (peer->maxcallbitrate < 0)
17380 peer->maxcallbitrate = default_maxcallbitrate;
17381 }
17382 }
17383 if (!ast_strlen_zero(fullcontact)) {
17384 ast_copy_string(peer->fullcontact, fullcontact, sizeof(peer->fullcontact));
17385
17386
17387
17388
17389
17390 __set_address_from_contact(fullcontact, &peer->addr);
17391 }
17392
17393 if (!ast_test_flag(&global_flags[1], SIP_PAGE2_IGNOREREGEXPIRE) && ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC) && realtime) {
17394 time_t nowtime = time(NULL);
17395
17396 if ((nowtime - regseconds) > 0) {
17397 destroy_association(peer);
17398 memset(&peer->addr, 0, sizeof(peer->addr));
17399 if (option_debug)
17400 ast_log(LOG_DEBUG, "Bah, we're expired (%d/%d/%d)!\n", (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
17401 }
17402 }
17403 ast_copy_flags(&peer->flags[0], &peerflags[0], mask[0].flags);
17404 ast_copy_flags(&peer->flags[1], &peerflags[1], mask[1].flags);
17405 if (ast_test_flag(&peer->flags[1], SIP_PAGE2_ALLOWSUBSCRIBE))
17406 global_allowsubscribe = TRUE;
17407 if (!found && ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC) && !ast_test_flag(&peer->flags[0], SIP_REALTIME))
17408 reg_source_db(peer);
17409 ASTOBJ_UNMARK(peer);
17410 ast_free_ha(oldha);
17411 return peer;
17412 }
17413
17414
17415
17416
17417
17418
17419
17420 static int reload_config(enum channelreloadreason reason)
17421 {
17422 struct ast_config *cfg, *ucfg;
17423 struct ast_variable *v;
17424 struct sip_peer *peer;
17425 struct sip_user *user;
17426 struct ast_hostent ahp;
17427 char *cat, *stringp, *context, *oldregcontext;
17428 char newcontexts[AST_MAX_CONTEXT], oldcontexts[AST_MAX_CONTEXT];
17429 struct hostent *hp;
17430 int format;
17431 struct ast_flags dummy[2];
17432 int auto_sip_domains = FALSE;
17433 struct sockaddr_in old_bindaddr = bindaddr;
17434 int registry_count = 0, peer_count = 0, user_count = 0;
17435 unsigned int temp_tos = 0;
17436 struct ast_flags debugflag = {0};
17437
17438 cfg = ast_config_load(config);
17439
17440
17441 if (!cfg) {
17442 ast_log(LOG_NOTICE, "Unable to load config %s\n", config);
17443 return -1;
17444 }
17445
17446 if (option_debug > 3)
17447 ast_log(LOG_DEBUG, "--------------- SIP reload started\n");
17448
17449 clear_realm_authentication(authl);
17450 clear_sip_domains();
17451 authl = NULL;
17452
17453
17454
17455 ASTOBJ_CONTAINER_TRAVERSE(®l, 1, do {
17456 ASTOBJ_RDLOCK(iterator);
17457 if (iterator->call) {
17458 if (option_debug > 2)
17459 ast_log(LOG_DEBUG, "Destroying active SIP dialog for registry %s@%s\n", iterator->username, iterator->hostname);
17460
17461 sip_destroy(iterator->call);
17462 }
17463 ASTOBJ_UNLOCK(iterator);
17464
17465 } while(0));
17466
17467
17468 ASTOBJ_CONTAINER_DESTROYALL(&userl, sip_destroy_user);
17469 if (option_debug > 3)
17470 ast_log(LOG_DEBUG, "--------------- Done destroying user list\n");
17471 ASTOBJ_CONTAINER_DESTROYALL(®l, sip_registry_destroy);
17472 if (option_debug > 3)
17473 ast_log(LOG_DEBUG, "--------------- Done destroying registry list\n");
17474 ASTOBJ_CONTAINER_MARKALL(&peerl);
17475
17476
17477 ast_copy_string(oldcontexts, global_regcontext, sizeof(oldcontexts));
17478 oldregcontext = oldcontexts;
17479
17480
17481
17482 ast_copy_flags(&debugflag, &global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
17483 ast_clear_flag(&global_flags[0], AST_FLAGS_ALL);
17484 ast_clear_flag(&global_flags[1], AST_FLAGS_ALL);
17485 ast_copy_flags(&global_flags[1], &debugflag, SIP_PAGE2_DEBUG_CONSOLE);
17486
17487
17488 memset(&bindaddr, 0, sizeof(bindaddr));
17489 ast_free_ha(localaddr);
17490 memset(&localaddr, 0, sizeof(localaddr));
17491 memset(&externip, 0, sizeof(externip));
17492 memset(&default_prefs, 0 , sizeof(default_prefs));
17493 outboundproxyip.sin_port = htons(STANDARD_SIP_PORT);
17494 outboundproxyip.sin_family = AF_INET;
17495 ourport = STANDARD_SIP_PORT;
17496 srvlookup = DEFAULT_SRVLOOKUP;
17497 global_tos_sip = DEFAULT_TOS_SIP;
17498 global_tos_audio = DEFAULT_TOS_AUDIO;
17499 global_tos_video = DEFAULT_TOS_VIDEO;
17500 externhost[0] = '\0';
17501 externexpire = 0;
17502 externrefresh = 10;
17503 memset(&outboundproxyip, 0, sizeof(outboundproxyip));
17504
17505
17506 allow_external_domains = DEFAULT_ALLOW_EXT_DOM;
17507 global_regcontext[0] = '\0';
17508 expiry = DEFAULT_EXPIRY;
17509 global_notifyringing = DEFAULT_NOTIFYRINGING;
17510 global_limitonpeers = FALSE;
17511 global_directrtpsetup = FALSE;
17512 global_notifyhold = FALSE;
17513 global_alwaysauthreject = 0;
17514 global_allowsubscribe = FALSE;
17515 ast_copy_string(global_useragent, DEFAULT_USERAGENT, sizeof(global_useragent));
17516 ast_copy_string(default_notifymime, DEFAULT_NOTIFYMIME, sizeof(default_notifymime));
17517 if (ast_strlen_zero(ast_config_AST_SYSTEM_NAME))
17518 ast_copy_string(global_realm, DEFAULT_REALM, sizeof(global_realm));
17519 else
17520 ast_copy_string(global_realm, ast_config_AST_SYSTEM_NAME, sizeof(global_realm));
17521 ast_copy_string(default_callerid, DEFAULT_CALLERID, sizeof(default_callerid));
17522 compactheaders = DEFAULT_COMPACTHEADERS;
17523 global_reg_timeout = DEFAULT_REGISTRATION_TIMEOUT;
17524 global_regattempts_max = 0;
17525 pedanticsipchecking = DEFAULT_PEDANTIC;
17526 global_mwitime = DEFAULT_MWITIME;
17527 autocreatepeer = DEFAULT_AUTOCREATEPEER;
17528 global_autoframing = 0;
17529 global_allowguest = DEFAULT_ALLOWGUEST;
17530 global_rtptimeout = 0;
17531 global_rtpholdtimeout = 0;
17532 global_rtpkeepalive = 0;
17533 global_allowtransfer = TRANSFER_OPENFORALL;
17534 global_rtautoclear = 120;
17535 ast_set_flag(&global_flags[1], SIP_PAGE2_ALLOWSUBSCRIBE);
17536 ast_set_flag(&global_flags[1], SIP_PAGE2_ALLOWOVERLAP);
17537 ast_set_flag(&global_flags[1], SIP_PAGE2_RTUPDATE);
17538
17539
17540 ast_copy_string(default_context, DEFAULT_CONTEXT, sizeof(default_context));
17541 default_subscribecontext[0] = '\0';
17542 default_language[0] = '\0';
17543 default_fromdomain[0] = '\0';
17544 default_qualify = DEFAULT_QUALIFY;
17545 default_maxcallbitrate = DEFAULT_MAX_CALL_BITRATE;
17546 ast_copy_string(default_mohinterpret, DEFAULT_MOHINTERPRET, sizeof(default_mohinterpret));
17547 ast_copy_string(default_mohsuggest, DEFAULT_MOHSUGGEST, sizeof(default_mohsuggest));
17548 ast_copy_string(default_vmexten, DEFAULT_VMEXTEN, sizeof(default_vmexten));
17549 ast_set_flag(&global_flags[0], SIP_DTMF_RFC2833);
17550 ast_set_flag(&global_flags[0], SIP_NAT_RFC3581);
17551 ast_set_flag(&global_flags[0], SIP_CAN_REINVITE);
17552
17553
17554 dumphistory = FALSE;
17555 recordhistory = FALSE;
17556 ast_clear_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONFIG);
17557
17558
17559 global_relaxdtmf = FALSE;
17560 global_callevents = FALSE;
17561 global_t1min = DEFAULT_T1MIN;
17562
17563 global_matchexterniplocally = FALSE;
17564
17565
17566 memcpy(&global_jbconf, &default_jbconf, sizeof(struct ast_jb_conf));
17567
17568 ast_clear_flag(&global_flags[1], SIP_PAGE2_VIDEOSUPPORT);
17569
17570
17571 for (v = ast_variable_browse(cfg, "general"); v; v = v->next) {
17572 if (handle_common_options(&global_flags[0], &dummy[0], v))
17573 continue;
17574
17575 if (!ast_jb_read_conf(&global_jbconf, v->name, v->value))
17576 continue;
17577
17578
17579 if (!strcasecmp(v->name, "context")) {
17580 ast_copy_string(default_context, v->value, sizeof(default_context));
17581 } else if (!strcasecmp(v->name, "subscribecontext")) {
17582 ast_copy_string(default_subscribecontext, v->value, sizeof(default_subscribecontext));
17583 } else if (!strcasecmp(v->name, "allowguest")) {
17584 global_allowguest = ast_true(v->value) ? 1 : 0;
17585 } else if (!strcasecmp(v->name, "realm")) {
17586 ast_copy_string(global_realm, v->value, sizeof(global_realm));
17587 } else if (!strcasecmp(v->name, "useragent")) {
17588 ast_copy_string(global_useragent, v->value, sizeof(global_useragent));
17589 if (option_debug)
17590 ast_log(LOG_DEBUG, "Setting SIP channel User-Agent Name to %s\n", global_useragent);
17591 } else if (!strcasecmp(v->name, "allowtransfer")) {
17592 global_allowtransfer = ast_true(v->value) ? TRANSFER_OPENFORALL : TRANSFER_CLOSED;
17593 } else if (!strcasecmp(v->name, "rtcachefriends")) {
17594 ast_set2_flag(&global_flags[1], ast_true(v->value), SIP_PAGE2_RTCACHEFRIENDS);
17595 } else if (!strcasecmp(v->name, "rtsavesysname")) {
17596 ast_set2_flag(&global_flags[1], ast_true(v->value), SIP_PAGE2_RTSAVE_SYSNAME);
17597 } else if (!strcasecmp(v->name, "rtupdate")) {
17598 ast_set2_flag(&global_flags[1], ast_true(v->value), SIP_PAGE2_RTUPDATE);
17599 } else if (!strcasecmp(v->name, "ignoreregexpire")) {
17600 ast_set2_flag(&global_flags[1], ast_true(v->value), SIP_PAGE2_IGNOREREGEXPIRE);
17601 } else if (!strcasecmp(v->name, "t1min")) {
17602 global_t1min = atoi(v->value);
17603 } else if (!strcasecmp(v->name, "rtautoclear")) {
17604 int i = atoi(v->value);
17605 if (i > 0)
17606 global_rtautoclear = i;
17607 else
17608 i = 0;
17609 ast_set2_flag(&global_flags[1], i || ast_true(v->value), SIP_PAGE2_RTAUTOCLEAR);
17610 } else if (!strcasecmp(v->name, "usereqphone")) {
17611 ast_set2_flag(&global_flags[0], ast_true(v->value), SIP_USEREQPHONE);
17612 } else if (!strcasecmp(v->name, "relaxdtmf")) {
17613 global_relaxdtmf = ast_true(v->value);
17614 } else if (!strcasecmp(v->name, "checkmwi")) {
17615 if ((sscanf(v->value, "%d", &global_mwitime) != 1) || (global_mwitime < 0)) {
17616 ast_log(LOG_WARNING, "'%s' is not a valid MWI time setting at line %d. Using default (10).\n", v->value, v->lineno);
17617 global_mwitime = DEFAULT_MWITIME;
17618 }
17619 } else if (!strcasecmp(v->name, "vmexten")) {
17620 ast_copy_string(default_vmexten, v->value, sizeof(default_vmexten));
17621 } else if (!strcasecmp(v->name, "rtptimeout")) {
17622 if ((sscanf(v->value, "%d", &global_rtptimeout) != 1) || (global_rtptimeout < 0)) {
17623 ast_log(LOG_WARNING, "'%s' is not a valid RTP hold time at line %d. Using default.\n", v->value, v->lineno);
17624 global_rtptimeout = 0;
17625 }
17626 } else if (!strcasecmp(v->name, "rtpholdtimeout")) {
17627 if ((sscanf(v->value, "%d", &global_rtpholdtimeout) != 1) || (global_rtpholdtimeout < 0)) {
17628 ast_log(LOG_WARNING, "'%s' is not a valid RTP hold time at line %d. Using default.\n", v->value, v->lineno);
17629 global_rtpholdtimeout = 0;
17630 }
17631 } else if (!strcasecmp(v->name, "rtpkeepalive")) {
17632 if ((sscanf(v->value, "%d", &global_rtpkeepalive) != 1) || (global_rtpkeepalive < 0)) {
17633 ast_log(LOG_WARNING, "'%s' is not a valid RTP keepalive time at line %d. Using default.\n", v->value, v->lineno);
17634 global_rtpkeepalive = 0;
17635 }
17636 } else if (!strcasecmp(v->name, "compactheaders")) {
17637 compactheaders = ast_true(v->value);
17638 } else if (!strcasecmp(v->name, "notifymimetype")) {
17639 ast_copy_string(default_notifymime, v->value, sizeof(default_notifymime));
17640 } else if (!strncasecmp(v->name, "limitonpeer", 11)) {
17641 global_limitonpeers = ast_true(v->value);
17642 } else if (!strcasecmp(v->name, "directrtpsetup")) {
17643 global_directrtpsetup = ast_true(v->value);
17644 } else if (!strcasecmp(v->name, "notifyringing")) {
17645 global_notifyringing = ast_true(v->value);
17646 } else if (!strcasecmp(v->name, "notifyhold")) {
17647 global_notifyhold = ast_true(v->value);
17648 } else if (!strcasecmp(v->name, "alwaysauthreject")) {
17649 global_alwaysauthreject = ast_true(v->value);
17650 } else if (!strcasecmp(v->name, "mohinterpret")
17651 || !strcasecmp(v->name, "musicclass") || !strcasecmp(v->name, "musiconhold")) {
17652 ast_copy_string(default_mohinterpret, v->value, sizeof(default_mohinterpret));
17653 } else if (!strcasecmp(v->name, "mohsuggest")) {
17654 ast_copy_string(default_mohsuggest, v->value, sizeof(default_mohsuggest));
17655 } else if (!strcasecmp(v->name, "language")) {
17656 ast_copy_string(default_language, v->value, sizeof(default_language));
17657 } else if (!strcasecmp(v->name, "regcontext")) {
17658 ast_copy_string(newcontexts, v->value, sizeof(newcontexts));
17659 stringp = newcontexts;
17660
17661 cleanup_stale_contexts(stringp, oldregcontext);
17662
17663 while ((context = strsep(&stringp, "&"))) {
17664 if (!ast_context_find(context))
17665 ast_context_create(NULL, context,"SIP");
17666 }
17667 ast_copy_string(global_regcontext, v->value, sizeof(global_regcontext));
17668 } else if (!strcasecmp(v->name, "callerid")) {
17669 ast_copy_string(default_callerid, v->value, sizeof(default_callerid));
17670 } else if (!strcasecmp(v->name, "fromdomain")) {
17671 ast_copy_string(default_fromdomain, v->value, sizeof(default_fromdomain));
17672 } else if (!strcasecmp(v->name, "outboundproxy")) {
17673 if (ast_get_ip_or_srv(&outboundproxyip, v->value, srvlookup ? "_sip._udp" : NULL) < 0)
17674 ast_log(LOG_WARNING, "Unable to locate host '%s'\n", v->value);
17675 } else if (!strcasecmp(v->name, "outboundproxyport")) {
17676
17677 sscanf(v->value, "%d", &format);
17678 outboundproxyip.sin_port = htons(format);
17679 } else if (!strcasecmp(v->name, "autocreatepeer")) {
17680 autocreatepeer = ast_true(v->value);
17681 } else if (!strcasecmp(v->name, "srvlookup")) {
17682 srvlookup = ast_true(v->value);
17683 } else if (!strcasecmp(v->name, "pedantic")) {
17684 pedanticsipchecking = ast_true(v->value);
17685 } else if (!strcasecmp(v->name, "maxexpirey") || !strcasecmp(v->name, "maxexpiry")) {
17686 max_expiry = atoi(v->value);
17687 if (max_expiry < 1)
17688 max_expiry = DEFAULT_MAX_EXPIRY;
17689 } else if (!strcasecmp(v->name, "minexpirey") || !strcasecmp(v->name, "minexpiry")) {
17690 min_expiry = atoi(v->value);
17691 if (min_expiry < 1)
17692 min_expiry = DEFAULT_MIN_EXPIRY;
17693 } else if (!strcasecmp(v->name, "defaultexpiry") || !strcasecmp(v->name, "defaultexpirey")) {
17694 default_expiry = atoi(v->value);
17695 if (default_expiry < 1)
17696 default_expiry = DEFAULT_DEFAULT_EXPIRY;
17697 } else if (!strcasecmp(v->name, "sipdebug")) {
17698 if (ast_true(v->value))
17699 ast_set_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONFIG);
17700 } else if (!strcasecmp(v->name, "dumphistory")) {
17701 dumphistory = ast_true(v->value);
17702 } else if (!strcasecmp(v->name, "recordhistory")) {
17703 recordhistory = ast_true(v->value);
17704 } else if (!strcasecmp(v->name, "registertimeout")) {
17705 global_reg_timeout = atoi(v->value);
17706 if (global_reg_timeout < 1)
17707 global_reg_timeout = DEFAULT_REGISTRATION_TIMEOUT;
17708 } else if (!strcasecmp(v->name, "registerattempts")) {
17709 global_regattempts_max = atoi(v->value);
17710 } else if (!strcasecmp(v->name, "bindaddr")) {
17711 if (!(hp = ast_gethostbyname(v->value, &ahp))) {
17712 ast_log(LOG_WARNING, "Invalid address: %s\n", v->value);
17713 } else {
17714 memcpy(&bindaddr.sin_addr, hp->h_addr, sizeof(bindaddr.sin_addr));
17715 }
17716 } else if (!strcasecmp(v->name, "localnet")) {
17717 struct ast_ha *na;
17718 if (!(na = ast_append_ha("d", v->value, localaddr)))
17719 ast_log(LOG_WARNING, "Invalid localnet value: %s\n", v->value);
17720 else
17721 localaddr = na;
17722 } else if (!strcasecmp(v->name, "localmask")) {
17723 ast_log(LOG_WARNING, "Use of localmask is no long supported -- use localnet with mask syntax\n");
17724 } else if (!strcasecmp(v->name, "externip")) {
17725 if (!(hp = ast_gethostbyname(v->value, &ahp)))
17726 ast_log(LOG_WARNING, "Invalid address for externip keyword: %s\n", v->value);
17727 else
17728 memcpy(&externip.sin_addr, hp->h_addr, sizeof(externip.sin_addr));
17729 externexpire = 0;
17730 } else if (!strcasecmp(v->name, "externhost")) {
17731 ast_copy_string(externhost, v->value, sizeof(externhost));
17732 if (!(hp = ast_gethostbyname(externhost, &ahp)))
17733 ast_log(LOG_WARNING, "Invalid address for externhost keyword: %s\n", externhost);
17734 else
17735 memcpy(&externip.sin_addr, hp->h_addr, sizeof(externip.sin_addr));
17736 externexpire = time(NULL);
17737 } else if (!strcasecmp(v->name, "externrefresh")) {
17738 if (sscanf(v->value, "%d", &externrefresh) != 1) {
17739 ast_log(LOG_WARNING, "Invalid externrefresh value '%s', must be an integer >0 at line %d\n", v->value, v->lineno);
17740 externrefresh = 10;
17741 }
17742 } else if (!strcasecmp(v->name, "allow")) {
17743 ast_parse_allow_disallow(&default_prefs, &global_capability, v->value, 1);
17744 } else if (!strcasecmp(v->name, "disallow")) {
17745 ast_parse_allow_disallow(&default_prefs, &global_capability, v->value, 0);
17746 } else if (!strcasecmp(v->name, "autoframing")) {
17747 global_autoframing = ast_true(v->value);
17748 } else if (!strcasecmp(v->name, "allowexternaldomains")) {
17749 allow_external_domains = ast_true(v->value);
17750 } else if (!strcasecmp(v->name, "autodomain")) {
17751 auto_sip_domains = ast_true(v->value);
17752 } else if (!strcasecmp(v->name, "domain")) {
17753 char *domain = ast_strdupa(v->value);
17754 char *context = strchr(domain, ',');
17755
17756 if (context)
17757 *context++ = '\0';
17758
17759 if (option_debug && ast_strlen_zero(context))
17760 ast_log(LOG_DEBUG, "No context specified at line %d for domain '%s'\n", v->lineno, domain);
17761 if (ast_strlen_zero(domain))
17762 ast_log(LOG_WARNING, "Empty domain specified at line %d\n", v->lineno);
17763 else
17764 add_sip_domain(ast_strip(domain), SIP_DOMAIN_CONFIG, context ? ast_strip(context) : "");
17765 } else if (!strcasecmp(v->name, "register")) {
17766 if (sip_register(v->value, v->lineno) == 0)
17767 registry_count++;
17768 } else if (!strcasecmp(v->name, "tos")) {
17769 if (!ast_str2tos(v->value, &temp_tos)) {
17770 global_tos_sip = temp_tos;
17771 global_tos_audio = temp_tos;
17772 global_tos_video = temp_tos;
17773 ast_log(LOG_WARNING, "tos value at line %d is deprecated. See doc/ip-tos.txt for more information.\n", v->lineno);
17774 } else
17775 ast_log(LOG_WARNING, "Invalid tos value at line %d, See doc/ip-tos.txt for more information.\n", v->lineno);
17776 } else if (!strcasecmp(v->name, "tos_sip")) {
17777 if (ast_str2tos(v->value, &global_tos_sip))
17778 ast_log(LOG_WARNING, "Invalid tos_sip value at line %d, recommended value is 'cs3'. See doc/ip-tos.txt.\n", v->lineno);
17779 } else if (!strcasecmp(v->name, "tos_audio")) {
17780 if (ast_str2tos(v->value, &global_tos_audio))
17781 ast_log(LOG_WARNING, "Invalid tos_audio value at line %d, recommended value is 'ef'. See doc/ip-tos.txt.\n", v->lineno);
17782 } else if (!strcasecmp(v->name, "tos_video")) {
17783 if (ast_str2tos(v->value, &global_tos_video))
17784 ast_log(LOG_WARNING, "Invalid tos_video value at line %d, recommended value is 'af41'. See doc/ip-tos.txt.\n", v->lineno);
17785 } else if (!strcasecmp(v->name, "bindport")) {
17786 if (sscanf(v->value, "%d", &ourport) == 1) {
17787 bindaddr.sin_port = htons(ourport);
17788 } else {
17789 ast_log(LOG_WARNING, "Invalid port number '%s' at line %d of %s\n", v->value, v->lineno, config);
17790 }
17791 } else if (!strcasecmp(v->name, "qualify")) {
17792 if (!strcasecmp(v->value, "no")) {
17793 default_qualify = 0;
17794 } else if (!strcasecmp(v->value, "yes")) {
17795 default_qualify = DEFAULT_MAXMS;
17796 } else if (sscanf(v->value, "%d", &default_qualify) != 1) {
17797 ast_log(LOG_WARNING, "Qualification default should be 'yes', 'no', or a number of milliseconds at line %d of sip.conf\n", v->lineno);
17798 default_qualify = 0;
17799 }
17800 } else if (!strcasecmp(v->name, "callevents")) {
17801 global_callevents = ast_true(v->value);
17802 } else if (!strcasecmp(v->name, "maxcallbitrate")) {
17803 default_maxcallbitrate = atoi(v->value);
17804 if (default_maxcallbitrate < 0)
17805 default_maxcallbitrate = DEFAULT_MAX_CALL_BITRATE;
17806 } else if (!strcasecmp(v->name, "matchexterniplocally")) {
17807 global_matchexterniplocally = ast_true(v->value);
17808 }
17809 }
17810
17811 if (!allow_external_domains && AST_LIST_EMPTY(&domain_list)) {
17812 ast_log(LOG_WARNING, "To disallow external domains, you need to configure local SIP domains.\n");
17813 allow_external_domains = 1;
17814 }
17815
17816
17817 for (v = ast_variable_browse(cfg, "authentication"); v ; v = v->next) {
17818
17819 if (!strcasecmp(v->name, "auth"))
17820 authl = add_realm_authentication(authl, v->value, v->lineno);
17821 }
17822
17823 ucfg = ast_config_load("users.conf");
17824 if (ucfg) {
17825 struct ast_variable *gen;
17826 int genhassip, genregistersip;
17827 const char *hassip, *registersip;
17828
17829 genhassip = ast_true(ast_variable_retrieve(ucfg, "general", "hassip"));
17830 genregistersip = ast_true(ast_variable_retrieve(ucfg, "general", "registersip"));
17831 gen = ast_variable_browse(ucfg, "general");
17832 cat = ast_category_browse(ucfg, NULL);
17833 while (cat) {
17834 if (strcasecmp(cat, "general")) {
17835 hassip = ast_variable_retrieve(ucfg, cat, "hassip");
17836 registersip = ast_variable_retrieve(ucfg, cat, "registersip");
17837 if (ast_true(hassip) || (!hassip && genhassip)) {
17838 user = build_user(cat, gen, ast_variable_browse(ucfg, cat), 0);
17839 if (user) {
17840 ASTOBJ_CONTAINER_LINK(&userl,user);
17841 ASTOBJ_UNREF(user, sip_destroy_user);
17842 user_count++;
17843 }
17844 peer = build_peer(cat, gen, ast_variable_browse(ucfg, cat), 0);
17845 if (peer) {
17846 ast_device_state_changed("SIP/%s", peer->name);
17847 ASTOBJ_CONTAINER_LINK(&peerl,peer);
17848 ASTOBJ_UNREF(peer, sip_destroy_peer);
17849 peer_count++;
17850 }
17851 }
17852 if (ast_true(registersip) || (!registersip && genregistersip)) {
17853 char tmp[256];
17854 const char *host = ast_variable_retrieve(ucfg, cat, "host");
17855 const char *username = ast_variable_retrieve(ucfg, cat, "username");
17856 const char *secret = ast_variable_retrieve(ucfg, cat, "secret");
17857 const char *contact = ast_variable_retrieve(ucfg, cat, "contact");
17858 if (!host)
17859 host = ast_variable_retrieve(ucfg, "general", "host");
17860 if (!username)
17861 username = ast_variable_retrieve(ucfg, "general", "username");
17862 if (!secret)
17863 secret = ast_variable_retrieve(ucfg, "general", "secret");
17864 if (!contact)
17865 contact = "s";
17866 if (!ast_strlen_zero(username) && !ast_strlen_zero(host)) {
17867 if (!ast_strlen_zero(secret))
17868 snprintf(tmp, sizeof(tmp), "%s:%s@%s/%s", username, secret, host, contact);
17869 else
17870 snprintf(tmp, sizeof(tmp), "%s@%s/%s", username, host, contact);
17871 if (sip_register(tmp, 0) == 0)
17872 registry_count++;
17873 }
17874 }
17875 }
17876 cat = ast_category_browse(ucfg, cat);
17877 }
17878 ast_config_destroy(ucfg);
17879 }
17880
17881
17882
17883 cat = NULL;
17884 while ( (cat = ast_category_browse(cfg, cat)) ) {
17885 const char *utype;
17886 if (!strcasecmp(cat, "general") || !strcasecmp(cat, "authentication"))
17887 continue;
17888 utype = ast_variable_retrieve(cfg, cat, "type");
17889 if (!utype) {
17890 ast_log(LOG_WARNING, "Section '%s' lacks type\n", cat);
17891 continue;
17892 } else {
17893 int is_user = 0, is_peer = 0;
17894 if (!strcasecmp(utype, "user"))
17895 is_user = 1;
17896 else if (!strcasecmp(utype, "friend"))
17897 is_user = is_peer = 1;
17898 else if (!strcasecmp(utype, "peer"))
17899 is_peer = 1;
17900 else {
17901 ast_log(LOG_WARNING, "Unknown type '%s' for '%s' in %s\n", utype, cat, "sip.conf");
17902 continue;
17903 }
17904 if (is_user) {
17905 user = build_user(cat, ast_variable_browse(cfg, cat), NULL, 0);
17906 if (user) {
17907 ASTOBJ_CONTAINER_LINK(&userl,user);
17908 ASTOBJ_UNREF(user, sip_destroy_user);
17909 user_count++;
17910 }
17911 }
17912 if (is_peer) {
17913 peer = build_peer(cat, ast_variable_browse(cfg, cat), NULL, 0);
17914 if (peer) {
17915 ASTOBJ_CONTAINER_LINK(&peerl,peer);
17916 ASTOBJ_UNREF(peer, sip_destroy_peer);
17917 peer_count++;
17918 }
17919 }
17920 }
17921 }
17922 if (ast_find_ourip(&__ourip, bindaddr)) {
17923 ast_log(LOG_WARNING, "Unable to get own IP address, SIP disabled\n");
17924 ast_config_destroy(cfg);
17925 return 0;
17926 }
17927 if (!ntohs(bindaddr.sin_port))
17928 bindaddr.sin_port = ntohs(STANDARD_SIP_PORT);
17929 bindaddr.sin_family = AF_INET;
17930 ast_mutex_lock(&netlock);
17931 if (memcmp(&old_bindaddr, &bindaddr, sizeof(struct sockaddr_in))) {
17932 if (sipsock > -1) {
17933 close(sipsock);
17934 sipsock = -1;
17935 }
17936 if (siptcpsock > -1) {
17937 close(siptcpsock);
17938 siptcpsock = -1;
17939 }
17940 }
17941 if (sipsock < 0) {
17942 sipsock = socket(AF_INET, SOCK_DGRAM, 0);
17943 if (sipsock < 0) {
17944 ast_log(LOG_WARNING, "Unable to create SIP socket: %s\n", strerror(errno));
17945 } else {
17946
17947 const int reuseFlag = 1;
17948
17949 setsockopt(sipsock, SOL_SOCKET, SO_REUSEADDR,
17950 (const char*)&reuseFlag,
17951 sizeof reuseFlag);
17952
17953 ast_enable_packet_fragmentation(sipsock);
17954
17955 if (bind(sipsock, (struct sockaddr *)&bindaddr, sizeof(bindaddr)) < 0) {
17956 ast_log(LOG_WARNING, "Failed to bind to UDP %s:%d: %s\n",
17957 ast_inet_ntoa(bindaddr.sin_addr), ntohs(bindaddr.sin_port),
17958 strerror(errno));
17959 close(sipsock);
17960 sipsock = -1;
17961 } else {
17962 if (option_verbose > 1) {
17963 ast_verbose(VERBOSE_PREFIX_2 "SIP Listening on UDP %s:%d\n",
17964 ast_inet_ntoa(bindaddr.sin_addr), ntohs(bindaddr.sin_port));
17965 ast_verbose(VERBOSE_PREFIX_2 "Using SIP UDP TOS: %s\n", ast_tos2str(global_tos_sip));
17966 }
17967 if (setsockopt(sipsock, IPPROTO_IP, IP_TOS, &global_tos_sip, sizeof(global_tos_sip)))
17968 ast_log(LOG_WARNING, "Unable to set SIP UDP TOS to %s\n", ast_tos2str(global_tos_sip));
17969 }
17970 }
17971 }
17972 if (siptcpsock < 0) {
17973 siptcpsock = socket(AF_INET, SOCK_STREAM, 0);
17974 if (siptcpsock < 0) {
17975 ast_log(LOG_WARNING, "Unable to create SIP TCP socket: %s\n", strerror(errno));
17976 } else {
17977
17978 const int reuseFlag = 1;
17979
17980 setsockopt(siptcpsock, SOL_SOCKET, SO_REUSEADDR,
17981 (const char*)&reuseFlag,
17982 sizeof reuseFlag);
17983
17984 ast_enable_packet_fragmentation(sipsock);
17985
17986 if (bind(siptcpsock, (struct sockaddr *)&bindaddr, sizeof(bindaddr)) < 0) {
17987 ast_log(LOG_WARNING, "Failed to bind to TCP %s:%d: %s\n",
17988 ast_inet_ntoa(bindaddr.sin_addr), ntohs(bindaddr.sin_port),
17989 strerror(errno));
17990 close(siptcpsock);
17991 siptcpsock = -1;
17992 } else {
17993 if (listen(siptcpsock, 30) < 0) {
17994 ast_log(LOG_WARNING, "Failed to listen on SIP TCP\n");
17995 } else {
17996 if (option_verbose > 1) {
17997 ast_verbose(VERBOSE_PREFIX_2 "SIP Listening on TCP %s:%d\n",
17998 ast_inet_ntoa(bindaddr.sin_addr), ntohs(bindaddr.sin_port));
17999 ast_verbose(VERBOSE_PREFIX_2 "Using SIP TCP TOS: %s\n", ast_tos2str(global_tos_sip));
18000 }
18001 if (setsockopt(siptcpsock, IPPROTO_IP, IP_TOS, &global_tos_sip, sizeof(global_tos_sip)))
18002 ast_log(LOG_WARNING, "Unable to set SIP TCP TOS to %s\n", ast_tos2str(global_tos_sip));
18003 }
18004 }
18005 }
18006 }
18007 if ((sipsock < 0) && (siptcpsock <0)) {
18008 ast_config_destroy(cfg);
18009 return -1;
18010 }
18011 ast_mutex_unlock(&netlock);
18012
18013
18014
18015
18016
18017 if (auto_sip_domains) {
18018 char temp[MAXHOSTNAMELEN];
18019
18020
18021 if (bindaddr.sin_addr.s_addr)
18022 add_sip_domain(ast_inet_ntoa(bindaddr.sin_addr), SIP_DOMAIN_AUTO, NULL);
18023 else
18024 ast_log(LOG_NOTICE, "Can't add wildcard IP address to domain list, please add IP address to domain manually.\n");
18025
18026
18027 if (externip.sin_addr.s_addr)
18028 add_sip_domain(ast_inet_ntoa(externip.sin_addr), SIP_DOMAIN_AUTO, NULL);
18029
18030
18031 if (!ast_strlen_zero(externhost))
18032 add_sip_domain(externhost, SIP_DOMAIN_AUTO, NULL);
18033
18034
18035 if (!gethostname(temp, sizeof(temp)))
18036 add_sip_domain(temp, SIP_DOMAIN_AUTO, NULL);
18037 }
18038
18039
18040 ast_config_destroy(cfg);
18041
18042
18043 if (notify_types)
18044 ast_config_destroy(notify_types);
18045 notify_types = ast_config_load(notify_config);
18046
18047
18048 manager_event(EVENT_FLAG_SYSTEM, "ChannelReload", "Channel: SIP\r\nReloadReason: %s\r\nRegistry_Count: %d\r\nPeer_Count: %d\r\nUser_Count: %d\r\n", channelreloadreason2txt(reason), registry_count, peer_count, user_count);
18049
18050 return 0;
18051 }
18052
18053 static struct ast_udptl *sip_get_udptl_peer(struct ast_channel *chan)
18054 {
18055 struct sip_pvt *p;
18056 struct ast_udptl *udptl = NULL;
18057
18058 p = chan->tech_pvt;
18059 if (!p)
18060 return NULL;
18061
18062 ast_mutex_lock(&p->lock);
18063 if (p->udptl && ast_test_flag(&p->flags[0], SIP_CAN_REINVITE))
18064 udptl = p->udptl;
18065 ast_mutex_unlock(&p->lock);
18066 return udptl;
18067 }
18068
18069 static int sip_set_udptl_peer(struct ast_channel *chan, struct ast_udptl *udptl)
18070 {
18071 struct sip_pvt *p;
18072
18073 p = chan->tech_pvt;
18074 if (!p)
18075 return -1;
18076 ast_mutex_lock(&p->lock);
18077 if (udptl)
18078 ast_udptl_get_peer(udptl, &p->udptlredirip);
18079 else
18080 memset(&p->udptlredirip, 0, sizeof(p->udptlredirip));
18081 if (!ast_test_flag(&p->flags[0], SIP_GOTREFER)) {
18082 if (!p->pendinginvite) {
18083 if (option_debug > 2) {
18084 ast_log(LOG_DEBUG, "Sending reinvite on SIP '%s' - It's UDPTL soon redirected to IP %s:%d\n", p->callid, ast_inet_ntoa(udptl ? p->udptlredirip.sin_addr : p->ourip), udptl ? ntohs(p->udptlredirip.sin_port) : 0);
18085 }
18086 transmit_reinvite_with_t38_sdp(p);
18087 } else if (!ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
18088 if (option_debug > 2) {
18089 ast_log(LOG_DEBUG, "Deferring reinvite on SIP '%s' - It's UDPTL will be redirected to IP %s:%d\n", p->callid, ast_inet_ntoa(udptl ? p->udptlredirip.sin_addr : p->ourip), udptl ? ntohs(p->udptlredirip.sin_port) : 0);
18090 }
18091 ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
18092 }
18093 }
18094
18095 p->lastrtprx = p->lastrtptx = time(NULL);
18096 ast_mutex_unlock(&p->lock);
18097 return 0;
18098 }
18099
18100
18101
18102
18103
18104
18105 static int sip_handle_t38_reinvite(struct ast_channel *chan, struct sip_pvt *pvt, int reinvite)
18106 {
18107 struct sip_pvt *p;
18108 int flag = 0;
18109
18110 p = chan->tech_pvt;
18111 if (!p || !pvt->udptl)
18112 return -1;
18113
18114
18115 ast_mutex_lock(&p->lock);
18116
18117
18118
18119 p->t38.jointcapability = p->t38.peercapability = pvt->t38.jointcapability;
18120
18121 ast_udptl_set_far_max_datagram(p->udptl, ast_udptl_get_local_max_datagram(pvt->udptl));
18122 ast_udptl_set_local_max_datagram(p->udptl, ast_udptl_get_local_max_datagram(pvt->udptl));
18123 ast_udptl_set_error_correction_scheme(p->udptl, ast_udptl_get_error_correction_scheme(pvt->udptl));
18124
18125 if (reinvite) {
18126
18127
18128
18129
18130
18131 if (ast_test_flag(&p->flags[0], SIP_CAN_REINVITE) && ast_test_flag(&pvt->flags[0], SIP_CAN_REINVITE)) {
18132 ast_udptl_get_peer(pvt->udptl, &p->udptlredirip);
18133 flag =1;
18134 } else {
18135 memset(&p->udptlredirip, 0, sizeof(p->udptlredirip));
18136 }
18137 if (!ast_test_flag(&p->flags[0], SIP_GOTREFER)) {
18138 if (!p->pendinginvite) {
18139 if (option_debug > 2) {
18140 if (flag)
18141 ast_log(LOG_DEBUG, "Sending reinvite on SIP '%s' - It's UDPTL soon redirected to IP %s:%d\n", p->callid, ast_inet_ntoa(p->udptlredirip.sin_addr), ntohs(p->udptlredirip.sin_port));
18142 else
18143 ast_log(LOG_DEBUG, "Sending reinvite on SIP '%s' - It's UDPTL soon redirected to us (IP %s)\n", p->callid, ast_inet_ntoa(p->ourip));
18144 }
18145 transmit_reinvite_with_t38_sdp(p);
18146 } else if (!ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
18147 if (option_debug > 2) {
18148 if (flag)
18149 ast_log(LOG_DEBUG, "Deferring reinvite on SIP '%s' - It's UDPTL will be redirected to IP %s:%d\n", p->callid, ast_inet_ntoa(p->udptlredirip.sin_addr), ntohs(p->udptlredirip.sin_port));
18150 else
18151 ast_log(LOG_DEBUG, "Deferring reinvite on SIP '%s' - It's UDPTL will be redirected to us (IP %s)\n", p->callid, ast_inet_ntoa(p->ourip));
18152 }
18153 ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
18154 }
18155 }
18156
18157 p->lastrtprx = p->lastrtptx = time(NULL);
18158 ast_mutex_unlock(&p->lock);
18159 return 0;
18160 } else {
18161 if (ast_test_flag(&p->flags[0], SIP_CAN_REINVITE) && ast_test_flag(&pvt->flags[0], SIP_CAN_REINVITE)) {
18162 ast_udptl_get_peer(pvt->udptl, &p->udptlredirip);
18163 flag = 1;
18164 } else {
18165 memset(&p->udptlredirip, 0, sizeof(p->udptlredirip));
18166 }
18167 if (option_debug > 2) {
18168 if (flag)
18169 ast_log(LOG_DEBUG, "Responding 200 OK on SIP '%s' - It's UDPTL soon redirected to IP %s:%d\n", p->callid, ast_inet_ntoa(p->udptlredirip.sin_addr), ntohs(p->udptlredirip.sin_port));
18170 else
18171 ast_log(LOG_DEBUG, "Responding 200 OK on SIP '%s' - It's UDPTL soon redirected to us (IP %s)\n", p->callid, ast_inet_ntoa(p->ourip));
18172 }
18173 pvt->t38.state = T38_ENABLED;
18174 p->t38.state = T38_ENABLED;
18175 if (option_debug > 1) {
18176 ast_log(LOG_DEBUG, "T38 changed state to %d on channel %s\n", pvt->t38.state, pvt->owner ? pvt->owner->name : "<none>");
18177 ast_log(LOG_DEBUG, "T38 changed state to %d on channel %s\n", p->t38.state, chan ? chan->name : "<none>");
18178 }
18179 transmit_response_with_t38_sdp(p, "200 OK", &p->initreq, XMIT_CRITICAL);
18180 p->lastrtprx = p->lastrtptx = time(NULL);
18181 ast_mutex_unlock(&p->lock);
18182 return 0;
18183 }
18184 }
18185
18186
18187
18188 static enum ast_rtp_get_result sip_get_rtp_peer(struct ast_channel *chan, struct ast_rtp **rtp)
18189 {
18190 struct sip_pvt *p = NULL;
18191 enum ast_rtp_get_result res = AST_RTP_TRY_PARTIAL;
18192
18193 if (!(p = chan->tech_pvt))
18194 return AST_RTP_GET_FAILED;
18195
18196 ast_mutex_lock(&p->lock);
18197 if (!(p->rtp)) {
18198 ast_mutex_unlock(&p->lock);
18199 return AST_RTP_GET_FAILED;
18200 }
18201
18202 *rtp = p->rtp;
18203
18204 if (ast_rtp_getnat(*rtp) && !ast_test_flag(&p->flags[0], SIP_CAN_REINVITE_NAT))
18205 res = AST_RTP_TRY_PARTIAL;
18206 else if (ast_test_flag(&p->flags[0], SIP_CAN_REINVITE))
18207 res = AST_RTP_TRY_NATIVE;
18208 else if (ast_test_flag(&global_jbconf, AST_JB_FORCED))
18209 res = AST_RTP_GET_FAILED;
18210
18211 ast_mutex_unlock(&p->lock);
18212
18213 return res;
18214 }
18215
18216
18217 static enum ast_rtp_get_result sip_get_vrtp_peer(struct ast_channel *chan, struct ast_rtp **rtp)
18218 {
18219 struct sip_pvt *p = NULL;
18220 enum ast_rtp_get_result res = AST_RTP_TRY_PARTIAL;
18221
18222 if (!(p = chan->tech_pvt))
18223 return AST_RTP_GET_FAILED;
18224
18225 ast_mutex_lock(&p->lock);
18226 if (!(p->vrtp)) {
18227 ast_mutex_unlock(&p->lock);
18228 return AST_RTP_GET_FAILED;
18229 }
18230
18231 *rtp = p->vrtp;
18232
18233 if (ast_test_flag(&p->flags[0], SIP_CAN_REINVITE))
18234 res = AST_RTP_TRY_NATIVE;
18235
18236 ast_mutex_unlock(&p->lock);
18237
18238 return res;
18239 }
18240
18241
18242 static int sip_set_rtp_peer(struct ast_channel *chan, struct ast_rtp *rtp, struct ast_rtp *vrtp, int codecs, int nat_active)
18243 {
18244 struct sip_pvt *p;
18245 int changed = 0;
18246
18247 p = chan->tech_pvt;
18248 if (!p)
18249 return -1;
18250
18251
18252 if (chan->_state != AST_STATE_UP && !global_directrtpsetup)
18253 return 0;
18254
18255 ast_mutex_lock(&p->lock);
18256 if (ast_test_flag(&p->flags[0], SIP_ALREADYGONE)) {
18257
18258 ast_mutex_unlock(&p->lock);
18259 return 0;
18260 }
18261
18262
18263
18264
18265 if (nat_active && !ast_test_flag(&p->flags[0], SIP_CAN_REINVITE_NAT)) {
18266 ast_mutex_unlock(&p->lock);
18267 return 0;
18268 }
18269
18270 if (rtp) {
18271 changed |= ast_rtp_get_peer(rtp, &p->redirip);
18272 } else if (p->redirip.sin_addr.s_addr || ntohs(p->redirip.sin_port) != 0) {
18273 memset(&p->redirip, 0, sizeof(p->redirip));
18274 changed = 1;
18275 }
18276 if (vrtp) {
18277 changed |= ast_rtp_get_peer(vrtp, &p->vredirip);
18278 } else if (p->vredirip.sin_addr.s_addr || ntohs(p->vredirip.sin_port) != 0) {
18279 memset(&p->vredirip, 0, sizeof(p->vredirip));
18280 changed = 1;
18281 }
18282 if (codecs) {
18283 if ((p->redircodecs != codecs)) {
18284 p->redircodecs = codecs;
18285 changed = 1;
18286 }
18287 if ((p->capability & codecs) != p->capability) {
18288 p->jointcapability &= codecs;
18289 p->capability &= codecs;
18290 changed = 1;
18291 }
18292 }
18293 if (changed && !ast_test_flag(&p->flags[0], SIP_GOTREFER) && !ast_test_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER)) {
18294 if (chan->_state != AST_STATE_UP) {
18295 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
18296 append_history(p, "ExtInv", "Initial invite sent with remote bridge proposal.");
18297 if (option_debug)
18298 ast_log(LOG_DEBUG, "Early remote bridge setting SIP '%s' - Sending media to %s\n", p->callid, ast_inet_ntoa(rtp ? p->redirip.sin_addr : p->ourip));
18299 } else if (!p->pendinginvite) {
18300 if (option_debug > 2) {
18301 ast_log(LOG_DEBUG, "Sending reinvite on SIP '%s' - It's audio soon redirected to IP %s\n", p->callid, ast_inet_ntoa(rtp ? p->redirip.sin_addr : p->ourip));
18302 }
18303 transmit_reinvite_with_sdp(p);
18304 } else if (!ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
18305 if (option_debug > 2) {
18306 ast_log(LOG_DEBUG, "Deferring reinvite on SIP '%s' - It's audio will be redirected to IP %s\n", p->callid, ast_inet_ntoa(rtp ? p->redirip.sin_addr : p->ourip));
18307 }
18308
18309 ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
18310 }
18311 }
18312
18313 p->lastrtprx = p->lastrtptx = time(NULL);
18314 ast_mutex_unlock(&p->lock);
18315 return 0;
18316 }
18317
18318 static char *synopsis_dtmfmode = "Change the dtmfmode for a SIP call";
18319 static char *descrip_dtmfmode = "SIPDtmfMode(inband|info|rfc2833): Changes the dtmfmode for a SIP call\n";
18320 static char *app_dtmfmode = "SIPDtmfMode";
18321
18322 static char *app_sipaddheader = "SIPAddHeader";
18323 static char *synopsis_sipaddheader = "Add a SIP header to the outbound call";
18324
18325 static char *descrip_sipaddheader = ""
18326 " SIPAddHeader(Header: Content)\n"
18327 "Adds a header to a SIP call placed with DIAL.\n"
18328 "Remember to user the X-header if you are adding non-standard SIP\n"
18329 "headers, like \"X-Asterisk-Accountcode:\". Use this with care.\n"
18330 "Adding the wrong headers may jeopardize the SIP dialog.\n"
18331 "Always returns 0\n";
18332
18333
18334
18335 static int sip_dtmfmode(struct ast_channel *chan, void *data)
18336 {
18337 struct sip_pvt *p;
18338 char *mode;
18339 if (data)
18340 mode = (char *)data;
18341 else {
18342 ast_log(LOG_WARNING, "This application requires the argument: info, inband, rfc2833\n");
18343 return 0;
18344 }
18345 ast_channel_lock(chan);
18346 if (chan->tech != &sip_tech && chan->tech != &sip_tech_info) {
18347 ast_log(LOG_WARNING, "Call this application only on SIP incoming calls\n");
18348 ast_channel_unlock(chan);
18349 return 0;
18350 }
18351 p = chan->tech_pvt;
18352 if (!p) {
18353 ast_channel_unlock(chan);
18354 return 0;
18355 }
18356 ast_mutex_lock(&p->lock);
18357 if (!strcasecmp(mode,"info")) {
18358 ast_clear_flag(&p->flags[0], SIP_DTMF);
18359 ast_set_flag(&p->flags[0], SIP_DTMF_INFO);
18360 p->jointnoncodeccapability &= ~AST_RTP_DTMF;
18361 } else if (!strcasecmp(mode,"rfc2833")) {
18362 ast_clear_flag(&p->flags[0], SIP_DTMF);
18363 ast_set_flag(&p->flags[0], SIP_DTMF_RFC2833);
18364 p->jointnoncodeccapability |= AST_RTP_DTMF;
18365 } else if (!strcasecmp(mode,"inband")) {
18366 ast_clear_flag(&p->flags[0], SIP_DTMF);
18367 ast_set_flag(&p->flags[0], SIP_DTMF_INBAND);
18368 p->jointnoncodeccapability &= ~AST_RTP_DTMF;
18369 } else
18370 ast_log(LOG_WARNING, "I don't know about this dtmf mode: %s\n",mode);
18371 if (p->rtp)
18372 ast_rtp_setdtmf(p->rtp, ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833);
18373 if (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_INBAND) {
18374 if (!p->vad) {
18375 p->vad = ast_dsp_new();
18376 ast_dsp_set_features(p->vad, DSP_FEATURE_DTMF_DETECT);
18377 }
18378 } else {
18379 if (p->vad) {
18380 ast_dsp_free(p->vad);
18381 p->vad = NULL;
18382 }
18383 }
18384 ast_mutex_unlock(&p->lock);
18385 ast_channel_unlock(chan);
18386 return 0;
18387 }
18388
18389
18390 static int sip_addheader(struct ast_channel *chan, void *data)
18391 {
18392 int no = 0;
18393 int ok = FALSE;
18394 char varbuf[30];
18395 char *inbuf = (char *) data;
18396
18397 if (ast_strlen_zero(inbuf)) {
18398 ast_log(LOG_WARNING, "This application requires the argument: Header\n");
18399 return 0;
18400 }
18401 ast_channel_lock(chan);
18402
18403
18404 while (!ok && no <= 50) {
18405 no++;
18406 snprintf(varbuf, sizeof(varbuf), "__SIPADDHEADER%.2d", no);
18407
18408
18409 if( (pbx_builtin_getvar_helper(chan, (const char *) varbuf + 2) == (const char *) NULL) )
18410 ok = TRUE;
18411 }
18412 if (ok) {
18413 pbx_builtin_setvar_helper (chan, varbuf, inbuf);
18414 if (sipdebug)
18415 ast_log(LOG_DEBUG,"SIP Header added \"%s\" as %s\n", inbuf, varbuf);
18416 } else {
18417 ast_log(LOG_WARNING, "Too many SIP headers added, max 50\n");
18418 }
18419 ast_channel_unlock(chan);
18420 return 0;
18421 }
18422
18423
18424
18425
18426
18427
18428
18429 static int sip_sipredirect(struct sip_pvt *p, const char *dest)
18430 {
18431 char *cdest;
18432 char *extension, *host, *port;
18433 char tmp[80];
18434
18435 cdest = ast_strdupa(dest);
18436
18437 extension = strsep(&cdest, "@");
18438 host = strsep(&cdest, ":");
18439 port = strsep(&cdest, ":");
18440 if (ast_strlen_zero(extension)) {
18441 ast_log(LOG_ERROR, "Missing mandatory argument: extension\n");
18442 return 0;
18443 }
18444
18445
18446 if (!host) {
18447 char *localtmp;
18448 ast_copy_string(tmp, get_header(&p->initreq, "To"), sizeof(tmp));
18449 if (ast_strlen_zero(tmp)) {
18450 ast_log(LOG_ERROR, "Cannot retrieve the 'To' header from the original SIP request!\n");
18451 return 0;
18452 }
18453 if ((localtmp = strcasestr(tmp, "sip:")) && (localtmp = strchr(localtmp, '@'))) {
18454 char lhost[80], lport[80];
18455 memset(lhost, 0, sizeof(lhost));
18456 memset(lport, 0, sizeof(lport));
18457 localtmp++;
18458
18459 sscanf(localtmp, "%[^<>:; ]:%[^<>:; ]", lhost, lport);
18460 if (ast_strlen_zero(lhost)) {
18461 ast_log(LOG_ERROR, "Can't find the host address\n");
18462 return 0;
18463 }
18464 host = ast_strdupa(lhost);
18465 if (!ast_strlen_zero(lport)) {
18466 port = ast_strdupa(lport);
18467 }
18468 }
18469 }
18470
18471 ast_string_field_build(p, our_contact, "Transfer <sip:%s@%s%s%s>", extension, host, port ? ":" : "", port ? port : "");
18472 transmit_response_reliable(p, "302 Moved Temporarily", &p->initreq);
18473
18474 sip_scheddestroy(p, SIP_TRANS_TIMEOUT);
18475 sip_alreadygone(p);
18476 return 0;
18477 }
18478
18479
18480 static int sip_get_codec(struct ast_channel *chan)
18481 {
18482 struct sip_pvt *p = chan->tech_pvt;
18483 return p->peercapability ? p->peercapability : p->capability;
18484 }
18485
18486
18487
18488
18489
18490 static void sip_poke_all_peers(void)
18491 {
18492 int ms = 0;
18493
18494 if (!speerobjs)
18495 return;
18496
18497 ASTOBJ_CONTAINER_TRAVERSE(&peerl, 1, do {
18498 ASTOBJ_WRLOCK(iterator);
18499 if (!AST_SCHED_DEL(sched, iterator->pokeexpire)) {
18500 struct sip_peer *peer_ptr = iterator;
18501 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
18502 }
18503 ms += 100;
18504 iterator->pokeexpire = ast_sched_add(sched, ms, sip_poke_peer_s, ASTOBJ_REF(iterator));
18505 if (iterator->pokeexpire == -1) {
18506 struct sip_peer *peer_ptr = iterator;
18507 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
18508 }
18509 ASTOBJ_UNLOCK(iterator);
18510 } while (0)
18511 );
18512 }
18513
18514
18515 static void sip_send_all_registers(void)
18516 {
18517 int ms;
18518 int regspacing;
18519 if (!regobjs)
18520 return;
18521 regspacing = default_expiry * 1000/regobjs;
18522 if (regspacing > 100)
18523 regspacing = 100;
18524 ms = regspacing;
18525 ASTOBJ_CONTAINER_TRAVERSE(®l, 1, do {
18526 ASTOBJ_WRLOCK(iterator);
18527 AST_SCHED_DEL(sched, iterator->expire);
18528 ms += regspacing;
18529 iterator->expire = ast_sched_add(sched, ms, sip_reregister, iterator);
18530 ASTOBJ_UNLOCK(iterator);
18531 } while (0)
18532 );
18533 }
18534
18535
18536 static int sip_do_reload(enum channelreloadreason reason)
18537 {
18538 reload_config(reason);
18539
18540
18541 ASTOBJ_CONTAINER_PRUNE_MARKED(&peerl, sip_destroy_peer);
18542 if (option_debug > 3)
18543 ast_log(LOG_DEBUG, "--------------- Done destroying pruned peers\n");
18544
18545
18546 sip_poke_all_peers();
18547
18548
18549 sip_send_all_registers();
18550
18551 if (option_debug > 3)
18552 ast_log(LOG_DEBUG, "--------------- SIP reload done\n");
18553
18554 return 0;
18555 }
18556
18557
18558 static int sip_reload(int fd, int argc, char *argv[])
18559 {
18560 ast_mutex_lock(&sip_reload_lock);
18561 if (sip_reloading)
18562 ast_verbose("Previous SIP reload not yet done\n");
18563 else {
18564 sip_reloading = TRUE;
18565 if (fd)
18566 sip_reloadreason = CHANNEL_CLI_RELOAD;
18567 else
18568 sip_reloadreason = CHANNEL_MODULE_RELOAD;
18569 }
18570 ast_mutex_unlock(&sip_reload_lock);
18571 restart_monitor();
18572
18573 return 0;
18574 }
18575
18576
18577 static int reload(void)
18578 {
18579 return sip_reload(0, 0, NULL);
18580 }
18581
18582 static struct ast_cli_entry cli_sip_debug_deprecated =
18583 { { "sip", "debug", NULL },
18584 sip_do_debug_deprecated, "Enable SIP debugging",
18585 debug_usage };
18586
18587 static struct ast_cli_entry cli_sip_no_debug_deprecated =
18588 { { "sip", "no", "debug", NULL },
18589 sip_no_debug_deprecated, "Disable SIP debugging",
18590 debug_usage };
18591
18592 static struct ast_cli_entry cli_sip[] = {
18593 { { "sip", "show", "channels", NULL },
18594 sip_show_channels, "List active SIP channels",
18595 show_channels_usage },
18596
18597 { { "sip", "show", "domains", NULL },
18598 sip_show_domains, "List our local SIP domains.",
18599 show_domains_usage },
18600
18601 { { "sip", "show", "inuse", NULL },
18602 sip_show_inuse, "List all inuse/limits",
18603 show_inuse_usage },
18604
18605 { { "sip", "show", "objects", NULL },
18606 sip_show_objects, "List all SIP object allocations",
18607 show_objects_usage },
18608
18609 { { "sip", "show", "peers", NULL },
18610 sip_show_peers, "List defined SIP peers",
18611 show_peers_usage },
18612
18613 { { "sip", "show", "registry", NULL },
18614 sip_show_registry, "List SIP registration status",
18615 show_reg_usage },
18616
18617 { { "sip", "show", "settings", NULL },
18618 sip_show_settings, "Show SIP global settings",
18619 show_settings_usage },
18620
18621 { { "sip", "show", "subscriptions", NULL },
18622 sip_show_subscriptions, "List active SIP subscriptions",
18623 show_subscriptions_usage },
18624
18625 { { "sip", "show", "users", NULL },
18626 sip_show_users, "List defined SIP users",
18627 show_users_usage },
18628
18629 { { "sip", "notify", NULL },
18630 sip_notify, "Send a notify packet to a SIP peer",
18631 notify_usage, complete_sipnotify },
18632
18633 { { "sip", "show", "channel", NULL },
18634 sip_show_channel, "Show detailed SIP channel info",
18635 show_channel_usage, complete_sipch },
18636
18637 { { "sip", "show", "history", NULL },
18638 sip_show_history, "Show SIP dialog history",
18639 show_history_usage, complete_sipch },
18640
18641 { { "sip", "show", "peer", NULL },
18642 sip_show_peer, "Show details on specific SIP peer",
18643 show_peer_usage, complete_sip_show_peer },
18644
18645 { { "sip", "show", "user", NULL },
18646 sip_show_user, "Show details on specific SIP user",
18647 show_user_usage, complete_sip_show_user },
18648
18649 { { "sip", "prune", "realtime", NULL },
18650 sip_prune_realtime, "Prune cached Realtime object(s)",
18651 prune_realtime_usage },
18652
18653 { { "sip", "prune", "realtime", "peer", NULL },
18654 sip_prune_realtime, "Prune cached Realtime peer(s)",
18655 prune_realtime_usage, complete_sip_prune_realtime_peer },
18656
18657 { { "sip", "prune", "realtime", "user", NULL },
18658 sip_prune_realtime, "Prune cached Realtime user(s)",
18659 prune_realtime_usage, complete_sip_prune_realtime_user },
18660
18661 { { "sip", "set", "debug", NULL },
18662 sip_do_debug, "Enable SIP debugging",
18663 debug_usage, NULL, &cli_sip_debug_deprecated },
18664
18665 { { "sip", "set", "debug", "ip", NULL },
18666 sip_do_debug, "Enable SIP debugging on IP",
18667 debug_usage },
18668
18669 { { "sip", "set", "debug", "peer", NULL },
18670 sip_do_debug, "Enable SIP debugging on Peername",
18671 debug_usage, complete_sip_debug_peer },
18672
18673 { { "sip", "set", "debug", "off", NULL },
18674 sip_no_debug, "Disable SIP debugging",
18675 no_debug_usage, NULL, &cli_sip_no_debug_deprecated },
18676
18677 { { "sip", "history", NULL },
18678 sip_do_history, "Enable SIP history",
18679 history_usage },
18680
18681 { { "sip", "history", "off", NULL },
18682 sip_no_history, "Disable SIP history",
18683 no_history_usage },
18684
18685 { { "sip", "reload", NULL },
18686 sip_reload, "Reload SIP configuration",
18687 sip_reload_usage },
18688 };
18689
18690
18691 static int load_module(void)
18692 {
18693 ASTOBJ_CONTAINER_INIT(&userl);
18694 ASTOBJ_CONTAINER_INIT(&peerl);
18695 ASTOBJ_CONTAINER_INIT(®l);
18696
18697 if (!(sched = sched_context_create())) {
18698 ast_log(LOG_ERROR, "Unable to create scheduler context\n");
18699 return AST_MODULE_LOAD_FAILURE;
18700 }
18701
18702 if (!(io = io_context_create())) {
18703 ast_log(LOG_ERROR, "Unable to create I/O context\n");
18704 sched_context_destroy(sched);
18705 return AST_MODULE_LOAD_FAILURE;
18706 }
18707
18708 sip_reloadreason = CHANNEL_MODULE_LOAD;
18709
18710 if(reload_config(sip_reloadreason))
18711 return AST_MODULE_LOAD_DECLINE;
18712
18713
18714 if (ast_channel_register(&sip_tech)) {
18715 ast_log(LOG_ERROR, "Unable to register channel type 'SIP'\n");
18716 io_context_destroy(io);
18717 sched_context_destroy(sched);
18718 return AST_MODULE_LOAD_FAILURE;
18719 }
18720
18721
18722 ast_cli_register_multiple(cli_sip, sizeof(cli_sip)/ sizeof(struct ast_cli_entry));
18723
18724
18725 ast_rtp_proto_register(&sip_rtp);
18726
18727
18728 ast_udptl_proto_register(&sip_udptl);
18729
18730
18731 ast_register_application(app_dtmfmode, sip_dtmfmode, synopsis_dtmfmode, descrip_dtmfmode);
18732 ast_register_application(app_sipaddheader, sip_addheader, synopsis_sipaddheader, descrip_sipaddheader);
18733
18734
18735 ast_custom_function_register(&sip_header_function);
18736 ast_custom_function_register(&sippeer_function);
18737 ast_custom_function_register(&sipchaninfo_function);
18738 ast_custom_function_register(&checksipdomain_function);
18739
18740
18741 ast_manager_register2("SIPpeers", EVENT_FLAG_SYSTEM, manager_sip_show_peers,
18742 "List SIP peers (text format)", mandescr_show_peers);
18743 ast_manager_register2("SIPshowpeer", EVENT_FLAG_SYSTEM, manager_sip_show_peer,
18744 "Show SIP peer (text format)", mandescr_show_peer);
18745
18746 sip_poke_all_peers();
18747 sip_send_all_registers();
18748
18749
18750 restart_monitor();
18751
18752 return AST_MODULE_LOAD_SUCCESS;
18753 }
18754
18755
18756 static int unload_module(void)
18757 {
18758 struct sip_pvt *p, *pl;
18759
18760
18761 ast_channel_unregister(&sip_tech);
18762
18763
18764 ast_custom_function_unregister(&sipchaninfo_function);
18765 ast_custom_function_unregister(&sippeer_function);
18766 ast_custom_function_unregister(&sip_header_function);
18767 ast_custom_function_unregister(&checksipdomain_function);
18768
18769
18770 ast_unregister_application(app_dtmfmode);
18771 ast_unregister_application(app_sipaddheader);
18772
18773
18774 ast_cli_unregister_multiple(cli_sip, sizeof(cli_sip) / sizeof(struct ast_cli_entry));
18775
18776
18777 ast_rtp_proto_unregister(&sip_rtp);
18778
18779
18780 ast_udptl_proto_unregister(&sip_udptl);
18781
18782
18783 ast_manager_unregister("SIPpeers");
18784 ast_manager_unregister("SIPshowpeer");
18785
18786 ast_mutex_lock(&iflock);
18787
18788 for (p = iflist; p ; p = p->next) {
18789 if (p->owner)
18790 ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
18791 }
18792 ast_mutex_unlock(&iflock);
18793
18794 ast_mutex_lock(&monlock);
18795 if (monitor_thread && (monitor_thread != AST_PTHREADT_STOP) && (monitor_thread != AST_PTHREADT_NULL)) {
18796 pthread_cancel(monitor_thread);
18797 pthread_kill(monitor_thread, SIGURG);
18798 pthread_join(monitor_thread, NULL);
18799 }
18800 monitor_thread = AST_PTHREADT_STOP;
18801 ast_mutex_unlock(&monlock);
18802
18803 restartdestroy:
18804 ast_mutex_lock(&iflock);
18805
18806 p = iflist;
18807 while (p) {
18808 pl = p;
18809 p = p->next;
18810 if (__sip_destroy(pl, TRUE) < 0) {
18811
18812 iflist = p;
18813 ast_mutex_unlock(&iflock);
18814 usleep(1);
18815 goto restartdestroy;
18816 }
18817 }
18818 iflist = NULL;
18819 ast_mutex_unlock(&iflock);
18820
18821
18822 ast_free_ha(localaddr);
18823
18824 ASTOBJ_CONTAINER_DESTROYALL(&userl, sip_destroy_user);
18825 ASTOBJ_CONTAINER_DESTROY(&userl);
18826 ASTOBJ_CONTAINER_DESTROYALL(&peerl, sip_destroy_peer);
18827 ASTOBJ_CONTAINER_DESTROY(&peerl);
18828 ASTOBJ_CONTAINER_DESTROYALL(®l, sip_registry_destroy);
18829 ASTOBJ_CONTAINER_DESTROY(®l);
18830
18831 clear_realm_authentication(authl);
18832 clear_sip_domains();
18833 close(sipsock);
18834 close(siptcpsock);
18835 sched_context_destroy(sched);
18836
18837 return 0;
18838 }
18839
18840 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Session Initiation Protocol (SIP)",
18841 .load = load_module,
18842 .unload = unload_module,
18843 .reload = reload,
18844 );