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
00095 #include "asterisk.h"
00096
00097 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 119926 $")
00098
00099 #include <stdio.h>
00100 #include <ctype.h>
00101 #include <string.h>
00102 #include <unistd.h>
00103 #include <sys/socket.h>
00104 #include <sys/ioctl.h>
00105 #include <net/if.h>
00106 #include <errno.h>
00107 #include <stdlib.h>
00108 #include <fcntl.h>
00109 #include <netdb.h>
00110 #include <signal.h>
00111 #include <sys/signal.h>
00112 #include <netinet/in.h>
00113 #include <netinet/in_systm.h>
00114 #include <arpa/inet.h>
00115 #include <netinet/ip.h>
00116 #include <regex.h>
00117
00118 #include "asterisk/lock.h"
00119 #include "asterisk/channel.h"
00120 #include "asterisk/config.h"
00121 #include "asterisk/logger.h"
00122 #include "asterisk/module.h"
00123 #include "asterisk/pbx.h"
00124 #include "asterisk/options.h"
00125 #include "asterisk/sched.h"
00126 #include "asterisk/io.h"
00127 #include "asterisk/rtp.h"
00128 #include "asterisk/udptl.h"
00129 #include "asterisk/acl.h"
00130 #include "asterisk/manager.h"
00131 #include "asterisk/callerid.h"
00132 #include "asterisk/cli.h"
00133 #include "asterisk/app.h"
00134 #include "asterisk/musiconhold.h"
00135 #include "asterisk/dsp.h"
00136 #include "asterisk/features.h"
00137 #include "asterisk/srv.h"
00138 #include "asterisk/astdb.h"
00139 #include "asterisk/causes.h"
00140 #include "asterisk/utils.h"
00141 #include "asterisk/file.h"
00142 #include "asterisk/astobj.h"
00143 #include "asterisk/devicestate.h"
00144 #include "asterisk/linkedlists.h"
00145 #include "asterisk/stringfields.h"
00146 #include "asterisk/monitor.h"
00147 #include "asterisk/localtime.h"
00148 #include "asterisk/abstract_jb.h"
00149 #include "asterisk/compiler.h"
00150 #include "asterisk/threadstorage.h"
00151 #include "asterisk/translate.h"
00152
00153 #ifndef FALSE
00154 #define FALSE 0
00155 #endif
00156
00157 #ifndef TRUE
00158 #define TRUE 1
00159 #endif
00160
00161 #define SIPBUFSIZE 512
00162
00163 #define XMIT_ERROR -2
00164
00165 #define VIDEO_CODEC_MASK 0x1fc0000
00166 #ifndef IPTOS_MINCOST
00167 #define IPTOS_MINCOST 0x02
00168 #endif
00169
00170
00171
00172 #define DEFAULT_DEFAULT_EXPIRY 120
00173 #define DEFAULT_MIN_EXPIRY 60
00174 #define DEFAULT_MAX_EXPIRY 3600
00175 #define DEFAULT_REGISTRATION_TIMEOUT 20
00176 #define DEFAULT_MAX_FORWARDS "70"
00177
00178
00179
00180 #define EXPIRY_GUARD_SECS 15
00181 #define EXPIRY_GUARD_LIMIT 30
00182
00183 #define EXPIRY_GUARD_MIN 500
00184
00185
00186
00187 #define EXPIRY_GUARD_PCT 0.20
00188
00189 #define DEFAULT_EXPIRY 900
00190
00191 static int min_expiry = DEFAULT_MIN_EXPIRY;
00192 static int max_expiry = DEFAULT_MAX_EXPIRY;
00193 static int default_expiry = DEFAULT_DEFAULT_EXPIRY;
00194 static int expiry = DEFAULT_EXPIRY;
00195
00196 #ifndef MAX
00197 #define MAX(a,b) ((a) > (b) ? (a) : (b))
00198 #endif
00199
00200 #define CALLERID_UNKNOWN "Unknown"
00201
00202 #define DEFAULT_MAXMS 2000
00203 #define DEFAULT_FREQ_OK 60 * 1000
00204 #define DEFAULT_FREQ_NOTOK 10 * 1000
00205
00206 #define DEFAULT_RETRANS 1000
00207 #define MAX_RETRANS 6
00208 #define SIP_TRANS_TIMEOUT 32000
00209
00210
00211 #define DEFAULT_TRANS_TIMEOUT -1
00212 #define MAX_AUTHTRIES 3
00213
00214 #define SIP_MAX_HEADERS 64
00215 #define SIP_MAX_LINES 64
00216 #define SIP_MAX_PACKET 4096
00217
00218 #define SDP_MAX_RTPMAP_CODECS 32
00219
00220 #define INITIAL_CSEQ 101
00221
00222
00223 static struct ast_jb_conf default_jbconf =
00224 {
00225 .flags = 0,
00226 .max_size = -1,
00227 .resync_threshold = -1,
00228 .impl = ""
00229 };
00230 static struct ast_jb_conf global_jbconf;
00231
00232 static const char config[] = "sip.conf";
00233 static const char notify_config[] = "sip_notify.conf";
00234
00235 #define RTP 1
00236 #define NO_RTP 0
00237
00238
00239
00240
00241 enum transfermodes {
00242 TRANSFER_OPENFORALL,
00243 TRANSFER_CLOSED,
00244 };
00245
00246
00247 enum sip_result {
00248 AST_SUCCESS = 0,
00249 AST_FAILURE = -1,
00250 };
00251
00252
00253
00254
00255 enum invitestates {
00256 INV_NONE = 0,
00257 INV_CALLING = 1,
00258 INV_PROCEEDING = 2,
00259 INV_EARLY_MEDIA = 3,
00260 INV_COMPLETED = 4,
00261 INV_CONFIRMED = 5,
00262 INV_TERMINATED = 6,
00263
00264 INV_CANCELLED = 7,
00265 };
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275 enum xmittype {
00276 XMIT_CRITICAL = 2,
00277
00278 XMIT_RELIABLE = 1,
00279 XMIT_UNRELIABLE = 0,
00280 };
00281
00282 enum parse_register_result {
00283 PARSE_REGISTER_FAILED,
00284 PARSE_REGISTER_UPDATE,
00285 PARSE_REGISTER_QUERY,
00286 };
00287
00288 enum subscriptiontype {
00289 NONE = 0,
00290 XPIDF_XML,
00291 DIALOG_INFO_XML,
00292 CPIM_PIDF_XML,
00293 PIDF_XML,
00294 MWI_NOTIFICATION
00295 };
00296
00297 static const struct cfsubscription_types {
00298 enum subscriptiontype type;
00299 const char * const event;
00300 const char * const mediatype;
00301 const char * const text;
00302 } subscription_types[] = {
00303 { NONE, "-", "unknown", "unknown" },
00304
00305 { DIALOG_INFO_XML, "dialog", "application/dialog-info+xml", "dialog-info+xml" },
00306 { CPIM_PIDF_XML, "presence", "application/cpim-pidf+xml", "cpim-pidf+xml" },
00307 { PIDF_XML, "presence", "application/pidf+xml", "pidf+xml" },
00308 { XPIDF_XML, "presence", "application/xpidf+xml", "xpidf+xml" },
00309 { MWI_NOTIFICATION, "message-summary", "application/simple-message-summary", "mwi" }
00310 };
00311
00312
00313 enum sipmethod {
00314 SIP_UNKNOWN,
00315 SIP_RESPONSE,
00316 SIP_REGISTER,
00317 SIP_OPTIONS,
00318 SIP_NOTIFY,
00319 SIP_INVITE,
00320 SIP_ACK,
00321 SIP_PRACK,
00322 SIP_BYE,
00323 SIP_REFER,
00324 SIP_SUBSCRIBE,
00325 SIP_MESSAGE,
00326 SIP_UPDATE,
00327 SIP_INFO,
00328 SIP_CANCEL,
00329 SIP_PUBLISH,
00330 SIP_PING,
00331 };
00332
00333
00334
00335
00336
00337
00338 enum sip_auth_type {
00339 PROXY_AUTH,
00340 WWW_AUTH,
00341 };
00342
00343
00344 enum check_auth_result {
00345 AUTH_SUCCESSFUL = 0,
00346 AUTH_CHALLENGE_SENT = 1,
00347 AUTH_SECRET_FAILED = -1,
00348 AUTH_USERNAME_MISMATCH = -2,
00349 AUTH_NOT_FOUND = -3,
00350 AUTH_FAKE_AUTH = -4,
00351 AUTH_UNKNOWN_DOMAIN = -5,
00352 AUTH_PEER_NOT_DYNAMIC = -6,
00353 AUTH_ACL_FAILED = -7,
00354 };
00355
00356
00357 enum sipregistrystate {
00358 REG_STATE_UNREGISTERED = 0,
00359 REG_STATE_REGSENT,
00360 REG_STATE_AUTHSENT,
00361 REG_STATE_REGISTERED,
00362 REG_STATE_REJECTED,
00363 REG_STATE_TIMEOUT,
00364 REG_STATE_NOAUTH,
00365 REG_STATE_FAILED,
00366 };
00367
00368 #define CAN_NOT_CREATE_DIALOG 0
00369 #define CAN_CREATE_DIALOG 1
00370 #define CAN_CREATE_DIALOG_UNSUPPORTED_METHOD 2
00371
00372
00373 static const struct cfsip_methods {
00374 enum sipmethod id;
00375 int need_rtp;
00376 char * const text;
00377 int can_create;
00378 } sip_methods[] = {
00379 { SIP_UNKNOWN, RTP, "-UNKNOWN-", CAN_CREATE_DIALOG },
00380 { SIP_RESPONSE, NO_RTP, "SIP/2.0", CAN_NOT_CREATE_DIALOG },
00381 { SIP_REGISTER, NO_RTP, "REGISTER", CAN_CREATE_DIALOG },
00382 { SIP_OPTIONS, NO_RTP, "OPTIONS", CAN_CREATE_DIALOG },
00383 { SIP_NOTIFY, NO_RTP, "NOTIFY", CAN_CREATE_DIALOG },
00384 { SIP_INVITE, RTP, "INVITE", CAN_CREATE_DIALOG },
00385 { SIP_ACK, NO_RTP, "ACK", CAN_NOT_CREATE_DIALOG },
00386 { SIP_PRACK, NO_RTP, "PRACK", CAN_NOT_CREATE_DIALOG },
00387 { SIP_BYE, NO_RTP, "BYE", CAN_NOT_CREATE_DIALOG },
00388 { SIP_REFER, NO_RTP, "REFER", CAN_CREATE_DIALOG },
00389 { SIP_SUBSCRIBE, NO_RTP, "SUBSCRIBE", CAN_CREATE_DIALOG },
00390 { SIP_MESSAGE, NO_RTP, "MESSAGE", CAN_CREATE_DIALOG },
00391 { SIP_UPDATE, NO_RTP, "UPDATE", CAN_NOT_CREATE_DIALOG },
00392 { SIP_INFO, NO_RTP, "INFO", CAN_NOT_CREATE_DIALOG },
00393 { SIP_CANCEL, NO_RTP, "CANCEL", CAN_NOT_CREATE_DIALOG },
00394 { SIP_PUBLISH, NO_RTP, "PUBLISH", CAN_CREATE_DIALOG_UNSUPPORTED_METHOD },
00395 { SIP_PING, NO_RTP, "PING", CAN_CREATE_DIALOG_UNSUPPORTED_METHOD }
00396 };
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408 #define SUPPORTED 1
00409 #define NOT_SUPPORTED 0
00410
00411 #define SIP_OPT_REPLACES (1 << 0)
00412 #define SIP_OPT_100REL (1 << 1)
00413 #define SIP_OPT_TIMER (1 << 2)
00414 #define SIP_OPT_EARLY_SESSION (1 << 3)
00415 #define SIP_OPT_JOIN (1 << 4)
00416 #define SIP_OPT_PATH (1 << 5)
00417 #define SIP_OPT_PREF (1 << 6)
00418 #define SIP_OPT_PRECONDITION (1 << 7)
00419 #define SIP_OPT_PRIVACY (1 << 8)
00420 #define SIP_OPT_SDP_ANAT (1 << 9)
00421 #define SIP_OPT_SEC_AGREE (1 << 10)
00422 #define SIP_OPT_EVENTLIST (1 << 11)
00423 #define SIP_OPT_GRUU (1 << 12)
00424 #define SIP_OPT_TARGET_DIALOG (1 << 13)
00425 #define SIP_OPT_NOREFERSUB (1 << 14)
00426 #define SIP_OPT_HISTINFO (1 << 15)
00427 #define SIP_OPT_RESPRIORITY (1 << 16)
00428
00429
00430
00431 static const struct cfsip_options {
00432 int id;
00433 int supported;
00434 char * const text;
00435 } sip_options[] = {
00436
00437 { SIP_OPT_REPLACES, SUPPORTED, "replaces" },
00438
00439 { SIP_OPT_REPLACES, SUPPORTED, "replace" },
00440
00441 { SIP_OPT_100REL, NOT_SUPPORTED, "100rel" },
00442
00443 { SIP_OPT_TIMER, NOT_SUPPORTED, "timer" },
00444
00445 { SIP_OPT_EARLY_SESSION, NOT_SUPPORTED, "early-session" },
00446
00447 { SIP_OPT_JOIN, NOT_SUPPORTED, "join" },
00448
00449 { SIP_OPT_PATH, NOT_SUPPORTED, "path" },
00450
00451 { SIP_OPT_PREF, NOT_SUPPORTED, "pref" },
00452
00453 { SIP_OPT_PRECONDITION, NOT_SUPPORTED, "precondition" },
00454
00455 { SIP_OPT_PRIVACY, NOT_SUPPORTED, "privacy" },
00456
00457 { SIP_OPT_SDP_ANAT, NOT_SUPPORTED, "sdp-anat" },
00458
00459 { SIP_OPT_SEC_AGREE, NOT_SUPPORTED, "sec_agree" },
00460
00461 { SIP_OPT_EVENTLIST, NOT_SUPPORTED, "eventlist" },
00462
00463 { SIP_OPT_GRUU, NOT_SUPPORTED, "gruu" },
00464
00465 { SIP_OPT_TARGET_DIALOG,NOT_SUPPORTED, "tdialog" },
00466
00467 { SIP_OPT_NOREFERSUB, NOT_SUPPORTED, "norefersub" },
00468
00469 { SIP_OPT_HISTINFO, NOT_SUPPORTED, "histinfo" },
00470
00471 { SIP_OPT_RESPRIORITY, NOT_SUPPORTED, "resource-priority" },
00472 };
00473
00474
00475
00476 #define ALLOWED_METHODS "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, SUBSCRIBE, NOTIFY"
00477
00478
00479 #define SUPPORTED_EXTENSIONS "replaces"
00480
00481
00482 #define STANDARD_SIP_PORT 5060
00483
00484
00485
00486
00487
00488
00489
00490
00491
00492
00493
00494
00495 #define DEFAULT_CONTEXT "default"
00496 #define DEFAULT_MOHINTERPRET "default"
00497 #define DEFAULT_MOHSUGGEST ""
00498 #define DEFAULT_VMEXTEN "asterisk"
00499 #define DEFAULT_CALLERID "asterisk"
00500 #define DEFAULT_NOTIFYMIME "application/simple-message-summary"
00501 #define DEFAULT_MWITIME 10
00502 #define DEFAULT_ALLOWGUEST TRUE
00503 #define DEFAULT_SRVLOOKUP TRUE
00504 #define DEFAULT_COMPACTHEADERS FALSE
00505 #define DEFAULT_TOS_SIP 0
00506 #define DEFAULT_TOS_AUDIO 0
00507 #define DEFAULT_TOS_VIDEO 0
00508 #define DEFAULT_ALLOW_EXT_DOM TRUE
00509 #define DEFAULT_REALM "asterisk"
00510 #define DEFAULT_NOTIFYRINGING TRUE
00511 #define DEFAULT_PEDANTIC FALSE
00512 #define DEFAULT_AUTOCREATEPEER FALSE
00513 #define DEFAULT_QUALIFY FALSE
00514 #define DEFAULT_T1MIN 100
00515 #define DEFAULT_MAX_CALL_BITRATE (384)
00516 #ifndef DEFAULT_USERAGENT
00517 #define DEFAULT_USERAGENT "Asterisk PBX"
00518 #endif
00519
00520
00521
00522
00523 static char default_context[AST_MAX_CONTEXT];
00524 static char default_subscribecontext[AST_MAX_CONTEXT];
00525 static char default_language[MAX_LANGUAGE];
00526 static char default_callerid[AST_MAX_EXTENSION];
00527 static char default_fromdomain[AST_MAX_EXTENSION];
00528 static char default_notifymime[AST_MAX_EXTENSION];
00529 static int default_qualify;
00530 static char default_vmexten[AST_MAX_EXTENSION];
00531 static char default_mohinterpret[MAX_MUSICCLASS];
00532 static char default_mohsuggest[MAX_MUSICCLASS];
00533
00534 static int default_maxcallbitrate;
00535 static struct ast_codec_pref default_prefs;
00536
00537
00538 static int global_directrtpsetup;
00539 static int global_limitonpeers;
00540 static int global_rtautoclear;
00541 static int global_notifyringing;
00542 static int global_notifyhold;
00543 static int global_alwaysauthreject;
00544 static int srvlookup;
00545 static int pedanticsipchecking;
00546 static int autocreatepeer;
00547 static int global_relaxdtmf;
00548 static int global_rtptimeout;
00549 static int global_rtpholdtimeout;
00550 static int global_rtpkeepalive;
00551 static int global_reg_timeout;
00552 static int global_regattempts_max;
00553 static int global_allowguest;
00554 static int global_allowsubscribe;
00555
00556 static int global_mwitime;
00557 static unsigned int global_tos_sip;
00558 static unsigned int global_tos_audio;
00559 static unsigned int global_tos_video;
00560 static int compactheaders;
00561 static int recordhistory;
00562 static int dumphistory;
00563 static char global_realm[MAXHOSTNAMELEN];
00564 static char global_regcontext[AST_MAX_CONTEXT];
00565 static char global_useragent[AST_MAX_EXTENSION];
00566 static int allow_external_domains;
00567 static int global_callevents;
00568 static int global_t1min;
00569 static int global_autoframing;
00570 static enum transfermodes global_allowtransfer;
00571
00572 static int global_matchexterniplocally;
00573
00574
00575 static int global_capability = AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_GSM | AST_FORMAT_H263;
00576
00577
00578 static int suserobjs = 0;
00579 static int ruserobjs = 0;
00580 static int speerobjs = 0;
00581 static int rpeerobjs = 0;
00582 static int apeerobjs = 0;
00583 static int regobjs = 0;
00584
00585 static struct ast_flags global_flags[2] = {{0}};
00586
00587
00588 AST_MUTEX_DEFINE_STATIC(iflock);
00589
00590
00591
00592 AST_MUTEX_DEFINE_STATIC(netlock);
00593
00594 AST_MUTEX_DEFINE_STATIC(monlock);
00595
00596 AST_MUTEX_DEFINE_STATIC(sip_reload_lock);
00597
00598
00599
00600 static pthread_t monitor_thread = AST_PTHREADT_NULL;
00601
00602 static int sip_reloading = FALSE;
00603 static enum channelreloadreason sip_reloadreason;
00604
00605 static struct sched_context *sched;
00606 static struct io_context *io;
00607 static int *sipsock_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
00800 #define SIP_PAGE2_FLAGS_TO_COPY \
00801 (SIP_PAGE2_ALLOWSUBSCRIBE | SIP_PAGE2_ALLOWOVERLAP | SIP_PAGE2_VIDEOSUPPORT | \
00802 SIP_PAGE2_T38SUPPORT | SIP_PAGE2_RFC2833_COMPENSATE | SIP_PAGE2_BUGGY_MWI | SIP_PAGE2_UDPTL_DESTINATION)
00803
00804
00805 #define SIP_PKT_DEBUG (1 << 0)
00806 #define SIP_PKT_WITH_TOTAG (1 << 1)
00807 #define SIP_PKT_IGNORE (1 << 2)
00808 #define SIP_PKT_IGNORE_RESP (1 << 3)
00809 #define SIP_PKT_IGNORE_REQ (1 << 4)
00810
00811
00812 #define T38FAX_FILL_BIT_REMOVAL (1 << 0)
00813 #define T38FAX_TRANSCODING_MMR (1 << 1)
00814 #define T38FAX_TRANSCODING_JBIG (1 << 2)
00815
00816 #define T38FAX_RATE_MANAGEMENT_TRANSFERED_TCF (0 << 3)
00817 #define T38FAX_RATE_MANAGEMENT_LOCAL_TCF (1 << 3)
00818
00819 #define T38FAX_UDP_EC_NONE (0 << 4)
00820 #define T38FAX_UDP_EC_FEC (1 << 4)
00821 #define T38FAX_UDP_EC_REDUNDANCY (2 << 4)
00822
00823 #define T38FAX_VERSION (3 << 6)
00824 #define T38FAX_VERSION_0 (0 << 6)
00825 #define T38FAX_VERSION_1 (1 << 6)
00826
00827 #define T38FAX_RATE_2400 (1 << 8)
00828 #define T38FAX_RATE_4800 (1 << 9)
00829 #define T38FAX_RATE_7200 (1 << 10)
00830 #define T38FAX_RATE_9600 (1 << 11)
00831 #define T38FAX_RATE_12000 (1 << 12)
00832 #define T38FAX_RATE_14400 (1 << 13)
00833
00834
00835 static int global_t38_capability = T38FAX_VERSION_0 | T38FAX_RATE_2400 | T38FAX_RATE_4800 | T38FAX_RATE_7200 | T38FAX_RATE_9600;
00836
00837 #define sipdebug ast_test_flag(&global_flags[1], SIP_PAGE2_DEBUG)
00838 #define sipdebug_config ast_test_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONFIG)
00839 #define sipdebug_console ast_test_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE)
00840
00841
00842 enum t38state {
00843 T38_DISABLED = 0,
00844 T38_LOCAL_DIRECT,
00845 T38_LOCAL_REINVITE,
00846 T38_PEER_DIRECT,
00847 T38_PEER_REINVITE,
00848 T38_ENABLED
00849 };
00850
00851
00852 struct t38properties {
00853 struct ast_flags t38support;
00854 int capability;
00855 int peercapability;
00856 int jointcapability;
00857 enum t38state state;
00858 };
00859
00860
00861 enum referstatus {
00862 REFER_IDLE,
00863 REFER_SENT,
00864 REFER_RECEIVED,
00865 REFER_CONFIRMED,
00866 REFER_ACCEPTED,
00867 REFER_RINGING,
00868 REFER_200OK,
00869 REFER_FAILED,
00870 REFER_NOAUTH
00871 };
00872
00873 static const struct c_referstatusstring {
00874 enum referstatus status;
00875 char *text;
00876 } referstatusstrings[] = {
00877 { REFER_IDLE, "<none>" },
00878 { REFER_SENT, "Request sent" },
00879 { REFER_RECEIVED, "Request received" },
00880 { REFER_ACCEPTED, "Accepted" },
00881 { REFER_RINGING, "Target ringing" },
00882 { REFER_200OK, "Done" },
00883 { REFER_FAILED, "Failed" },
00884 { REFER_NOAUTH, "Failed - auth failure" }
00885 } ;
00886
00887
00888
00889 struct sip_refer {
00890 char refer_to[AST_MAX_EXTENSION];
00891 char refer_to_domain[AST_MAX_EXTENSION];
00892 char refer_to_urioption[AST_MAX_EXTENSION];
00893 char refer_to_context[AST_MAX_EXTENSION];
00894 char referred_by[AST_MAX_EXTENSION];
00895 char referred_by_name[AST_MAX_EXTENSION];
00896 char refer_contact[AST_MAX_EXTENSION];
00897 char replaces_callid[SIPBUFSIZE];
00898 char replaces_callid_totag[SIPBUFSIZE/2];
00899 char replaces_callid_fromtag[SIPBUFSIZE/2];
00900 struct sip_pvt *refer_call;
00901 int attendedtransfer;
00902 int localtransfer;
00903 enum referstatus status;
00904 };
00905
00906
00907 static struct sip_pvt {
00908 ast_mutex_t lock;
00909 int method;
00910 enum invitestates invitestate;
00911 AST_DECLARE_STRING_FIELDS(
00912 AST_STRING_FIELD(callid);
00913 AST_STRING_FIELD(randdata);
00914 AST_STRING_FIELD(accountcode);
00915 AST_STRING_FIELD(realm);
00916 AST_STRING_FIELD(nonce);
00917 AST_STRING_FIELD(opaque);
00918 AST_STRING_FIELD(qop);
00919 AST_STRING_FIELD(domain);
00920 AST_STRING_FIELD(from);
00921 AST_STRING_FIELD(useragent);
00922 AST_STRING_FIELD(exten);
00923 AST_STRING_FIELD(context);
00924 AST_STRING_FIELD(subscribecontext);
00925 AST_STRING_FIELD(subscribeuri);
00926 AST_STRING_FIELD(fromdomain);
00927 AST_STRING_FIELD(fromuser);
00928 AST_STRING_FIELD(fromname);
00929 AST_STRING_FIELD(tohost);
00930 AST_STRING_FIELD(language);
00931 AST_STRING_FIELD(mohinterpret);
00932 AST_STRING_FIELD(mohsuggest);
00933 AST_STRING_FIELD(rdnis);
00934 AST_STRING_FIELD(theirtag);
00935 AST_STRING_FIELD(username);
00936 AST_STRING_FIELD(peername);
00937 AST_STRING_FIELD(authname);
00938 AST_STRING_FIELD(uri);
00939 AST_STRING_FIELD(okcontacturi);
00940 AST_STRING_FIELD(peersecret);
00941 AST_STRING_FIELD(peermd5secret);
00942 AST_STRING_FIELD(cid_num);
00943 AST_STRING_FIELD(cid_name);
00944 AST_STRING_FIELD(via);
00945 AST_STRING_FIELD(fullcontact);
00946 AST_STRING_FIELD(our_contact);
00947 AST_STRING_FIELD(rpid);
00948 AST_STRING_FIELD(rpid_from);
00949 );
00950 unsigned int ocseq;
00951 unsigned int icseq;
00952 ast_group_t callgroup;
00953 ast_group_t pickupgroup;
00954 int lastinvite;
00955 int lastnoninvite;
00956 struct ast_flags flags[2];
00957 int timer_t1;
00958 unsigned int sipoptions;
00959 struct ast_codec_pref prefs;
00960 int capability;
00961 int jointcapability;
00962 int peercapability;
00963 int prefcodec;
00964 int noncodeccapability;
00965 int jointnoncodeccapability;
00966 int redircodecs;
00967 int maxcallbitrate;
00968 struct t38properties t38;
00969 struct sockaddr_in udptlredirip;
00970 struct ast_udptl *udptl;
00971 int callingpres;
00972 int authtries;
00973 int expiry;
00974 long branch;
00975 char tag[11];
00976 int sessionid;
00977 int sessionversion;
00978 struct sockaddr_in sa;
00979 struct sockaddr_in redirip;
00980 struct sockaddr_in vredirip;
00981 time_t lastrtprx;
00982 time_t lastrtptx;
00983 int rtptimeout;
00984 struct sockaddr_in recv;
00985 struct in_addr ourip;
00986 struct ast_channel *owner;
00987 struct sip_route *route;
00988 int route_persistant;
00989 struct sip_auth *peerauth;
00990 int noncecount;
00991 char lastmsg[256];
00992 int amaflags;
00993 int pendinginvite;
00994 struct sip_request initreq;
00995
00996
00997 int maxtime;
00998 int initid;
00999 int waitid;
01000 int autokillid;
01001 enum transfermodes allowtransfer;
01002 struct sip_refer *refer;
01003 enum subscriptiontype subscribed;
01004 int stateid;
01005 int laststate;
01006 int dialogver;
01007
01008 struct ast_dsp *vad;
01009
01010 struct sip_peer *relatedpeer;
01011
01012 struct sip_registry *registry;
01013 struct ast_rtp *rtp;
01014 struct ast_rtp *vrtp;
01015 struct sip_pkt *packets;
01016 struct sip_history_head *history;
01017 size_t history_entries;
01018 struct ast_variable *chanvars;
01019 struct sip_pvt *next;
01020 struct sip_invite_param *options;
01021 int autoframing;
01022 } *iflist = NULL;
01023
01024
01025 #define MAX_HISTORY_ENTRIES 50
01026
01027 #define FLAG_RESPONSE (1 << 0)
01028 #define FLAG_FATAL (1 << 1)
01029
01030
01031 struct sip_pkt {
01032 struct sip_pkt *next;
01033 int retrans;
01034 int method;
01035 int seqno;
01036 unsigned int flags;
01037 struct sip_pvt *owner;
01038 int retransid;
01039 int timer_a;
01040 int timer_t1;
01041 int packetlen;
01042 char data[0];
01043 };
01044
01045
01046 struct sip_user {
01047
01048 ASTOBJ_COMPONENTS(struct sip_user);
01049 char secret[80];
01050 char md5secret[80];
01051 char context[AST_MAX_CONTEXT];
01052 char subscribecontext[AST_MAX_CONTEXT];
01053 char cid_num[80];
01054 char cid_name[80];
01055 char accountcode[AST_MAX_ACCOUNT_CODE];
01056 char language[MAX_LANGUAGE];
01057 char mohinterpret[MAX_MUSICCLASS];
01058 char mohsuggest[MAX_MUSICCLASS];
01059 char useragent[256];
01060 struct ast_codec_pref prefs;
01061 ast_group_t callgroup;
01062 ast_group_t pickupgroup;
01063 unsigned int sipoptions;
01064 struct ast_flags flags[2];
01065 int amaflags;
01066 int callingpres;
01067 int capability;
01068 int inUse;
01069 int call_limit;
01070 enum transfermodes allowtransfer;
01071 struct ast_ha *ha;
01072 struct ast_variable *chanvars;
01073 int maxcallbitrate;
01074 int autoframing;
01075 };
01076
01077
01078
01079 struct sip_peer {
01080 ASTOBJ_COMPONENTS(struct sip_peer);
01081
01082 char secret[80];
01083 char md5secret[80];
01084 struct sip_auth *auth;
01085 char context[AST_MAX_CONTEXT];
01086 char subscribecontext[AST_MAX_CONTEXT];
01087 char username[80];
01088 char accountcode[AST_MAX_ACCOUNT_CODE];
01089 int amaflags;
01090 char tohost[MAXHOSTNAMELEN];
01091 char regexten[AST_MAX_EXTENSION];
01092 char fromuser[80];
01093 char fromdomain[MAXHOSTNAMELEN];
01094 char fullcontact[256];
01095 char cid_num[80];
01096 char cid_name[80];
01097 int callingpres;
01098 int inUse;
01099 int inRinging;
01100 int onHold;
01101 int call_limit;
01102 enum transfermodes allowtransfer;
01103 char vmexten[AST_MAX_EXTENSION];
01104 char mailbox[AST_MAX_EXTENSION];
01105 char language[MAX_LANGUAGE];
01106 char mohinterpret[MAX_MUSICCLASS];
01107 char mohsuggest[MAX_MUSICCLASS];
01108 char useragent[256];
01109 struct ast_codec_pref prefs;
01110 int lastmsgssent;
01111 time_t lastmsgcheck;
01112 unsigned int sipoptions;
01113 struct ast_flags flags[2];
01114 int expire;
01115 int capability;
01116 int rtptimeout;
01117 int rtpholdtimeout;
01118 int rtpkeepalive;
01119 ast_group_t callgroup;
01120 ast_group_t pickupgroup;
01121 struct sockaddr_in addr;
01122 int maxcallbitrate;
01123
01124
01125 struct sip_pvt *call;
01126 int pokeexpire;
01127 int lastms;
01128 int maxms;
01129 struct timeval ps;
01130
01131 struct sockaddr_in defaddr;
01132 struct ast_ha *ha;
01133 struct ast_variable *chanvars;
01134 struct sip_pvt *mwipvt;
01135 int lastmsg;
01136 int autoframing;
01137 };
01138
01139
01140
01141
01142 struct sip_registry {
01143 ASTOBJ_COMPONENTS_FULL(struct sip_registry,1,1);
01144 AST_DECLARE_STRING_FIELDS(
01145 AST_STRING_FIELD(callid);
01146 AST_STRING_FIELD(realm);
01147 AST_STRING_FIELD(nonce);
01148 AST_STRING_FIELD(opaque);
01149 AST_STRING_FIELD(qop);
01150 AST_STRING_FIELD(domain);
01151 AST_STRING_FIELD(username);
01152 AST_STRING_FIELD(authuser);
01153 AST_STRING_FIELD(hostname);
01154 AST_STRING_FIELD(secret);
01155 AST_STRING_FIELD(md5secret);
01156 AST_STRING_FIELD(contact);
01157 AST_STRING_FIELD(random);
01158 );
01159 int portno;
01160 int expire;
01161 int regattempts;
01162 int timeout;
01163 int refresh;
01164 struct sip_pvt *call;
01165 enum sipregistrystate regstate;
01166 time_t regtime;
01167 int callid_valid;
01168 unsigned int ocseq;
01169 struct sockaddr_in us;
01170 int noncecount;
01171 char lastmsg[256];
01172 };
01173
01174
01175
01176
01177 static struct ast_user_list {
01178 ASTOBJ_CONTAINER_COMPONENTS(struct sip_user);
01179 } userl;
01180
01181
01182 static struct ast_peer_list {
01183 ASTOBJ_CONTAINER_COMPONENTS(struct sip_peer);
01184 } peerl;
01185
01186
01187 static struct ast_register_list {
01188 ASTOBJ_CONTAINER_COMPONENTS(struct sip_registry);
01189 int recheck;
01190 } regl;
01191
01192 static void temp_pvt_cleanup(void *);
01193
01194
01195 AST_THREADSTORAGE_CUSTOM(ts_temp_pvt, temp_pvt_init, temp_pvt_cleanup);
01196
01197
01198 static struct sip_auth *authl = NULL;
01199
01200
01201
01202 static int sipsock = -1;
01203 static struct sockaddr_in bindaddr = { 0, };
01204 static struct sockaddr_in externip;
01205 static char externhost[MAXHOSTNAMELEN];
01206 static time_t externexpire = 0;
01207 static int externrefresh = 10;
01208 static struct ast_ha *localaddr;
01209 static struct in_addr __ourip;
01210 static struct sockaddr_in outboundproxyip;
01211 static int ourport;
01212 static struct sockaddr_in debugaddr;
01213
01214 static struct ast_config *notify_types;
01215
01216
01217
01218
01219
01220
01221 static struct ast_channel *sip_request_call(const char *type, int format, void *data, int *cause);
01222 static int sip_devicestate(void *data);
01223 static int sip_sendtext(struct ast_channel *ast, const char *text);
01224 static int sip_call(struct ast_channel *ast, char *dest, int timeout);
01225 static int sip_hangup(struct ast_channel *ast);
01226 static int sip_answer(struct ast_channel *ast);
01227 static struct ast_frame *sip_read(struct ast_channel *ast);
01228 static int sip_write(struct ast_channel *ast, struct ast_frame *frame);
01229 static int sip_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen);
01230 static int sip_transfer(struct ast_channel *ast, const char *dest);
01231 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
01232 static int sip_senddigit_begin(struct ast_channel *ast, char digit);
01233 static int sip_senddigit_end(struct ast_channel *ast, char digit, unsigned int duration);
01234
01235
01236 static int sipsock_read(int *id, int fd, short events, void *ignore);
01237 static int __sip_xmit(struct sip_pvt *p, char *data, int len);
01238 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal, int sipmethod);
01239 static int __transmit_response(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable);
01240 static int retrans_pkt(const void *data);
01241 static int transmit_sip_request(struct sip_pvt *p, struct sip_request *req);
01242 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);
01243 static int transmit_response(struct sip_pvt *p, const char *msg, const struct sip_request *req);
01244 static int transmit_response_reliable(struct sip_pvt *p, const char *msg, const struct sip_request *req);
01245 static int transmit_response_with_date(struct sip_pvt *p, const char *msg, const struct sip_request *req);
01246 static int transmit_response_with_sdp(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable);
01247 static int transmit_response_with_unsupported(struct sip_pvt *p, const char *msg, const struct sip_request *req, const char *unsupported);
01248 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);
01249 static int transmit_response_with_allow(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable);
01250 static void transmit_fake_auth_response(struct sip_pvt *p, int sipmethod, struct sip_request *req, enum xmittype reliable);
01251 static int transmit_request(struct sip_pvt *p, int sipmethod, int inc, enum xmittype reliable, int newbranch);
01252 static int transmit_request_with_auth(struct sip_pvt *p, int sipmethod, int seqno, enum xmittype reliable, int newbranch);
01253 static int transmit_invite(struct sip_pvt *p, int sipmethod, int sdp, int init);
01254 static int transmit_reinvite_with_sdp(struct sip_pvt *p);
01255 static int transmit_info_with_digit(struct sip_pvt *p, const char digit, unsigned int duration);
01256 static int transmit_info_with_vidupdate(struct sip_pvt *p);
01257 static int transmit_message_with_text(struct sip_pvt *p, const char *text);
01258 static int transmit_refer(struct sip_pvt *p, const char *dest);
01259 static int transmit_notify_with_mwi(struct sip_pvt *p, int newmsgs, int oldmsgs, char *vmexten);
01260 static int transmit_notify_with_sipfrag(struct sip_pvt *p, int cseq, char *message, int terminate);
01261 static int transmit_register(struct sip_registry *r, int sipmethod, const char *auth, const char *authheader);
01262 static int send_response(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno);
01263 static int send_request(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno);
01264 static void copy_request(struct sip_request *dst, const struct sip_request *src);
01265 static void receive_message(struct sip_pvt *p, struct sip_request *req);
01266 static void parse_moved_contact(struct sip_pvt *p, struct sip_request *req);
01267 static int sip_send_mwi_to_peer(struct sip_peer *peer);
01268 static int does_peer_need_mwi(struct sip_peer *peer);
01269
01270
01271 static struct sip_pvt *sip_alloc(ast_string_field callid, struct sockaddr_in *sin,
01272 int useglobal_nat, const int intended_method);
01273 static int __sip_autodestruct(const void *data);
01274 static void sip_scheddestroy(struct sip_pvt *p, int ms);
01275 static int sip_cancel_destroy(struct sip_pvt *p);
01276 static void sip_destroy(struct sip_pvt *p);
01277 static int __sip_destroy(struct sip_pvt *p, int lockowner);
01278 static void __sip_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod);
01279 static void __sip_pretend_ack(struct sip_pvt *p);
01280 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod);
01281 static int auto_congest(const void *nothing);
01282 static int update_call_counter(struct sip_pvt *fup, int event);
01283 static int hangup_sip2cause(int cause);
01284 static const char *hangup_cause2sip(int cause);
01285 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin, const int intended_method);
01286 static void free_old_route(struct sip_route *route);
01287 static void list_route(struct sip_route *route);
01288 static void build_route(struct sip_pvt *p, struct sip_request *req, int backwards);
01289 static enum check_auth_result register_verify(struct sip_pvt *p, struct sockaddr_in *sin,
01290 struct sip_request *req, char *uri);
01291 static struct sip_pvt *get_sip_pvt_byid_locked(const char *callid, const char *totag, const char *fromtag);
01292 static void check_pendings(struct sip_pvt *p);
01293 static void *sip_park_thread(void *stuff);
01294 static int sip_park(struct ast_channel *chan1, struct ast_channel *chan2, struct sip_request *req, int seqno);
01295 static int sip_sipredirect(struct sip_pvt *p, const char *dest);
01296
01297
01298 static void try_suggested_sip_codec(struct sip_pvt *p);
01299 static const char* get_sdp_iterate(int* start, struct sip_request *req, const char *name);
01300 static const char *get_sdp(struct sip_request *req, const char *name);
01301 static int find_sdp(struct sip_request *req);
01302 static int process_sdp(struct sip_pvt *p, struct sip_request *req);
01303 static void add_codec_to_sdp(const struct sip_pvt *p, int codec, int sample_rate,
01304 char **m_buf, size_t *m_size, char **a_buf, size_t *a_size,
01305 int debug, int *min_packet_size);
01306 static void add_noncodec_to_sdp(const struct sip_pvt *p, int format, int sample_rate,
01307 char **m_buf, size_t *m_size, char **a_buf, size_t *a_size,
01308 int debug);
01309 static enum sip_result add_sdp(struct sip_request *resp, struct sip_pvt *p);
01310 static void stop_media_flows(struct sip_pvt *p);
01311
01312
01313 static int reply_digest(struct sip_pvt *p, struct sip_request *req, char *header, int sipmethod, char *digest, int digest_len);
01314 static int build_reply_digest(struct sip_pvt *p, int method, char *digest, int digest_len);
01315 static enum check_auth_result check_auth(struct sip_pvt *p, struct sip_request *req, const char *username,
01316 const char *secret, const char *md5secret, int sipmethod,
01317 char *uri, enum xmittype reliable, int ignore);
01318 static enum check_auth_result check_user_full(struct sip_pvt *p, struct sip_request *req,
01319 int sipmethod, char *uri, enum xmittype reliable,
01320 struct sockaddr_in *sin, struct sip_peer **authpeer);
01321 static int check_user(struct sip_pvt *p, struct sip_request *req, int sipmethod, char *uri, enum xmittype reliable, struct sockaddr_in *sin);
01322
01323
01324 static int check_sip_domain(const char *domain, char *context, size_t len);
01325 static int add_sip_domain(const char *domain, const enum domain_mode mode, const char *context);
01326 static void clear_sip_domains(void);
01327
01328
01329 static struct sip_auth *add_realm_authentication(struct sip_auth *authlist, char *configuration, int lineno);
01330 static int clear_realm_authentication(struct sip_auth *authlist);
01331 static struct sip_auth *find_realm_authentication(struct sip_auth *authlist, const char *realm);
01332
01333
01334 static int sip_do_reload(enum channelreloadreason reason);
01335 static int reload_config(enum channelreloadreason reason);
01336 static int expire_register(const void *data);
01337 static void *do_monitor(void *data);
01338 static int restart_monitor(void);
01339 static int sip_send_mwi_to_peer(struct sip_peer *peer);
01340 static int sip_addrcmp(char *name, struct sockaddr_in *sin);
01341 static int sip_refer_allocate(struct sip_pvt *p);
01342 static void ast_quiet_chan(struct ast_channel *chan);
01343 static int attempt_transfer(struct sip_dual *transferer, struct sip_dual *target);
01344
01345
01346 static int cb_extensionstate(char *context, char* exten, int state, void *data, char *cid_num, char *cid_name);
01347 static int sip_devicestate(void *data);
01348 static int sip_poke_noanswer(const void *data);
01349 static int sip_poke_peer(struct sip_peer *peer);
01350 static void sip_poke_all_peers(void);
01351 static void sip_peer_hold(struct sip_pvt *p, int hold);
01352
01353
01354 static const char *sip_nat_mode(const struct sip_pvt *p);
01355 static int sip_show_inuse(int fd, int argc, char *argv[]);
01356 static char *transfermode2str(enum transfermodes mode) attribute_const;
01357 static char *nat2str(int nat) attribute_const;
01358 static int peer_status(struct sip_peer *peer, char *status, int statuslen);
01359 static int sip_show_users(int fd, int argc, char *argv[]);
01360 static int _sip_show_peers(int fd, int *total, struct mansession *s, const struct message *m, int argc, const char *argv[]);
01361 static int sip_show_peers(int fd, int argc, char *argv[]);
01362 static int sip_show_objects(int fd, int argc, char *argv[]);
01363 static void print_group(int fd, ast_group_t group, int crlf);
01364 static const char *dtmfmode2str(int mode) attribute_const;
01365 static const char *insecure2str(int port, int invite) attribute_const;
01366 static void cleanup_stale_contexts(char *new, char *old);
01367 static void print_codec_to_cli(int fd, struct ast_codec_pref *pref);
01368 static const char *domain_mode_to_text(const enum domain_mode mode);
01369 static int sip_show_domains(int fd, int argc, char *argv[]);
01370 static int _sip_show_peer(int type, int fd, struct mansession *s, const struct message *m, int argc, const char *argv[]);
01371 static int sip_show_peer(int fd, int argc, char *argv[]);
01372 static int sip_show_user(int fd, int argc, char *argv[]);
01373 static int sip_show_registry(int fd, int argc, char *argv[]);
01374 static int sip_show_settings(int fd, int argc, char *argv[]);
01375 static const char *subscription_type2str(enum subscriptiontype subtype) attribute_pure;
01376 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype);
01377 static int __sip_show_channels(int fd, int argc, char *argv[], int subscriptions);
01378 static int sip_show_channels(int fd, int argc, char *argv[]);
01379 static int sip_show_subscriptions(int fd, int argc, char *argv[]);
01380 static int __sip_show_channels(int fd, int argc, char *argv[], int subscriptions);
01381 static char *complete_sipch(const char *line, const char *word, int pos, int state);
01382 static char *complete_sip_peer(const char *word, int state, int flags2);
01383 static char *complete_sip_show_peer(const char *line, const char *word, int pos, int state);
01384 static char *complete_sip_debug_peer(const char *line, const char *word, int pos, int state);
01385 static char *complete_sip_user(const char *word, int state, int flags2);
01386 static char *complete_sip_show_user(const char *line, const char *word, int pos, int state);
01387 static char *complete_sipnotify(const char *line, const char *word, int pos, int state);
01388 static char *complete_sip_prune_realtime_peer(const char *line, const char *word, int pos, int state);
01389 static char *complete_sip_prune_realtime_user(const char *line, const char *word, int pos, int state);
01390 static int sip_show_channel(int fd, int argc, char *argv[]);
01391 static int sip_show_history(int fd, int argc, char *argv[]);
01392 static int sip_do_debug_ip(int fd, int argc, char *argv[]);
01393 static int sip_do_debug_peer(int fd, int argc, char *argv[]);
01394 static int sip_do_debug(int fd, int argc, char *argv[]);
01395 static int sip_no_debug(int fd, int argc, char *argv[]);
01396 static int sip_notify(int fd, int argc, char *argv[]);
01397 static int sip_do_history(int fd, int argc, char *argv[]);
01398 static int sip_no_history(int fd, int argc, char *argv[]);
01399 static int func_header_read(struct ast_channel *chan, char *function, char *data, char *buf, size_t len);
01400 static int func_check_sipdomain(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len);
01401 static int function_sippeer(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len);
01402 static int function_sipchaninfo_read(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len);
01403 static int sip_dtmfmode(struct ast_channel *chan, void *data);
01404 static int sip_addheader(struct ast_channel *chan, void *data);
01405 static int sip_do_reload(enum channelreloadreason reason);
01406 static int sip_reload(int fd, int argc, char *argv[]);
01407 static int acf_channel_read(struct ast_channel *chan, char *funcname, char *preparse, char *buf, size_t buflen);
01408
01409
01410
01411
01412
01413 static void sip_dump_history(struct sip_pvt *dialog);
01414 static inline int sip_debug_test_addr(const struct sockaddr_in *addr);
01415 static inline int sip_debug_test_pvt(struct sip_pvt *p);
01416 static void append_history_full(struct sip_pvt *p, const char *fmt, ...);
01417 static void sip_dump_history(struct sip_pvt *dialog);
01418
01419
01420 static struct sip_peer *temp_peer(const char *name);
01421 static struct sip_peer *build_peer(const char *name, struct ast_variable *v, struct ast_variable *alt, int realtime);
01422 static struct sip_user *build_user(const char *name, struct ast_variable *v, struct ast_variable *alt, int realtime);
01423 static int update_call_counter(struct sip_pvt *fup, int event);
01424 static void sip_destroy_peer(struct sip_peer *peer);
01425 static void sip_destroy_user(struct sip_user *user);
01426 static int sip_poke_peer(struct sip_peer *peer);
01427 static int sip_poke_peer_s(const void *data);
01428 static void set_peer_defaults(struct sip_peer *peer);
01429 static struct sip_peer *temp_peer(const char *name);
01430 static void register_peer_exten(struct sip_peer *peer, int onoff);
01431 static struct sip_peer *find_peer(const char *peer, struct sockaddr_in *sin, int realtime);
01432 static struct sip_user *find_user(const char *name, int realtime);
01433 static enum parse_register_result parse_register_contact(struct sip_pvt *pvt, struct sip_peer *p, struct sip_request *req);
01434 static int expire_register(const void *data);
01435 static void reg_source_db(struct sip_peer *peer);
01436 static void destroy_association(struct sip_peer *peer);
01437 static int handle_common_options(struct ast_flags *flags, struct ast_flags *mask, struct ast_variable *v);
01438
01439
01440 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, const char *username, const char *fullcontact, int expirey);
01441 static struct sip_user *realtime_user(const char *username);
01442 static void update_peer(struct sip_peer *p, int expiry);
01443 static struct sip_peer *realtime_peer(const char *peername, struct sockaddr_in *sin);
01444 static int sip_prune_realtime(int fd, int argc, char *argv[]);
01445
01446
01447 static int ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us);
01448 static void sip_registry_destroy(struct sip_registry *reg);
01449 static int sip_register(char *value, int lineno);
01450 static char *regstate2str(enum sipregistrystate regstate) attribute_const;
01451 static int sip_reregister(const void *data);
01452 static int __sip_do_register(struct sip_registry *r);
01453 static int sip_reg_timeout(const void *data);
01454 static void sip_send_all_registers(void);
01455
01456
01457 static void append_date(struct sip_request *req);
01458 static int determine_firstline_parts(struct sip_request *req);
01459 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype);
01460 static const char *gettag(const struct sip_request *req, const char *header, char *tagbuf, int tagbufsize);
01461 static void set_insecure_flags(struct ast_flags *flags, const char *value, int lineno);
01462 static int find_sip_method(const char *msg);
01463 static unsigned int parse_sip_options(struct sip_pvt *pvt, const char *supported);
01464 static int parse_request(struct sip_request *req);
01465 static const char *get_header(const struct sip_request *req, const char *name);
01466 static char *referstatus2str(enum referstatus rstatus) attribute_pure;
01467 static int method_match(enum sipmethod id, const char *name);
01468 static void parse_copy(struct sip_request *dst, const struct sip_request *src);
01469 static char *get_in_brackets(char *tmp);
01470 static const char *find_alias(const char *name, const char *_default);
01471 static const char *__get_header(const struct sip_request *req, const char *name, int *start);
01472 static int lws2sws(char *msgbuf, int len);
01473 static void extract_uri(struct sip_pvt *p, struct sip_request *req);
01474 static int get_refer_info(struct sip_pvt *transferer, struct sip_request *outgoing_req);
01475 static int get_also_info(struct sip_pvt *p, struct sip_request *oreq);
01476 static int parse_ok_contact(struct sip_pvt *pvt, struct sip_request *req);
01477 static int set_address_from_contact(struct sip_pvt *pvt);
01478 static void check_via(struct sip_pvt *p, const struct sip_request *req);
01479 static char *get_calleridname(const char *input, char *output, size_t outputsize);
01480 static int get_rpid_num(const char *input, char *output, int maxlen);
01481 static int get_rdnis(struct sip_pvt *p, struct sip_request *oreq);
01482 static int get_destination(struct sip_pvt *p, struct sip_request *oreq);
01483 static int get_msg_text(char *buf, int len, struct sip_request *req);
01484 static void free_old_route(struct sip_route *route);
01485 static int transmit_state_notify(struct sip_pvt *p, int state, int full, int timeout);
01486
01487
01488 static void initialize_initreq(struct sip_pvt *p, struct sip_request *req);
01489 static int init_req(struct sip_request *req, int sipmethod, const char *recip);
01490 static int reqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod, int seqno, int newbranch);
01491 static void initreqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod);
01492 static int init_resp(struct sip_request *resp, const char *msg);
01493 static int respprep(struct sip_request *resp, struct sip_pvt *p, const char *msg, const struct sip_request *req);
01494 static const struct sockaddr_in *sip_real_dst(const struct sip_pvt *p);
01495 static void build_via(struct sip_pvt *p);
01496 static int create_addr_from_peer(struct sip_pvt *r, struct sip_peer *peer);
01497 static int create_addr(struct sip_pvt *dialog, const char *opeer);
01498 static char *generate_random_string(char *buf, size_t size);
01499 static void build_callid_pvt(struct sip_pvt *pvt);
01500 static void build_callid_registry(struct sip_registry *reg, struct in_addr ourip, const char *fromdomain);
01501 static void make_our_tag(char *tagbuf, size_t len);
01502 static int add_header(struct sip_request *req, const char *var, const char *value);
01503 static int add_header_contentLength(struct sip_request *req, int len);
01504 static int add_line(struct sip_request *req, const char *line);
01505 static int add_text(struct sip_request *req, const char *text);
01506 static int add_digit(struct sip_request *req, char digit, unsigned int duration);
01507 static int add_vidupdate(struct sip_request *req);
01508 static void add_route(struct sip_request *req, struct sip_route *route);
01509 static int copy_header(struct sip_request *req, const struct sip_request *orig, const char *field);
01510 static int copy_all_header(struct sip_request *req, const struct sip_request *orig, const char *field);
01511 static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, const struct sip_request *orig, const char *field);
01512 static void set_destination(struct sip_pvt *p, char *uri);
01513 static void append_date(struct sip_request *req);
01514 static void build_contact(struct sip_pvt *p);
01515 static void build_rpid(struct sip_pvt *p);
01516
01517
01518 static int handle_request(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int *recount, int *nounlock);
01519 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);
01520 static int handle_request_refer(struct sip_pvt *p, struct sip_request *req, int debug, int ignore, int seqno, int *nounlock);
01521 static int handle_request_bye(struct sip_pvt *p, struct sip_request *req);
01522 static int handle_request_register(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, char *e);
01523 static int handle_request_cancel(struct sip_pvt *p, struct sip_request *req);
01524 static int handle_request_message(struct sip_pvt *p, struct sip_request *req);
01525 static int handle_request_subscribe(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int seqno, char *e);
01526 static void handle_request_info(struct sip_pvt *p, struct sip_request *req);
01527 static int handle_request_options(struct sip_pvt *p, struct sip_request *req);
01528 static int handle_invite_replaces(struct sip_pvt *p, struct sip_request *req, int debug, int ignore, int seqno, struct sockaddr_in *sin);
01529 static int handle_request_notify(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int seqno, char *e);
01530 static int local_attended_transfer(struct sip_pvt *transferer, struct sip_dual *current, struct sip_request *req, int seqno);
01531
01532
01533 static void handle_response_invite(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int seqno);
01534 static void handle_response_refer(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int seqno);
01535 static int handle_response_register(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int ignore, int seqno);
01536 static void handle_response(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int ignore, int seqno);
01537
01538
01539 static int sip_set_rtp_peer(struct ast_channel *chan, struct ast_rtp *rtp, struct ast_rtp *vrtp, int codecs, int nat_active);
01540 static enum ast_rtp_get_result sip_get_rtp_peer(struct ast_channel *chan, struct ast_rtp **rtp);
01541 static enum ast_rtp_get_result sip_get_vrtp_peer(struct ast_channel *chan, struct ast_rtp **rtp);
01542 static int sip_get_codec(struct ast_channel *chan);
01543 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p, int *faxdetect);
01544
01545
01546 static int sip_handle_t38_reinvite(struct ast_channel *chan, struct sip_pvt *pvt, int reinvite);
01547 static int transmit_response_with_t38_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans);
01548 static int transmit_reinvite_with_t38_sdp(struct sip_pvt *p);
01549 static struct ast_udptl *sip_get_udptl_peer(struct ast_channel *chan);
01550 static int sip_set_udptl_peer(struct ast_channel *chan, struct ast_udptl *udptl);
01551
01552
01553 static const struct ast_channel_tech sip_tech = {
01554 .type = "SIP",
01555 .description = "Session Initiation Protocol (SIP)",
01556 .capabilities = ((AST_FORMAT_MAX_AUDIO << 1) - 1),
01557 .properties = AST_CHAN_TP_WANTSJITTER | AST_CHAN_TP_CREATESJITTER,
01558 .requester = sip_request_call,
01559 .devicestate = sip_devicestate,
01560 .call = sip_call,
01561 .hangup = sip_hangup,
01562 .answer = sip_answer,
01563 .read = sip_read,
01564 .write = sip_write,
01565 .write_video = sip_write,
01566 .indicate = sip_indicate,
01567 .transfer = sip_transfer,
01568 .fixup = sip_fixup,
01569 .send_digit_begin = sip_senddigit_begin,
01570 .send_digit_end = sip_senddigit_end,
01571 .bridge = ast_rtp_bridge,
01572 .send_text = sip_sendtext,
01573 .func_channel_read = acf_channel_read,
01574 };
01575
01576
01577
01578
01579 static const struct ast_channel_tech sip_tech_info = {
01580 .type = "SIP",
01581 .description = "Session Initiation Protocol (SIP)",
01582 .capabilities = ((AST_FORMAT_MAX_AUDIO << 1) - 1),
01583 .properties = AST_CHAN_TP_WANTSJITTER | AST_CHAN_TP_CREATESJITTER,
01584 .requester = sip_request_call,
01585 .devicestate = sip_devicestate,
01586 .call = sip_call,
01587 .hangup = sip_hangup,
01588 .answer = sip_answer,
01589 .read = sip_read,
01590 .write = sip_write,
01591 .write_video = sip_write,
01592 .indicate = sip_indicate,
01593 .transfer = sip_transfer,
01594 .fixup = sip_fixup,
01595 .send_digit_end = sip_senddigit_end,
01596 .bridge = ast_rtp_bridge,
01597 .send_text = sip_sendtext,
01598 .func_channel_read = acf_channel_read,
01599 };
01600
01601
01602
01603 #define UNLINK(element, head, prev) do { \
01604 if (prev) \
01605 (prev)->next = (element)->next; \
01606 else \
01607 (head) = (element)->next; \
01608 } while (0)
01609
01610
01611 static struct ast_rtp_protocol sip_rtp = {
01612 type: "SIP",
01613 get_rtp_info: sip_get_rtp_peer,
01614 get_vrtp_info: sip_get_vrtp_peer,
01615 set_rtp_peer: sip_set_rtp_peer,
01616 get_codec: sip_get_codec,
01617 };
01618
01619
01620 static struct ast_udptl_protocol sip_udptl = {
01621 type: "SIP",
01622 get_udptl_info: sip_get_udptl_peer,
01623 set_udptl_peer: sip_set_udptl_peer,
01624 };
01625
01626
01627 static char *referstatus2str(enum referstatus rstatus)
01628 {
01629 int i = (sizeof(referstatusstrings) / sizeof(referstatusstrings[0]));
01630 int x;
01631
01632 for (x = 0; x < i; x++) {
01633 if (referstatusstrings[x].status == rstatus)
01634 return (char *) referstatusstrings[x].text;
01635 }
01636 return "";
01637 }
01638
01639
01640
01641
01642 static void initialize_initreq(struct sip_pvt *p, struct sip_request *req)
01643 {
01644 if (p->initreq.headers && option_debug) {
01645 ast_log(LOG_DEBUG, "Initializing already initialized SIP dialog %s (presumably reinvite)\n", p->callid);
01646 }
01647
01648 copy_request(&p->initreq, req);
01649 parse_request(&p->initreq);
01650 if (ast_test_flag(req, SIP_PKT_DEBUG))
01651 ast_verbose("%d headers, %d lines\n", p->initreq.headers, p->initreq.lines);
01652 }
01653
01654 static void sip_alreadygone(struct sip_pvt *dialog)
01655 {
01656 if (option_debug > 2)
01657 ast_log(LOG_DEBUG, "Setting SIP_ALREADYGONE on dialog %s\n", dialog->callid);
01658 ast_set_flag(&dialog->flags[0], SIP_ALREADYGONE);
01659 }
01660
01661
01662
01663
01664
01665
01666
01667
01668 static int method_match(enum sipmethod id, const char *name)
01669 {
01670 int len = strlen(sip_methods[id].text);
01671 int l_name = name ? strlen(name) : 0;
01672
01673 return (l_name >= len && name[len] < 33 &&
01674 !strncasecmp(sip_methods[id].text, name, len));
01675 }
01676
01677
01678 static int find_sip_method(const char *msg)
01679 {
01680 int i, res = 0;
01681
01682 if (ast_strlen_zero(msg))
01683 return 0;
01684 for (i = 1; i < (sizeof(sip_methods) / sizeof(sip_methods[0])) && !res; i++) {
01685 if (method_match(i, msg))
01686 res = sip_methods[i].id;
01687 }
01688 return res;
01689 }
01690
01691
01692 static unsigned int parse_sip_options(struct sip_pvt *pvt, const char *supported)
01693 {
01694 char *next, *sep;
01695 char *temp;
01696 unsigned int profile = 0;
01697 int i, found;
01698
01699 if (ast_strlen_zero(supported) )
01700 return 0;
01701 temp = ast_strdupa(supported);
01702
01703 if (option_debug > 2 && sipdebug)
01704 ast_log(LOG_DEBUG, "Begin: parsing SIP \"Supported: %s\"\n", supported);
01705
01706 for (next = temp; next; next = sep) {
01707 found = FALSE;
01708 if ( (sep = strchr(next, ',')) != NULL)
01709 *sep++ = '\0';
01710 next = ast_skip_blanks(next);
01711 if (option_debug > 2 && sipdebug)
01712 ast_log(LOG_DEBUG, "Found SIP option: -%s-\n", next);
01713 for (i=0; i < (sizeof(sip_options) / sizeof(sip_options[0])); i++) {
01714 if (!strcasecmp(next, sip_options[i].text)) {
01715 profile |= sip_options[i].id;
01716 found = TRUE;
01717 if (option_debug > 2 && sipdebug)
01718 ast_log(LOG_DEBUG, "Matched SIP option: %s\n", next);
01719 break;
01720 }
01721 }
01722 if (!found && option_debug > 2 && sipdebug) {
01723 if (!strncasecmp(next, "x-", 2))
01724 ast_log(LOG_DEBUG, "Found private SIP option, not supported: %s\n", next);
01725 else
01726 ast_log(LOG_DEBUG, "Found no match for SIP option: %s (Please file bug report!)\n", next);
01727 }
01728 }
01729
01730 if (pvt)
01731 pvt->sipoptions = profile;
01732 return profile;
01733 }
01734
01735
01736 static inline int sip_debug_test_addr(const struct sockaddr_in *addr)
01737 {
01738 if (!sipdebug)
01739 return 0;
01740 if (debugaddr.sin_addr.s_addr) {
01741 if (((ntohs(debugaddr.sin_port) != 0)
01742 && (debugaddr.sin_port != addr->sin_port))
01743 || (debugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
01744 return 0;
01745 }
01746 return 1;
01747 }
01748
01749
01750 static const struct sockaddr_in *sip_real_dst(const struct sip_pvt *p)
01751 {
01752 return ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE ? &p->recv : &p->sa;
01753 }
01754
01755
01756 static const char *sip_nat_mode(const struct sip_pvt *p)
01757 {
01758 return ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE ? "NAT" : "no NAT";
01759 }
01760
01761
01762 static inline int sip_debug_test_pvt(struct sip_pvt *p)
01763 {
01764 if (!sipdebug)
01765 return 0;
01766 return sip_debug_test_addr(sip_real_dst(p));
01767 }
01768
01769
01770 static int __sip_xmit(struct sip_pvt *p, char *data, int len)
01771 {
01772 int res;
01773 const struct sockaddr_in *dst = sip_real_dst(p);
01774 res = sendto(sipsock, data, len, 0, (const struct sockaddr *)dst, sizeof(struct sockaddr_in));
01775
01776 if (res == -1) {
01777 switch (errno) {
01778 case EBADF:
01779 case EHOSTUNREACH:
01780 case ENETDOWN:
01781 case ENETUNREACH:
01782 case ECONNREFUSED:
01783 res = XMIT_ERROR;
01784 }
01785 }
01786 if (res != len)
01787 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));
01788 return res;
01789 }
01790
01791
01792
01793 static void build_via(struct sip_pvt *p)
01794 {
01795
01796 const char *rport = ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_RFC3581 ? ";rport" : "";
01797
01798
01799 ast_string_field_build(p, via, "SIP/2.0/UDP %s:%d;branch=z9hG4bK%08x%s",
01800 ast_inet_ntoa(p->ourip), ourport, p->branch, rport);
01801 }
01802
01803
01804
01805
01806
01807
01808
01809 static enum sip_result ast_sip_ouraddrfor(struct in_addr *them, struct in_addr *us)
01810 {
01811 struct sockaddr_in theirs, ours;
01812
01813
01814 ast_ouraddrfor(them, us);
01815 theirs.sin_addr = *them;
01816 ours.sin_addr = *us;
01817
01818 if (localaddr && externip.sin_addr.s_addr &&
01819 (ast_apply_ha(localaddr, &theirs)) &&
01820 (!global_matchexterniplocally || !ast_apply_ha(localaddr, &ours))) {
01821 if (externexpire && time(NULL) >= externexpire) {
01822 struct ast_hostent ahp;
01823 struct hostent *hp;
01824
01825 externexpire = time(NULL) + externrefresh;
01826 if ((hp = ast_gethostbyname(externhost, &ahp))) {
01827 memcpy(&externip.sin_addr, hp->h_addr, sizeof(externip.sin_addr));
01828 } else
01829 ast_log(LOG_NOTICE, "Warning: Re-lookup of '%s' failed!\n", externhost);
01830 }
01831 *us = externip.sin_addr;
01832 if (option_debug) {
01833 ast_log(LOG_DEBUG, "Target address %s is not local, substituting externip\n",
01834 ast_inet_ntoa(*(struct in_addr *)&them->s_addr));
01835 }
01836 } else if (bindaddr.sin_addr.s_addr)
01837 *us = bindaddr.sin_addr;
01838 return AST_SUCCESS;
01839 }
01840
01841
01842
01843 #define append_history(p, event, fmt , args... ) append_history_full(p, "%-15s " fmt, event, ## args)
01844
01845 static void append_history_full(struct sip_pvt *p, const char *fmt, ...)
01846 __attribute__ ((format (printf, 2, 3)));
01847
01848
01849 static void append_history_va(struct sip_pvt *p, const char *fmt, va_list ap)
01850 {
01851 char buf[80], *c = buf;
01852 struct sip_history *hist;
01853 int l;
01854
01855 vsnprintf(buf, sizeof(buf), fmt, ap);
01856 strsep(&c, "\r\n");
01857 l = strlen(buf) + 1;
01858 if (!(hist = ast_calloc(1, sizeof(*hist) + l)))
01859 return;
01860 if (!p->history && !(p->history = ast_calloc(1, sizeof(*p->history)))) {
01861 free(hist);
01862 return;
01863 }
01864 memcpy(hist->event, buf, l);
01865 if (p->history_entries == MAX_HISTORY_ENTRIES) {
01866 struct sip_history *oldest;
01867 oldest = AST_LIST_REMOVE_HEAD(p->history, list);
01868 p->history_entries--;
01869 free(oldest);
01870 }
01871 AST_LIST_INSERT_TAIL(p->history, hist, list);
01872 p->history_entries++;
01873 }
01874
01875
01876 static void append_history_full(struct sip_pvt *p, const char *fmt, ...)
01877 {
01878 va_list ap;
01879
01880 if (!p)
01881 return;
01882
01883 if (ast_test_flag(&p->flags[0], SIP_NO_HISTORY)
01884 && !recordhistory && !dumphistory) {
01885 return;
01886 }
01887
01888 va_start(ap, fmt);
01889 append_history_va(p, fmt, ap);
01890 va_end(ap);
01891
01892 return;
01893 }
01894
01895
01896 static int retrans_pkt(const void *data)
01897 {
01898 struct sip_pkt *pkt = (struct sip_pkt *)data, *prev, *cur = NULL;
01899 int reschedule = DEFAULT_RETRANS;
01900 int xmitres = 0;
01901
01902
01903 ast_mutex_lock(&pkt->owner->lock);
01904
01905 if (pkt->retrans < MAX_RETRANS) {
01906 pkt->retrans++;
01907 if (!pkt->timer_t1) {
01908 if (sipdebug && option_debug > 3)
01909 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);
01910 } else {
01911 int siptimer_a;
01912
01913 if (sipdebug && option_debug > 3)
01914 ast_log(LOG_DEBUG, "SIP TIMER: Rescheduling retransmission #%d (%d) %s - %d\n", pkt->retransid, pkt->retrans, sip_methods[pkt->method].text, pkt->method);
01915 if (!pkt->timer_a)
01916 pkt->timer_a = 2 ;
01917 else
01918 pkt->timer_a = 2 * pkt->timer_a;
01919
01920
01921 siptimer_a = pkt->timer_t1 * pkt->timer_a;
01922 if (pkt->method != SIP_INVITE && siptimer_a > 4000)
01923 siptimer_a = 4000;
01924
01925
01926 reschedule = siptimer_a;
01927 if (option_debug > 3)
01928 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);
01929 }
01930
01931 if (sip_debug_test_pvt(pkt->owner)) {
01932 const struct sockaddr_in *dst = sip_real_dst(pkt->owner);
01933 ast_verbose("Retransmitting #%d (%s) to %s:%d:\n%s\n---\n",
01934 pkt->retrans, sip_nat_mode(pkt->owner),
01935 ast_inet_ntoa(dst->sin_addr),
01936 ntohs(dst->sin_port), pkt->data);
01937 }
01938
01939 append_history(pkt->owner, "ReTx", "%d %s", reschedule, pkt->data);
01940 xmitres = __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
01941 ast_mutex_unlock(&pkt->owner->lock);
01942 if (xmitres == XMIT_ERROR)
01943 ast_log(LOG_WARNING, "Network error on retransmit in dialog %s\n", pkt->owner->callid);
01944 else
01945 return reschedule;
01946 }
01947
01948 if (pkt->owner && pkt->method != SIP_OPTIONS && xmitres == 0) {
01949 if (ast_test_flag(pkt, FLAG_FATAL) || sipdebug)
01950 ast_log(LOG_WARNING, "Maximum retries exceeded on transmission %s for seqno %d (%s %s)\n", pkt->owner->callid, pkt->seqno, (ast_test_flag(pkt, FLAG_FATAL)) ? "Critical" : "Non-critical", (ast_test_flag(pkt, FLAG_RESPONSE)) ? "Response" : "Request");
01951 } else if ((pkt->method == SIP_OPTIONS) && sipdebug) {
01952 ast_log(LOG_WARNING, "Cancelling retransmit of OPTIONs (call id %s) \n", pkt->owner->callid);
01953 }
01954 if (xmitres == XMIT_ERROR) {
01955 ast_log(LOG_WARNING, "Transmit error :: Cancelling transmission of transaction in call id %s \n", pkt->owner->callid);
01956 append_history(pkt->owner, "XmitErr", "%s", (ast_test_flag(pkt, FLAG_FATAL)) ? "(Critical)" : "(Non-critical)");
01957 } else
01958 append_history(pkt->owner, "MaxRetries", "%s", (ast_test_flag(pkt, FLAG_FATAL)) ? "(Critical)" : "(Non-critical)");
01959
01960 pkt->retransid = -1;
01961
01962 if (ast_test_flag(pkt, FLAG_FATAL)) {
01963 while(pkt->owner->owner && ast_channel_trylock(pkt->owner->owner)) {
01964 DEADLOCK_AVOIDANCE(&pkt->owner->lock);
01965 }
01966
01967 if (pkt->owner->owner && !pkt->owner->owner->hangupcause)
01968 pkt->owner->owner->hangupcause = AST_CAUSE_NO_USER_RESPONSE;
01969
01970 if (pkt->owner->owner) {
01971 sip_alreadygone(pkt->owner);
01972 ast_log(LOG_WARNING, "Hanging up call %s - no reply to our critical packet.\n", pkt->owner->callid);
01973 ast_queue_hangup(pkt->owner->owner);
01974 ast_channel_unlock(pkt->owner->owner);
01975 } else {
01976
01977
01978
01979 if (pkt->method != SIP_OPTIONS) {
01980 ast_set_flag(&pkt->owner->flags[0], SIP_NEEDDESTROY);
01981 sip_alreadygone(pkt->owner);
01982 if (option_debug)
01983 append_history(pkt->owner, "DialogKill", "Killing this failed dialog immediately");
01984 }
01985 }
01986 }
01987
01988 if (pkt->method == SIP_BYE) {
01989
01990 if (pkt->owner->owner)
01991 ast_channel_unlock(pkt->owner->owner);
01992 append_history(pkt->owner, "ByeFailure", "Remote peer doesn't respond to bye. Destroying call anyway.");
01993 ast_set_flag(&pkt->owner->flags[0], SIP_NEEDDESTROY);
01994 }
01995
01996
01997 for (prev = NULL, cur = pkt->owner->packets; cur; prev = cur, cur = cur->next) {
01998 if (cur == pkt)
01999 break;
02000 }
02001 if (cur) {
02002 if (prev)
02003 prev->next = cur->next;
02004 else
02005 pkt->owner->packets = cur->next;
02006 ast_mutex_unlock(&pkt->owner->lock);
02007 free(cur);
02008 pkt = NULL;
02009 } else
02010 ast_log(LOG_WARNING, "Weird, couldn't find packet owner!\n");
02011 if (pkt)
02012 ast_mutex_unlock(&pkt->owner->lock);
02013 return 0;
02014 }
02015
02016
02017
02018
02019 static enum sip_result __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, char *data, int len, int fatal, int sipmethod)
02020 {
02021 struct sip_pkt *pkt;
02022 int siptimer_a = DEFAULT_RETRANS;
02023 int xmitres = 0;
02024
02025 if (!(pkt = ast_calloc(1, sizeof(*pkt) + len + 1)))
02026 return AST_FAILURE;
02027 memcpy(pkt->data, data, len);
02028 pkt->method = sipmethod;
02029 pkt->packetlen = len;
02030 pkt->next = p->packets;
02031 pkt->owner = p;
02032 pkt->seqno = seqno;
02033 if (resp)
02034 ast_set_flag(pkt, FLAG_RESPONSE);
02035 pkt->data[len] = '\0';
02036 pkt->timer_t1 = p->timer_t1;
02037 pkt->retransid = -1;
02038 if (fatal)
02039 ast_set_flag(pkt, FLAG_FATAL);
02040 if (pkt->timer_t1)
02041 siptimer_a = pkt->timer_t1 * 2;
02042
02043 if (option_debug > 3 && sipdebug)
02044 ast_log(LOG_DEBUG, "*** SIP TIMER: Initializing retransmit timer on packet: Id #%d\n", pkt->retransid);
02045 pkt->retransid = -1;
02046 pkt->next = p->packets;
02047 p->packets = pkt;
02048 if (sipmethod == SIP_INVITE) {
02049
02050 p->pendinginvite = seqno;
02051 }
02052
02053 xmitres = __sip_xmit(pkt->owner, pkt->data, pkt->packetlen);
02054
02055 if (xmitres == XMIT_ERROR) {
02056 append_history(pkt->owner, "XmitErr", "%s", (ast_test_flag(pkt, FLAG_FATAL)) ? "(Critical)" : "(Non-critical)");
02057 return AST_FAILURE;
02058 } else {
02059
02060 pkt->retransid = ast_sched_add_variable(sched, siptimer_a, retrans_pkt, pkt, 1);
02061 return AST_SUCCESS;
02062 }
02063 }
02064
02065
02066 static int __sip_autodestruct(const void *data)
02067 {
02068 struct sip_pvt *p = (struct sip_pvt *)data;
02069
02070
02071 if (p->subscribed) {
02072 transmit_state_notify(p, AST_EXTENSION_DEACTIVATED, 1, TRUE);
02073 p->subscribed = NONE;
02074 append_history(p, "Subscribestatus", "timeout");
02075 if (option_debug > 2)
02076 ast_log(LOG_DEBUG, "Re-scheduled destruction of SIP subsription %s\n", p->callid ? p->callid : "<unknown>");
02077 return 10000;
02078 }
02079
02080
02081 if (p->packets) {
02082 if (option_debug > 2)
02083 ast_log(LOG_DEBUG, "Re-scheduled destruction of SIP call %s\n", p->callid ? p->callid : "<unknown>");
02084 append_history(p, "ReliableXmit", "timeout");
02085 return 10000;
02086 }
02087
02088
02089 if (p->subscribed == MWI_NOTIFICATION && p->relatedpeer)
02090 ASTOBJ_UNREF(p->relatedpeer,sip_destroy_peer);
02091
02092
02093 p->autokillid = -1;
02094
02095 if (option_debug)
02096 ast_log(LOG_DEBUG, "Auto destroying SIP dialog '%s'\n", p->callid);
02097 append_history(p, "AutoDestroy", "%s", p->callid);
02098 if (p->owner) {
02099 ast_log(LOG_WARNING, "Autodestruct on dialog '%s' with owner in place (Method: %s)\n", p->callid, sip_methods[p->method].text);
02100 ast_queue_hangup(p->owner);
02101 } else if (p->refer) {
02102 if (option_debug > 2)
02103 ast_log(LOG_DEBUG, "Finally hanging up channel after transfer: %s\n", p->callid);
02104 transmit_request_with_auth(p, SIP_BYE, 0, XMIT_RELIABLE, 1);
02105 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
02106 } else
02107 sip_destroy(p);
02108 return 0;
02109 }
02110
02111
02112 static void sip_scheddestroy(struct sip_pvt *p, int ms)
02113 {
02114 if (ms < 0) {
02115 if (p->timer_t1 == 0)
02116 p->timer_t1 = 500;
02117 ms = p->timer_t1 * 64;
02118 }
02119 if (sip_debug_test_pvt(p))
02120 ast_verbose("Scheduling destruction of SIP dialog '%s' in %d ms (Method: %s)\n", p->callid, ms, sip_methods[p->method].text);
02121 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
02122 append_history(p, "SchedDestroy", "%d ms", ms);
02123
02124 AST_SCHED_DEL(sched, p->autokillid);
02125 p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, p);
02126 }
02127
02128
02129 static int sip_cancel_destroy(struct sip_pvt *p)
02130 {
02131 int res = 0;
02132 if (p->autokillid > -1) {
02133 if (!(res = ast_sched_del(sched, p->autokillid))) {
02134 append_history(p, "CancelDestroy", "");
02135 p->autokillid = -1;
02136 }
02137 }
02138 return res;
02139 }
02140
02141
02142
02143 static void __sip_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
02144 {
02145 struct sip_pkt *cur, *prev = NULL;
02146
02147
02148 char *msg;
02149 int res = FALSE;
02150
02151 msg = sip_methods[sipmethod].text;
02152
02153 for (cur = p->packets; cur; prev = cur, cur = cur->next) {
02154 if ((cur->seqno == seqno) && ((ast_test_flag(cur, FLAG_RESPONSE)) == resp) &&
02155 ((ast_test_flag(cur, FLAG_RESPONSE)) ||
02156 (!strncasecmp(msg, cur->data, strlen(msg)) && (cur->data[strlen(msg)] < 33)))) {
02157 if (!resp && (seqno == p->pendinginvite)) {
02158 if (option_debug)
02159 ast_log(LOG_DEBUG, "Acked pending invite %d\n", p->pendinginvite);
02160 p->pendinginvite = 0;
02161 }
02162
02163 res = TRUE;
02164 UNLINK(cur, p->packets, prev);
02165 if (cur->retransid > -1) {
02166 if (sipdebug && option_debug > 3)
02167 ast_log(LOG_DEBUG, "** SIP TIMER: Cancelling retransmit of packet (reply received) Retransid #%d\n", cur->retransid);
02168 }
02169
02170
02171
02172
02173
02174
02175
02176
02177
02178
02179
02180
02181
02182
02183
02184
02185 while (cur->retransid > -1 && ast_sched_del(sched, cur->retransid)) {
02186 DEADLOCK_AVOIDANCE(&p->lock);
02187 }
02188 free(cur);
02189 break;
02190 }
02191 }
02192 if (option_debug)
02193 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");
02194 }
02195
02196
02197
02198 static void __sip_pretend_ack(struct sip_pvt *p)
02199 {
02200 struct sip_pkt *cur = NULL;
02201
02202 while (p->packets) {
02203 int method;
02204 if (cur == p->packets) {
02205 ast_log(LOG_WARNING, "Have a packet that doesn't want to give up! %s\n", sip_methods[cur->method].text);
02206 return;
02207 }
02208 cur = p->packets;
02209 method = (cur->method) ? cur->method : find_sip_method(cur->data);
02210 __sip_ack(p, cur->seqno, ast_test_flag(cur, FLAG_RESPONSE), method);
02211 }
02212 }
02213
02214
02215 static int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
02216 {
02217 struct sip_pkt *cur;
02218 int res = -1;
02219
02220 for (cur = p->packets; cur; cur = cur->next) {
02221 if (cur->seqno == seqno && ast_test_flag(cur, FLAG_RESPONSE) == resp &&
02222 (ast_test_flag(cur, FLAG_RESPONSE) || method_match(sipmethod, cur->data))) {
02223
02224 if (cur->retransid > -1) {
02225 if (option_debug > 3 && sipdebug)
02226 ast_log(LOG_DEBUG, "*** SIP TIMER: Cancelling retransmission #%d - %s (got response)\n", cur->retransid, sip_methods[sipmethod].text);
02227 }
02228 AST_SCHED_DEL(sched, cur->retransid);
02229 res = 0;
02230 break;
02231 }
02232 }
02233 if (option_debug)
02234 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");
02235 return res;
02236 }
02237
02238
02239
02240 static void parse_copy(struct sip_request *dst, const struct sip_request *src)
02241 {
02242 memset(dst, 0, sizeof(*dst));
02243 memcpy(dst->data, src->data, sizeof(dst->data));
02244 dst->len = src->len;
02245 parse_request(dst);
02246 }
02247
02248
02249 static void add_blank(struct sip_request *req)
02250 {
02251 if (!req->lines) {
02252
02253 snprintf(req->data + req->len, sizeof(req->data) - req->len, "\r\n");
02254 req->len += strlen(req->data + req->len);
02255 }
02256 }
02257
02258
02259 static int send_response(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno)
02260 {
02261 int res;
02262
02263 add_blank(req);
02264 if (sip_debug_test_pvt(p)) {
02265 const struct sockaddr_in *dst = sip_real_dst(p);
02266
02267 ast_verbose("\n<--- %sTransmitting (%s) to %s:%d --->\n%s\n<------------>\n",
02268 reliable ? "Reliably " : "", sip_nat_mode(p),
02269 ast_inet_ntoa(dst->sin_addr),
02270 ntohs(dst->sin_port), req->data);
02271 }
02272 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY)) {
02273 struct sip_request tmp;
02274 parse_copy(&tmp, req);
02275 append_history(p, reliable ? "TxRespRel" : "TxResp", "%s / %s - %s", tmp.data, get_header(&tmp, "CSeq"),
02276 (tmp.method == SIP_RESPONSE || tmp.method == SIP_UNKNOWN) ? tmp.rlPart2 : sip_methods[tmp.method].text);
02277 }
02278 res = (reliable) ?
02279 __sip_reliable_xmit(p, seqno, 1, req->data, req->len, (reliable == XMIT_CRITICAL), req->method) :
02280 __sip_xmit(p, req->data, req->len);
02281 if (res > 0)
02282 return 0;
02283 return res;
02284 }
02285
02286
02287 static int send_request(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno)
02288 {
02289 int res;
02290
02291 add_blank(req);
02292 if (sip_debug_test_pvt(p)) {
02293 if (ast_test_flag(&p->flags[0], SIP_NAT_ROUTE))
02294 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);
02295 else
02296 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);
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 ? "TxReqRel" : "TxReq", "%s / %s - %s", tmp.data, get_header(&tmp, "CSeq"), sip_methods[tmp.method].text);
02302 }
02303 res = (reliable) ?
02304 __sip_reliable_xmit(p, seqno, 0, req->data, req->len, (reliable == XMIT_CRITICAL), req->method) :
02305 __sip_xmit(p, req->data, req->len);
02306 return res;
02307 }
02308
02309
02310
02311
02312
02313 static const char *find_closing_quote(const char *start, const char *lim)
02314 {
02315 char last_char = '\0';
02316 const char *s;
02317 for (s = start; *s && s != lim; last_char = *s++) {
02318 if (*s == '"' && last_char != '\\')
02319 break;
02320 }
02321 return s;
02322 }
02323
02324
02325
02326
02327
02328
02329
02330
02331
02332
02333
02334
02335 static char *get_in_brackets(char *tmp)
02336 {
02337 const char *parse = tmp;
02338 char *first_bracket;
02339
02340
02341
02342
02343
02344 while ( (first_bracket = strchr(parse, '<')) ) {
02345 char *first_quote = strchr(parse, '"');
02346
02347 if (!first_quote || first_quote > first_bracket)
02348 break;
02349
02350 parse = find_closing_quote(first_quote + 1, NULL);
02351 if (!*parse) {
02352
02353 ast_log(LOG_WARNING, "No closing quote found in '%s'\n", tmp);
02354 break;
02355 }
02356 parse++;
02357 }
02358 if (first_bracket) {
02359 char *second_bracket = strchr(first_bracket + 1, '>');
02360 if (second_bracket) {
02361 *second_bracket = '\0';
02362 tmp = first_bracket + 1;
02363 } else {
02364 ast_log(LOG_WARNING, "No closing bracket found in '%s'\n", tmp);
02365 }
02366 }
02367 return tmp;
02368 }
02369
02370
02371
02372 static int sip_sendtext(struct ast_channel *ast, const char *text)
02373 {
02374 struct sip_pvt *p = ast->tech_pvt;
02375 int debug = sip_debug_test_pvt(p);
02376
02377 if (debug)
02378 ast_verbose("Sending text %s on %s\n", text, ast->name);
02379 if (!p)
02380 return -1;
02381 if (ast_strlen_zero(text))
02382 return 0;
02383 if (debug)
02384 ast_verbose("Really sending text %s on %s\n", text, ast->name);
02385 transmit_message_with_text(p, text);
02386 return 0;
02387 }
02388
02389
02390
02391
02392
02393
02394 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, const char *username, const char *fullcontact, int expirey)
02395 {
02396 char port[10];
02397 char ipaddr[INET_ADDRSTRLEN];
02398 char regseconds[20];
02399
02400 char *sysname = ast_config_AST_SYSTEM_NAME;
02401 char *syslabel = NULL;
02402
02403 time_t nowtime = time(NULL) + expirey;
02404 const char *fc = fullcontact ? "fullcontact" : NULL;
02405
02406 snprintf(regseconds, sizeof(regseconds), "%d", (int)nowtime);
02407 ast_copy_string(ipaddr, ast_inet_ntoa(sin->sin_addr), sizeof(ipaddr));
02408 snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
02409
02410 if (ast_strlen_zero(sysname))
02411 sysname = NULL;
02412 else if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTSAVE_SYSNAME))
02413 syslabel = "regserver";
02414
02415 if (fc)
02416 ast_update_realtime("sippeers", "name", peername, "ipaddr", ipaddr,
02417 "port", port, "regseconds", regseconds,
02418 "username", username, fc, fullcontact, syslabel, sysname, NULL);
02419 else
02420 ast_update_realtime("sippeers", "name", peername, "ipaddr", ipaddr,
02421 "port", port, "regseconds", regseconds,
02422 "username", username, syslabel, sysname, NULL);
02423 }
02424
02425
02426 static void register_peer_exten(struct sip_peer *peer, int onoff)
02427 {
02428 char multi[256];
02429 char *stringp, *ext, *context;
02430
02431
02432
02433
02434
02435 if (ast_strlen_zero(global_regcontext))
02436 return;
02437
02438 ast_copy_string(multi, S_OR(peer->regexten, peer->name), sizeof(multi));
02439 stringp = multi;
02440 while ((ext = strsep(&stringp, "&"))) {
02441 if ((context = strchr(ext, '@'))) {
02442 *context++ = '\0';
02443 if (!ast_context_find(context)) {
02444 ast_log(LOG_WARNING, "Context %s must exist in regcontext= in sip.conf!\n", context);
02445 continue;
02446 }
02447 } else {
02448 context = global_regcontext;
02449 }
02450 if (onoff)
02451 ast_add_extension(context, 1, ext, 1, NULL, NULL, "Noop",
02452 ast_strdup(peer->name), ast_free, "SIP");
02453 else
02454 ast_context_remove_extension(context, ext, 1, NULL);
02455 }
02456 }
02457
02458
02459 static void sip_destroy_peer(struct sip_peer *peer)
02460 {
02461 if (option_debug > 2)
02462 ast_log(LOG_DEBUG, "Destroying SIP peer %s\n", peer->name);
02463
02464
02465 if (peer->call)
02466 sip_destroy(peer->call);
02467
02468 if (peer->mwipvt)
02469 sip_destroy(peer->mwipvt);
02470
02471 if (peer->chanvars) {
02472 ast_variables_destroy(peer->chanvars);
02473 peer->chanvars = NULL;
02474 }
02475
02476 register_peer_exten(peer, FALSE);
02477 ast_free_ha(peer->ha);
02478 if (ast_test_flag(&peer->flags[1], SIP_PAGE2_SELFDESTRUCT))
02479 apeerobjs--;
02480 else if (ast_test_flag(&peer->flags[0], SIP_REALTIME))
02481 rpeerobjs--;
02482 else
02483 speerobjs--;
02484 clear_realm_authentication(peer->auth);
02485 peer->auth = NULL;
02486 free(peer);
02487 }
02488
02489
02490 static void update_peer(struct sip_peer *p, int expiry)
02491 {
02492 int rtcachefriends = ast_test_flag(&p->flags[1], SIP_PAGE2_RTCACHEFRIENDS);
02493 if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTUPDATE) &&
02494 (ast_test_flag(&p->flags[0], SIP_REALTIME) || rtcachefriends)) {
02495 realtime_update_peer(p->name, &p->addr, p->username, rtcachefriends ? p->fullcontact : NULL, expiry);
02496 }
02497 }
02498
02499
02500
02501
02502
02503
02504
02505 static struct sip_peer *realtime_peer(const char *newpeername, struct sockaddr_in *sin)
02506 {
02507 struct sip_peer *peer=NULL;
02508 struct ast_variable *var = NULL;
02509 struct ast_config *peerlist = NULL;
02510 struct ast_variable *tmp;
02511 struct ast_flags flags = {0};
02512 const char *iabuf = NULL;
02513 char portstring[6];
02514 const char *insecure;
02515 char *cat = NULL;
02516 unsigned short portnum;
02517
02518
02519 if (newpeername) {
02520 var = ast_load_realtime("sippeers", "name", newpeername, "host", "dynamic", NULL);
02521 if (!var && sin)
02522 var = ast_load_realtime("sippeers", "name", newpeername, "host", ast_inet_ntoa(sin->sin_addr), NULL);
02523 if (!var) {
02524 var = ast_load_realtime("sippeers", "name", newpeername, NULL);
02525
02526
02527
02528
02529
02530
02531 if (var && sin) {
02532 for (tmp = var; tmp; tmp = tmp->next) {
02533 if (!strcasecmp(tmp->name, "host")) {
02534 struct hostent *hp;
02535 struct ast_hostent ahp;
02536 if (!(hp = ast_gethostbyname(tmp->value, &ahp)) || (memcmp(&hp->h_addr, &sin->sin_addr, sizeof(hp->h_addr)))) {
02537
02538 ast_variables_destroy(var);
02539 var = NULL;
02540 }
02541 break;
02542 }
02543 }
02544 }
02545 }
02546 }
02547
02548 if (!var && sin) {
02549 iabuf = ast_inet_ntoa(sin->sin_addr);
02550 portnum = ntohs(sin->sin_port);
02551 sprintf(portstring, "%d", portnum);
02552 var = ast_load_realtime("sippeers", "host", iabuf, "port", portstring, NULL);
02553 if (!var)
02554 var = ast_load_realtime("sippeers", "ipaddr", iabuf, "port", portstring, NULL);
02555 if (!var) {
02556 peerlist = ast_load_realtime_multientry("sippeers", "host", iabuf, NULL);
02557 if(peerlist){
02558 while((cat = ast_category_browse(peerlist, cat)))
02559 {
02560 insecure = ast_variable_retrieve(peerlist, cat, "insecure");
02561 set_insecure_flags(&flags, insecure, -1);
02562 if(ast_test_flag(&flags, SIP_INSECURE_PORT)) {
02563 var = ast_category_root(peerlist, cat);
02564 break;
02565 }
02566 }
02567 }
02568 if(!var) {
02569 ast_config_destroy(peerlist);
02570 peerlist = NULL;
02571 cat = NULL;
02572 peerlist = ast_load_realtime_multientry("sippeers", "ipaddr", iabuf, NULL);
02573 if(peerlist) {
02574 while((cat = ast_category_browse(peerlist, cat)))
02575 {
02576 insecure = ast_variable_retrieve(peerlist, cat, "insecure");
02577 set_insecure_flags(&flags, insecure, -1);
02578 if(ast_test_flag(&flags, SIP_INSECURE_PORT)) {
02579 var = ast_category_root(peerlist, cat);
02580 break;
02581 }
02582 }
02583 }
02584 }
02585 }
02586 }
02587
02588 if (!var) {
02589 if(peerlist)
02590 ast_config_destroy(peerlist);
02591 return NULL;
02592 }
02593
02594 for (tmp = var; tmp; tmp = tmp->next) {
02595
02596 if (!strcasecmp(tmp->name, "type") &&
02597 !strcasecmp(tmp->value, "user")) {
02598 ast_variables_destroy(var);
02599 return NULL;
02600 } else if (!newpeername && !strcasecmp(tmp->name, "name")) {
02601 newpeername = tmp->value;
02602 }
02603 }
02604
02605 if (!newpeername) {
02606 ast_log(LOG_WARNING, "Cannot Determine peer name ip=%s\n", iabuf);
02607 if(peerlist)
02608 ast_config_destroy(peerlist);
02609 else
02610 ast_variables_destroy(var);
02611 return NULL;
02612 }
02613
02614
02615 peer = build_peer(newpeername, var, NULL, 1);
02616 if (!peer) {
02617 if(peerlist)
02618 ast_config_destroy(peerlist);
02619 else
02620 ast_variables_destroy(var);
02621 return NULL;
02622 }
02623
02624 if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
02625
02626 ast_copy_flags(&peer->flags[1],&global_flags[1], SIP_PAGE2_RTAUTOCLEAR|SIP_PAGE2_RTCACHEFRIENDS);
02627 if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTAUTOCLEAR)) {
02628 if (!AST_SCHED_DEL(sched, peer->expire)) {
02629 struct sip_peer *peer_ptr = peer;
02630 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
02631 }
02632 peer->expire = ast_sched_add(sched, (global_rtautoclear) * 1000, expire_register, ASTOBJ_REF(peer));
02633 if (peer->expire == -1) {
02634 struct sip_peer *peer_ptr = peer;
02635 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
02636 }
02637 }
02638 ASTOBJ_CONTAINER_LINK(&peerl,peer);
02639 } else {
02640 ast_set_flag(&peer->flags[0], SIP_REALTIME);
02641 }
02642 if(peerlist)
02643 ast_config_destroy(peerlist);
02644 else
02645 ast_variables_destroy(var);
02646 return peer;
02647 }
02648
02649
02650 static int sip_addrcmp(char *name, struct sockaddr_in *sin)
02651 {
02652
02653 struct sip_peer *p = (struct sip_peer *) name;
02654 return !(!inaddrcmp(&p->addr, sin) ||
02655 (ast_test_flag(&p->flags[0], SIP_INSECURE_PORT) &&
02656 (p->addr.sin_addr.s_addr == sin->sin_addr.s_addr)));
02657 }
02658
02659
02660
02661
02662 static struct sip_peer *find_peer(const char *peer, struct sockaddr_in *sin, int realtime)
02663 {
02664 struct sip_peer *p = NULL;
02665
02666 if (peer)
02667 p = ASTOBJ_CONTAINER_FIND(&peerl, peer);
02668 else
02669 p = ASTOBJ_CONTAINER_FIND_FULL(&peerl, sin, name, sip_addr_hashfunc, 1, sip_addrcmp);
02670
02671 if (!p && realtime)
02672 p = realtime_peer(peer, sin);
02673
02674 return p;
02675 }
02676
02677
02678 static void sip_destroy_user(struct sip_user *user)
02679 {
02680 if (option_debug > 2)
02681 ast_log(LOG_DEBUG, "Destroying user object from memory: %s\n", user->name);
02682 ast_free_ha(user->ha);
02683 if (user->chanvars) {
02684 ast_variables_destroy(user->chanvars);
02685 user->chanvars = NULL;
02686 }
02687 if (ast_test_flag(&user->flags[0], SIP_REALTIME))
02688 ruserobjs--;
02689 else
02690 suserobjs--;
02691 free(user);
02692 }
02693
02694
02695
02696
02697 static struct sip_user *realtime_user(const char *username)
02698 {
02699 struct ast_variable *var;
02700 struct ast_variable *tmp;
02701 struct sip_user *user = NULL;
02702
02703 var = ast_load_realtime("sipusers", "name", username, NULL);
02704
02705 if (!var)
02706 return NULL;
02707
02708 for (tmp = var; tmp; tmp = tmp->next) {
02709 if (!strcasecmp(tmp->name, "type") &&
02710 !strcasecmp(tmp->value, "peer")) {
02711 ast_variables_destroy(var);
02712 return NULL;
02713 }
02714 }
02715
02716 user = build_user(username, var, NULL, !ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS));
02717
02718 if (!user) {
02719 ast_variables_destroy(var);
02720 return NULL;
02721 }
02722
02723 if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
02724 ast_set_flag(&user->flags[1], SIP_PAGE2_RTCACHEFRIENDS);
02725 suserobjs++;
02726 ASTOBJ_CONTAINER_LINK(&userl,user);
02727 } else {
02728
02729 suserobjs--;
02730 ruserobjs++;
02731 ast_set_flag(&user->flags[0], SIP_REALTIME);
02732 }
02733 ast_variables_destroy(var);
02734 return user;
02735 }
02736
02737
02738
02739
02740
02741 static struct sip_user *find_user(const char *name, int realtime)
02742 {
02743 struct sip_user *u = ASTOBJ_CONTAINER_FIND(&userl, name);
02744 if (!u && realtime)
02745 u = realtime_user(name);
02746 return u;
02747 }
02748
02749
02750 static void do_setnat(struct sip_pvt *p, int natflags)
02751 {
02752 const char *mode = natflags ? "On" : "Off";
02753
02754 if (p->rtp) {
02755 if (option_debug)
02756 ast_log(LOG_DEBUG, "Setting NAT on RTP to %s\n", mode);
02757 ast_rtp_setnat(p->rtp, natflags);
02758 }
02759 if (p->vrtp) {
02760 if (option_debug)
02761 ast_log(LOG_DEBUG, "Setting NAT on VRTP to %s\n", mode);
02762 ast_rtp_setnat(p->vrtp, natflags);
02763 }
02764 if (p->udptl) {
02765 if (option_debug)
02766 ast_log(LOG_DEBUG, "Setting NAT on UDPTL to %s\n", mode);
02767 ast_udptl_setnat(p->udptl, natflags);
02768 }
02769 }
02770
02771
02772
02773
02774 static int create_addr_from_peer(struct sip_pvt *dialog, struct sip_peer *peer)
02775 {
02776 if ((peer->addr.sin_addr.s_addr || peer->defaddr.sin_addr.s_addr) &&
02777 (!peer->maxms || ((peer->lastms >= 0) && (peer->lastms <= peer->maxms)))) {
02778 dialog->sa = (peer->addr.sin_addr.s_addr) ? peer->addr : peer->defaddr;
02779 dialog->recv = dialog->sa;
02780 } else
02781 return -1;
02782
02783 ast_copy_flags(&dialog->flags[0], &peer->flags[0], SIP_FLAGS_TO_COPY);
02784 ast_copy_flags(&dialog->flags[1], &peer->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
02785 dialog->capability = peer->capability;
02786 if ((!ast_test_flag(&dialog->flags[1], SIP_PAGE2_VIDEOSUPPORT) || !(dialog->capability & AST_FORMAT_VIDEO_MASK)) && dialog->vrtp) {
02787 ast_rtp_destroy(dialog->vrtp);
02788 dialog->vrtp = NULL;
02789 }
02790 dialog->prefs = peer->prefs;
02791 if (ast_test_flag(&dialog->flags[1], SIP_PAGE2_T38SUPPORT)) {
02792 dialog->t38.capability = global_t38_capability;
02793 if (dialog->udptl) {
02794 if (ast_udptl_get_error_correction_scheme(dialog->udptl) == UDPTL_ERROR_CORRECTION_FEC )
02795 dialog->t38.capability |= T38FAX_UDP_EC_FEC;
02796 else if (ast_udptl_get_error_correction_scheme(dialog->udptl) == UDPTL_ERROR_CORRECTION_REDUNDANCY )
02797 dialog->t38.capability |= T38FAX_UDP_EC_REDUNDANCY;
02798 else if (ast_udptl_get_error_correction_scheme(dialog->udptl) == UDPTL_ERROR_CORRECTION_NONE )
02799 dialog->t38.capability |= T38FAX_UDP_EC_NONE;
02800 dialog->t38.capability |= T38FAX_RATE_MANAGEMENT_TRANSFERED_TCF;
02801 if (option_debug > 1)
02802 ast_log(LOG_DEBUG,"Our T38 capability (%d)\n", dialog->t38.capability);
02803 }
02804 dialog->t38.jointcapability = dialog->t38.capability;
02805 } else if (dialog->udptl) {
02806 ast_udptl_destroy(dialog->udptl);
02807 dialog->udptl = NULL;
02808 }
02809 do_setnat(dialog, ast_test_flag(&dialog->flags[0], SIP_NAT) & SIP_NAT_ROUTE );
02810
02811 if (dialog->rtp) {
02812 ast_rtp_setdtmf(dialog->rtp, ast_test_flag(&dialog->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833);
02813 ast_rtp_setdtmfcompensate(dialog->rtp, ast_test_flag(&dialog->flags[1], SIP_PAGE2_RFC2833_COMPENSATE));
02814 ast_rtp_set_rtptimeout(dialog->rtp, peer->rtptimeout);
02815 ast_rtp_set_rtpholdtimeout(dialog->rtp, peer->rtpholdtimeout);
02816 ast_rtp_set_rtpkeepalive(dialog->rtp, peer->rtpkeepalive);
02817
02818 ast_rtp_codec_setpref(dialog->rtp, &dialog->prefs);
02819 dialog->autoframing = peer->autoframing;
02820 }
02821 if (dialog->vrtp) {
02822 ast_rtp_setdtmf(dialog->vrtp, 0);
02823 ast_rtp_setdtmfcompensate(dialog->vrtp, 0);
02824 ast_rtp_set_rtptimeout(dialog->vrtp, peer->rtptimeout);
02825 ast_rtp_set_rtpholdtimeout(dialog->vrtp, peer->rtpholdtimeout);
02826 ast_rtp_set_rtpkeepalive(dialog->vrtp, peer->rtpkeepalive);
02827 }
02828
02829 ast_string_field_set(dialog, peername, peer->name);
02830 ast_string_field_set(dialog, authname, peer->username);
02831 ast_string_field_set(dialog, username, peer->username);
02832 ast_string_field_set(dialog, peersecret, peer->secret);
02833 ast_string_field_set(dialog, peermd5secret, peer->md5secret);
02834 ast_string_field_set(dialog, mohsuggest, peer->mohsuggest);
02835 ast_string_field_set(dialog, mohinterpret, peer->mohinterpret);
02836 ast_string_field_set(dialog, tohost, peer->tohost);
02837 ast_string_field_set(dialog, fullcontact, peer->fullcontact);
02838 if (!dialog->initreq.headers && !ast_strlen_zero(peer->fromdomain)) {
02839 char *tmpcall;
02840 char *c;
02841 tmpcall = ast_strdupa(dialog->callid);
02842 c = strchr(tmpcall, '@');
02843 if (c) {
02844 *c = '\0';
02845 ast_string_field_build(dialog, callid, "%s@%s", tmpcall, peer->fromdomain);
02846 }
02847 }
02848 if (ast_strlen_zero(dialog->tohost))
02849 ast_string_field_set(dialog, tohost, ast_inet_ntoa(dialog->sa.sin_addr));
02850 if (!ast_strlen_zero(peer->fromdomain))
02851 ast_string_field_set(dialog, fromdomain, peer->fromdomain);
02852 if (!ast_strlen_zero(peer->fromuser))
02853 ast_string_field_set(dialog, fromuser, peer->fromuser);
02854 if (!ast_strlen_zero(peer->language))
02855 ast_string_field_set(dialog, language, peer->language);
02856 dialog->maxtime = peer->maxms;
02857 dialog->callgroup = peer->callgroup;
02858 dialog->pickupgroup = peer->pickupgroup;
02859 dialog->allowtransfer = peer->allowtransfer;
02860
02861
02862 if (peer->maxms && peer->lastms)
02863 dialog->timer_t1 = peer->lastms < global_t1min ? global_t1min : peer->lastms;
02864 if ((ast_test_flag(&dialog->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
02865 (ast_test_flag(&dialog->flags[0], SIP_DTMF) == SIP_DTMF_AUTO))
02866 dialog->noncodeccapability |= AST_RTP_DTMF;
02867 else
02868 dialog->noncodeccapability &= ~AST_RTP_DTMF;
02869 dialog->jointnoncodeccapability = dialog->noncodeccapability;
02870 ast_string_field_set(dialog, context, peer->context);
02871 dialog->rtptimeout = peer->rtptimeout;
02872 if (peer->call_limit)
02873 ast_set_flag(&dialog->flags[0], SIP_CALL_LIMIT);
02874 dialog->maxcallbitrate = peer->maxcallbitrate;
02875
02876 return 0;
02877 }
02878
02879
02880
02881
02882 static int create_addr(struct sip_pvt *dialog, const char *opeer)
02883 {
02884 struct hostent *hp;
02885 struct ast_hostent ahp;
02886 struct sip_peer *p;
02887 char *port;
02888 int portno;
02889 char host[MAXHOSTNAMELEN], *hostn;
02890 char peer[256];
02891
02892 ast_copy_string(peer, opeer, sizeof(peer));
02893 port = strchr(peer, ':');
02894 if (port)
02895 *port++ = '\0';
02896 dialog->sa.sin_family = AF_INET;
02897 dialog->timer_t1 = 500;
02898 p = find_peer(peer, NULL, 1);
02899
02900 if (p) {
02901 int res = create_addr_from_peer(dialog, p);
02902 ASTOBJ_UNREF(p, sip_destroy_peer);
02903 return res;
02904 }
02905 hostn = peer;
02906 portno = port ? atoi(port) : STANDARD_SIP_PORT;
02907 if (srvlookup) {
02908 char service[MAXHOSTNAMELEN];
02909 int tportno;
02910 int ret;
02911
02912 snprintf(service, sizeof(service), "_sip._udp.%s", peer);
02913 ret = ast_get_srv(NULL, host, sizeof(host), &tportno, service);
02914 if (ret > 0) {
02915 hostn = host;
02916 portno = tportno;
02917 }
02918 }
02919 hp = ast_gethostbyname(hostn, &ahp);
02920 if (!hp) {
02921 ast_log(LOG_WARNING, "No such host: %s\n", peer);
02922 return -1;
02923 }
02924 ast_string_field_set(dialog, tohost, peer);
02925 memcpy(&dialog->sa.sin_addr, hp->h_addr, sizeof(dialog->sa.sin_addr));
02926 dialog->sa.sin_port = htons(portno);
02927 dialog->recv = dialog->sa;
02928 return 0;
02929 }
02930
02931
02932 static int auto_congest(const void *nothing)
02933 {
02934 struct sip_pvt *p = (struct sip_pvt *)nothing;
02935
02936 ast_mutex_lock(&p->lock);
02937 p->initid = -1;
02938 if (p->owner) {
02939
02940 if (!ast_channel_trylock(p->owner)) {
02941 ast_log(LOG_NOTICE, "Auto-congesting %s\n", p->owner->name);
02942 append_history(p, "Cong", "Auto-congesting (timer)");
02943 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
02944 ast_channel_unlock(p->owner);
02945 }
02946 }
02947 ast_mutex_unlock(&p->lock);
02948 return 0;
02949 }
02950
02951
02952
02953
02954 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
02955 {
02956 int res, xmitres = 0;
02957 struct sip_pvt *p;
02958 struct varshead *headp;
02959 struct ast_var_t *current;
02960 const char *referer = NULL;
02961
02962 p = ast->tech_pvt;
02963 if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
02964 ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
02965 return -1;
02966 }
02967
02968
02969 headp=&ast->varshead;
02970 AST_LIST_TRAVERSE(headp,current,entries) {
02971
02972 if (!p->options->vxml_url && !strcasecmp(ast_var_name(current), "VXML_URL")) {
02973 p->options->vxml_url = ast_var_value(current);
02974 } else if (!p->options->uri_options && !strcasecmp(ast_var_name(current), "SIP_URI_OPTIONS")) {
02975 p->options->uri_options = ast_var_value(current);
02976 } else if (!p->options->distinctive_ring && !strcasecmp(ast_var_name(current), "ALERT_INFO")) {
02977
02978 p->options->distinctive_ring = ast_var_value(current);
02979 } else if (!p->options->addsipheaders && !strncasecmp(ast_var_name(current), "SIPADDHEADER", strlen("SIPADDHEADER"))) {
02980
02981 p->options->addsipheaders = 1;
02982 } else if (!strcasecmp(ast_var_name(current), "SIPTRANSFER")) {
02983
02984 p->options->transfer = 1;
02985 } else if (!strcasecmp(ast_var_name(current), "SIPTRANSFER_REFERER")) {
02986
02987 referer = ast_var_value(current);
02988 } else if (!strcasecmp(ast_var_name(current), "SIPTRANSFER_REPLACES")) {
02989
02990 p->options->replaces = ast_var_value(current);
02991 } else if (!strcasecmp(ast_var_name(current), "T38CALL")) {
02992 p->t38.state = T38_LOCAL_DIRECT;
02993 if (option_debug)
02994 ast_log(LOG_DEBUG,"T38State change to %d on channel %s\n", p->t38.state, ast->name);
02995 }
02996
02997 }
02998
02999 res = 0;
03000 ast_set_flag(&p->flags[0], SIP_OUTGOING);
03001
03002 if (p->options->transfer) {
03003 char buf[SIPBUFSIZE/2];
03004
03005 if (referer) {
03006 if (sipdebug && option_debug > 2)
03007 ast_log(LOG_DEBUG, "Call for %s transfered by %s\n", p->username, referer);
03008 snprintf(buf, sizeof(buf)-1, "-> %s (via %s)", p->cid_name, referer);
03009 } else
03010 snprintf(buf, sizeof(buf)-1, "-> %s", p->cid_name);
03011 ast_string_field_set(p, cid_name, buf);
03012 }
03013 if (option_debug)
03014 ast_log(LOG_DEBUG, "Outgoing Call for %s\n", p->username);
03015
03016 res = update_call_counter(p, INC_CALL_RINGING);
03017 if ( res != -1 ) {
03018 p->callingpres = ast->cid.cid_pres;
03019 p->jointcapability = ast_translate_available_formats(p->capability, p->prefcodec);
03020 p->jointnoncodeccapability = p->noncodeccapability;
03021
03022
03023 if (!(p->jointcapability & AST_FORMAT_AUDIO_MASK)) {
03024 ast_log(LOG_WARNING, "No audio format found to offer. Cancelling call to %s\n", p->username);
03025 res = -1;
03026 } else {
03027 p->t38.jointcapability = p->t38.capability;
03028 if (option_debug > 1)
03029 ast_log(LOG_DEBUG,"Our T38 capability (%d), joint T38 capability (%d)\n", p->t38.capability, p->t38.jointcapability);
03030 xmitres = transmit_invite(p, SIP_INVITE, 1, 2);
03031 if (xmitres == XMIT_ERROR)
03032 return -1;
03033
03034 p->invitestate = INV_CALLING;
03035
03036
03037 AST_SCHED_DEL(sched, p->initid);
03038 p->initid = ast_sched_add(sched, p->maxtime ? (p->maxtime * 4) : SIP_TRANS_TIMEOUT, auto_congest, p);
03039 }
03040 }
03041 return res;
03042 }
03043
03044
03045
03046 static void sip_registry_destroy(struct sip_registry *reg)
03047 {
03048
03049 if (option_debug > 2)
03050 ast_log(LOG_DEBUG, "Destroying registry entry for %s@%s\n", reg->username, reg->hostname);
03051
03052 if (reg->call) {
03053
03054
03055 reg->call->registry = NULL;
03056 if (option_debug > 2)
03057 ast_log(LOG_DEBUG, "Destroying active SIP dialog for registry %s@%s\n", reg->username, reg->hostname);
03058 sip_destroy(reg->call);
03059 }
03060 AST_SCHED_DEL(sched, reg->expire);
03061 AST_SCHED_DEL(sched, reg->timeout);
03062 ast_string_field_free_memory(reg);
03063 regobjs--;
03064 free(reg);
03065
03066 }
03067
03068
03069 static int __sip_destroy(struct sip_pvt *p, int lockowner)
03070 {
03071 struct sip_pvt *cur, *prev = NULL;
03072 struct sip_pkt *cp;
03073
03074
03075 if (p->rtp && ast_rtp_get_bridged(p->rtp)) {
03076 ast_verbose("Bridge still active. Delaying destroy of SIP dialog '%s' Method: %s\n", p->callid, sip_methods[p->method].text);
03077 return -1;
03078 }
03079
03080 if (p->vrtp && ast_rtp_get_bridged(p->vrtp)) {
03081 ast_verbose("Bridge still active. Delaying destroy of SIP dialog '%s' Method: %s\n", p->callid, sip_methods[p->method].text);
03082 return -1;
03083 }
03084
03085 if (sip_debug_test_pvt(p) || option_debug > 2)
03086 ast_verbose("Really destroying SIP dialog '%s' Method: %s\n", p->callid, sip_methods[p->method].text);
03087
03088 if (ast_test_flag(&p->flags[0], SIP_INC_COUNT) || ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD)) {
03089 update_call_counter(p, DEC_CALL_LIMIT);
03090 if (option_debug > 1)
03091 ast_log(LOG_DEBUG, "This call did not properly clean up call limits. Call ID %s\n", p->callid);
03092 }
03093
03094
03095 if (p->owner) {
03096 if (lockowner)
03097 ast_channel_lock(p->owner);
03098 if (option_debug)
03099 ast_log(LOG_DEBUG, "Detaching from %s\n", p->owner->name);
03100 p->owner->tech_pvt = NULL;
03101
03102 p->owner->_softhangup |= AST_SOFTHANGUP_DEV;
03103 if (lockowner)
03104 ast_channel_unlock(p->owner);
03105
03106 usleep(1);
03107 }
03108
03109
03110 if (p->relatedpeer) {
03111 p->relatedpeer->mwipvt = NULL;
03112 ASTOBJ_UNREF(p->relatedpeer, sip_destroy_peer);
03113 }
03114
03115 if (dumphistory)
03116 sip_dump_history(p);
03117
03118 if (p->options)
03119 free(p->options);
03120
03121 if (p->stateid > -1)
03122 ast_extension_state_del(p->stateid, NULL);
03123 AST_SCHED_DEL(sched, p->initid);
03124 AST_SCHED_DEL(sched, p->waitid);
03125 AST_SCHED_DEL(sched, p->autokillid);
03126
03127 if (p->rtp) {
03128 ast_rtp_destroy(p->rtp);
03129 }
03130 if (p->vrtp) {
03131 ast_rtp_destroy(p->vrtp);
03132 }
03133 if (p->udptl)
03134 ast_udptl_destroy(p->udptl);
03135 if (p->refer)
03136 free(p->refer);
03137 if (p->route) {
03138 free_old_route(p->route);
03139 p->route = NULL;
03140 }
03141 if (p->registry) {
03142 if (p->registry->call == p)
03143 p->registry->call = NULL;
03144 ASTOBJ_UNREF(p->registry, sip_registry_destroy);
03145 }
03146
03147
03148 if (p->history) {
03149 struct sip_history *hist;
03150 while ( (hist = AST_LIST_REMOVE_HEAD(p->history, list)) ) {
03151 free(hist);
03152 p->history_entries--;
03153 }
03154 free(p->history);
03155 p->history = NULL;
03156 }
03157
03158 for (prev = NULL, cur = iflist; cur; prev = cur, cur = cur->next) {
03159 if (cur == p) {
03160 UNLINK(cur, iflist, prev);
03161 break;
03162 }
03163 }
03164 if (!cur) {
03165 ast_log(LOG_WARNING, "Trying to destroy \"%s\", not found in dialog list?!?! \n", p->callid);
03166 return 0;
03167 }
03168
03169
03170 while((cp = p->packets)) {
03171 p->packets = p->packets->next;
03172 AST_SCHED_DEL(sched, cp->retransid);
03173 free(cp);
03174 }
03175 if (p->chanvars) {
03176 ast_variables_destroy(p->chanvars);
03177 p->chanvars = NULL;
03178 }
03179 ast_mutex_destroy(&p->lock);
03180
03181 ast_string_field_free_memory(p);
03182
03183 free(p);
03184 return 0;
03185 }
03186
03187
03188
03189
03190
03191
03192
03193
03194
03195
03196
03197
03198
03199
03200
03201 static int update_call_counter(struct sip_pvt *fup, int event)
03202 {
03203 char name[256];
03204 int *inuse = NULL, *call_limit = NULL, *inringing = NULL;
03205 int outgoing = ast_test_flag(&fup->flags[1], SIP_PAGE2_OUTGOING_CALL);
03206 struct sip_user *u = NULL;
03207 struct sip_peer *p = NULL;
03208
03209 if (option_debug > 2)
03210 ast_log(LOG_DEBUG, "Updating call counter for %s call\n", outgoing ? "outgoing" : "incoming");
03211
03212
03213
03214 if (!ast_test_flag(&fup->flags[0], SIP_CALL_LIMIT) && !ast_test_flag(&fup->flags[1], SIP_PAGE2_CALL_ONHOLD))
03215 return 0;
03216
03217 ast_copy_string(name, fup->username, sizeof(name));
03218
03219
03220 if (global_limitonpeers == FALSE && !outgoing && (u = find_user(name, 1))) {
03221 inuse = &u->inUse;
03222 call_limit = &u->call_limit;
03223 inringing = NULL;
03224 } else if ( (p = find_peer(ast_strlen_zero(fup->peername) ? name : fup->peername, NULL, 1) ) ) {
03225 inuse = &p->inUse;
03226 call_limit = &p->call_limit;
03227 inringing = &p->inRinging;
03228 ast_copy_string(name, fup->peername, sizeof(name));
03229 }
03230 if (!p && !u) {
03231 if (option_debug > 1)
03232 ast_log(LOG_DEBUG, "%s is not a local device, no call limit\n", name);
03233 return 0;
03234 }
03235
03236 switch(event) {
03237
03238 case DEC_CALL_LIMIT:
03239 if ( *inuse > 0 ) {
03240 if (ast_test_flag(&fup->flags[0], SIP_INC_COUNT)) {
03241 (*inuse)--;
03242 ast_clear_flag(&fup->flags[0], SIP_INC_COUNT);
03243 }
03244 } else {
03245 *inuse = 0;
03246 }
03247 if (inringing) {
03248 if (ast_test_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING)) {
03249 if (*inringing > 0)
03250 (*inringing)--;
03251 else if (!ast_test_flag(&p->flags[0], SIP_REALTIME) || ast_test_flag(&p->flags[1], SIP_PAGE2_RTCACHEFRIENDS))
03252 ast_log(LOG_WARNING, "Inringing for peer '%s' < 0?\n", fup->peername);
03253 ast_clear_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING);
03254 }
03255 }
03256 if (ast_test_flag(&fup->flags[1], SIP_PAGE2_CALL_ONHOLD) && global_notifyhold) {
03257 ast_clear_flag(&fup->flags[1], SIP_PAGE2_CALL_ONHOLD);
03258 sip_peer_hold(fup, 0);
03259 }
03260 if (option_debug > 1 || sipdebug) {
03261 ast_log(LOG_DEBUG, "Call %s %s '%s' removed from call limit %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *call_limit);
03262 }
03263 break;
03264
03265 case INC_CALL_RINGING:
03266 case INC_CALL_LIMIT:
03267 if (*call_limit > 0 ) {
03268 if (*inuse >= *call_limit) {
03269 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);
03270 if (u)
03271 ASTOBJ_UNREF(u, sip_destroy_user);
03272 else
03273 ASTOBJ_UNREF(p, sip_destroy_peer);
03274 return -1;
03275 }
03276 }
03277 if (inringing && (event == INC_CALL_RINGING)) {
03278 if (!ast_test_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING)) {
03279 (*inringing)++;
03280 ast_set_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING);
03281 }
03282 }
03283
03284 (*inuse)++;
03285 ast_set_flag(&fup->flags[0], SIP_INC_COUNT);
03286 if (option_debug > 1 || sipdebug) {
03287 ast_log(LOG_DEBUG, "Call %s %s '%s' is %d out of %d\n", outgoing ? "to" : "from", u ? "user":"peer", name, *inuse, *call_limit);
03288 }
03289 break;
03290
03291 case DEC_CALL_RINGING:
03292 if (inringing) {
03293 if (ast_test_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING)) {
03294 if (*inringing > 0)
03295 (*inringing)--;
03296 else if (!ast_test_flag(&p->flags[0], SIP_REALTIME) || ast_test_flag(&p->flags[1], SIP_PAGE2_RTCACHEFRIENDS))
03297 ast_log(LOG_WARNING, "Inringing for peer '%s' < 0?\n", p->name);
03298 ast_clear_flag(&fup->flags[1], SIP_PAGE2_INC_RINGING);
03299 }
03300 }
03301 break;
03302
03303 default:
03304 ast_log(LOG_ERROR, "update_call_counter(%s, %d) called with no event!\n", name, event);
03305 }
03306 if (p) {
03307 ast_device_state_changed("SIP/%s", p->name);
03308 ASTOBJ_UNREF(p, sip_destroy_peer);
03309 } else
03310 ASTOBJ_UNREF(u, sip_destroy_user);
03311 return 0;
03312 }
03313
03314
03315 static void sip_destroy(struct sip_pvt *p)
03316 {
03317 ast_mutex_lock(&iflock);
03318 if (option_debug > 2)
03319 ast_log(LOG_DEBUG, "Destroying SIP dialog %s\n", p->callid);
03320 __sip_destroy(p, 1);
03321 ast_mutex_unlock(&iflock);
03322 }
03323
03324
03325 static int hangup_sip2cause(int cause)
03326 {
03327
03328
03329 switch(cause) {
03330 case 401:
03331 return AST_CAUSE_CALL_REJECTED;
03332 case 403:
03333 return AST_CAUSE_CALL_REJECTED;
03334 case 404:
03335 return AST_CAUSE_UNALLOCATED;
03336 case 405:
03337 return AST_CAUSE_INTERWORKING;
03338 case 407:
03339 return AST_CAUSE_CALL_REJECTED;
03340 case 408:
03341 return AST_CAUSE_NO_USER_RESPONSE;
03342 case 409:
03343 return AST_CAUSE_NORMAL_TEMPORARY_FAILURE;
03344 case 410:
03345 return AST_CAUSE_UNALLOCATED;
03346 case 411:
03347 return AST_CAUSE_INTERWORKING;
03348 case 413:
03349 return AST_CAUSE_INTERWORKING;
03350 case 414:
03351 return AST_CAUSE_INTERWORKING;
03352 case 415:
03353 return AST_CAUSE_INTERWORKING;
03354 case 420:
03355 return AST_CAUSE_NO_ROUTE_DESTINATION;
03356 case 480:
03357 return AST_CAUSE_NO_ANSWER;
03358 case 481:
03359 return AST_CAUSE_INTERWORKING;
03360 case 482:
03361 return AST_CAUSE_INTERWORKING;
03362 case 483:
03363 return AST_CAUSE_NO_ANSWER;
03364 case 484:
03365 return AST_CAUSE_INVALID_NUMBER_FORMAT;
03366 case 485:
03367 return AST_CAUSE_UNALLOCATED;
03368 case 486:
03369 return AST_CAUSE_BUSY;
03370 case 487:
03371 return AST_CAUSE_INTERWORKING;
03372 case 488:
03373 return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
03374 case 491:
03375 return AST_CAUSE_INTERWORKING;
03376 case 493:
03377 return AST_CAUSE_INTERWORKING;
03378 case 500:
03379 return AST_CAUSE_FAILURE;
03380 case 501:
03381 return AST_CAUSE_FACILITY_REJECTED;
03382 case 502:
03383 return AST_CAUSE_DESTINATION_OUT_OF_ORDER;
03384 case 503:
03385 return AST_CAUSE_CONGESTION;
03386 case 504:
03387 return AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE;
03388 case 505:
03389 return AST_CAUSE_INTERWORKING;
03390 case 600:
03391 return AST_CAUSE_USER_BUSY;
03392 case 603:
03393 return AST_CAUSE_CALL_REJECTED;
03394 case 604:
03395 return AST_CAUSE_UNALLOCATED;
03396 case 606:
03397 return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
03398 default:
03399 return AST_CAUSE_NORMAL;
03400 }
03401
03402 return 0;
03403 }
03404
03405
03406
03407
03408
03409
03410
03411
03412
03413
03414
03415
03416
03417
03418
03419
03420
03421
03422
03423
03424
03425
03426
03427
03428
03429
03430
03431
03432
03433
03434
03435
03436
03437 static const char *hangup_cause2sip(int cause)
03438 {
03439 switch (cause) {
03440 case AST_CAUSE_UNALLOCATED:
03441 case AST_CAUSE_NO_ROUTE_DESTINATION:
03442 case AST_CAUSE_NO_ROUTE_TRANSIT_NET:
03443 return "404 Not Found";
03444 case AST_CAUSE_CONGESTION:
03445 case AST_CAUSE_SWITCH_CONGESTION:
03446 return "503 Service Unavailable";
03447 case AST_CAUSE_NO_USER_RESPONSE:
03448 return "408 Request Timeout";
03449 case AST_CAUSE_NO_ANSWER:
03450 return "480 Temporarily unavailable";
03451 case AST_CAUSE_CALL_REJECTED:
03452 return "403 Forbidden";
03453 case AST_CAUSE_NUMBER_CHANGED:
03454 return "410 Gone";
03455 case AST_CAUSE_NORMAL_UNSPECIFIED:
03456 return "480 Temporarily unavailable";
03457 case AST_CAUSE_INVALID_NUMBER_FORMAT:
03458 return "484 Address incomplete";
03459 case AST_CAUSE_USER_BUSY:
03460 return "486 Busy here";
03461 case AST_CAUSE_FAILURE:
03462 return "500 Server internal failure";
03463 case AST_CAUSE_FACILITY_REJECTED:
03464 return "501 Not Implemented";
03465 case AST_CAUSE_CHAN_NOT_IMPLEMENTED:
03466 return "503 Service Unavailable";
03467
03468 case AST_CAUSE_DESTINATION_OUT_OF_ORDER:
03469 return "502 Bad Gateway";
03470 case AST_CAUSE_BEARERCAPABILITY_NOTAVAIL:
03471 return "488 Not Acceptable Here";
03472
03473 case AST_CAUSE_NOTDEFINED:
03474 default:
03475 if (option_debug)
03476 ast_log(LOG_DEBUG, "AST hangup cause %d (no match found in SIP)\n", cause);
03477 return NULL;
03478 }
03479
03480
03481 return 0;
03482 }
03483
03484
03485
03486
03487 static int sip_hangup(struct ast_channel *ast)
03488 {
03489 struct sip_pvt *p = ast->tech_pvt;
03490 int needcancel = FALSE;
03491 int needdestroy = 0;
03492 struct ast_channel *oldowner = ast;
03493
03494 if (!p) {
03495 if (option_debug)
03496 ast_log(LOG_DEBUG, "Asked to hangup channel that was not connected\n");
03497 return 0;
03498 }
03499
03500 if (ast_test_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER)) {
03501 if (ast_test_flag(&p->flags[0], SIP_INC_COUNT) || ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD)) {
03502 if (option_debug && sipdebug)
03503 ast_log(LOG_DEBUG, "update_call_counter(%s) - decrement call limit counter on hangup\n", p->username);
03504 update_call_counter(p, DEC_CALL_LIMIT);
03505 }
03506 if (option_debug >3)
03507 ast_log(LOG_DEBUG, "SIP Transfer: Not hanging up right now... Rescheduling hangup for %s.\n", p->callid);
03508 if (p->autokillid > -1 && sip_cancel_destroy(p))
03509 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
03510 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
03511 ast_clear_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER);
03512 ast_clear_flag(&p->flags[0], SIP_NEEDDESTROY);
03513 p->owner->tech_pvt = NULL;
03514 p->owner = NULL;
03515 return 0;
03516 }
03517 if (option_debug) {
03518 if (ast_test_flag(ast, AST_FLAG_ZOMBIE) && p->refer && option_debug)
03519 ast_log(LOG_DEBUG, "SIP Transfer: Hanging up Zombie channel %s after transfer ... Call-ID: %s\n", ast->name, p->callid);
03520 else {
03521 if (option_debug)
03522 ast_log(LOG_DEBUG, "Hangup call %s, SIP callid %s)\n", ast->name, p->callid);
03523 }
03524 }
03525 if (option_debug && ast_test_flag(ast, AST_FLAG_ZOMBIE))
03526 ast_log(LOG_DEBUG, "Hanging up zombie call. Be scared.\n");
03527
03528 ast_mutex_lock(&p->lock);
03529 if (ast_test_flag(&p->flags[0], SIP_INC_COUNT) || ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD)) {
03530 if (option_debug && sipdebug)
03531 ast_log(LOG_DEBUG, "update_call_counter(%s) - decrement call limit counter on hangup\n", p->username);
03532 update_call_counter(p, DEC_CALL_LIMIT);
03533 }
03534
03535
03536 if (p->owner != ast) {
03537 ast_log(LOG_WARNING, "Huh? We aren't the owner? Can't hangup call.\n");
03538 ast_mutex_unlock(&p->lock);
03539 return 0;
03540 }
03541
03542 if (ast->_state == AST_STATE_RING || ast->_state == AST_STATE_RINGING || (p->invitestate < INV_COMPLETED && ast->_state != AST_STATE_UP)) {
03543 needcancel = TRUE;
03544 if (option_debug > 3)
03545 ast_log(LOG_DEBUG, "Hanging up channel in state %s (not UP)\n", ast_state2str(ast->_state));
03546 }
03547
03548 stop_media_flows(p);
03549
03550 append_history(p, needcancel ? "Cancel" : "Hangup", "Cause %s", p->owner ? ast_cause2str(p->owner->hangupcause) : "Unknown");
03551
03552
03553 if (p->vad)
03554 ast_dsp_free(p->vad);
03555
03556 p->owner = NULL;
03557 ast->tech_pvt = NULL;
03558
03559 ast_module_unref(ast_module_info->self);
03560
03561
03562
03563
03564
03565
03566
03567 if (ast_test_flag(&p->flags[0], SIP_ALREADYGONE))
03568 needdestroy = 1;
03569 else if (p->invitestate != INV_CALLING)
03570 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
03571
03572
03573 if (!ast_test_flag(&p->flags[0], SIP_ALREADYGONE) && !ast_strlen_zero(p->initreq.data)) {
03574 if (needcancel) {
03575 if (ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
03576
03577 __sip_pretend_ack(p);
03578 p->invitestate = INV_CANCELLED;
03579
03580
03581 if (p->invitestate == INV_CALLING) {
03582
03583 ast_set_flag(&p->flags[0], SIP_PENDINGBYE);
03584
03585 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
03586 append_history(p, "DELAY", "Not sending cancel, waiting for timeout");
03587 } else {
03588
03589 transmit_request(p, SIP_CANCEL, p->lastinvite, XMIT_RELIABLE, FALSE);
03590
03591
03592 needdestroy = 0;
03593 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
03594 }
03595 if ( p->initid != -1 ) {
03596
03597
03598 update_call_counter(p, INC_CALL_LIMIT);
03599 }
03600 } else {
03601 const char *res;
03602 if (ast->hangupcause && (res = hangup_cause2sip(ast->hangupcause)))
03603 transmit_response_reliable(p, res, &p->initreq);
03604 else
03605 transmit_response_reliable(p, "603 Declined", &p->initreq);
03606 p->invitestate = INV_TERMINATED;
03607 }
03608 } else {
03609 if (!p->pendinginvite) {
03610 char *audioqos = "";
03611 char *videoqos = "";
03612 if (p->rtp)
03613 audioqos = ast_rtp_get_quality(p->rtp, NULL);
03614 if (p->vrtp)
03615 videoqos = ast_rtp_get_quality(p->vrtp, NULL);
03616
03617 transmit_request_with_auth(p, SIP_BYE, 0, XMIT_RELIABLE, 1);
03618
03619
03620 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY)) {
03621 if (p->rtp)
03622 append_history(p, "RTCPaudio", "Quality:%s", audioqos);
03623 if (p->vrtp)
03624 append_history(p, "RTCPvideo", "Quality:%s", videoqos);
03625 }
03626 if (p->rtp && oldowner)
03627 pbx_builtin_setvar_helper(oldowner, "RTPAUDIOQOS", audioqos);
03628 if (p->vrtp && oldowner)
03629 pbx_builtin_setvar_helper(oldowner, "RTPVIDEOQOS", videoqos);
03630 } else {
03631
03632
03633 ast_set_flag(&p->flags[0], SIP_PENDINGBYE);
03634 ast_clear_flag(&p->flags[0], SIP_NEEDREINVITE);
03635 AST_SCHED_DEL(sched, p->waitid);
03636 if (sip_cancel_destroy(p))
03637 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
03638 }
03639 }
03640 }
03641 if (needdestroy)
03642 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
03643 ast_mutex_unlock(&p->lock);
03644 return 0;
03645 }
03646
03647
03648 static void try_suggested_sip_codec(struct sip_pvt *p)
03649 {
03650 int fmt;
03651 const char *codec;
03652
03653 codec = pbx_builtin_getvar_helper(p->owner, "SIP_CODEC");
03654 if (!codec)
03655 return;
03656
03657 fmt = ast_getformatbyname(codec);
03658 if (fmt) {
03659 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC} variable\n", codec);
03660 if (p->jointcapability & fmt) {
03661 p->jointcapability &= fmt;
03662 p->capability &= fmt;
03663 } else
03664 ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because it is not shared by both ends.\n");
03665 } else
03666 ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n", codec);
03667 return;
03668 }
03669
03670
03671
03672 static int sip_answer(struct ast_channel *ast)
03673 {
03674 int res = 0;
03675 struct sip_pvt *p = ast->tech_pvt;
03676
03677 ast_mutex_lock(&p->lock);
03678 if (ast->_state != AST_STATE_UP) {
03679 try_suggested_sip_codec(p);
03680
03681 ast_setstate(ast, AST_STATE_UP);
03682 if (option_debug)
03683 ast_log(LOG_DEBUG, "SIP answering channel: %s\n", ast->name);
03684 if (p->t38.state == T38_PEER_DIRECT) {
03685 p->t38.state = T38_ENABLED;
03686 if (option_debug > 1)
03687 ast_log(LOG_DEBUG,"T38State change to %d on channel %s\n", p->t38.state, ast->name);
03688 res = transmit_response_with_t38_sdp(p, "200 OK", &p->initreq, XMIT_CRITICAL);
03689 } else {
03690 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, XMIT_CRITICAL);
03691 }
03692 }
03693 ast_mutex_unlock(&p->lock);
03694 return res;
03695 }
03696
03697
03698 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
03699 {
03700 struct sip_pvt *p = ast->tech_pvt;
03701 int res = 0;
03702
03703 switch (frame->frametype) {
03704 case AST_FRAME_VOICE:
03705 if (!(frame->subclass & ast->nativeformats)) {
03706 char s1[512], s2[512], s3[512];
03707 ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %s(%d) read/write = %s(%d)/%s(%d)\n",
03708 frame->subclass,
03709 ast_getformatname_multiple(s1, sizeof(s1) - 1, ast->nativeformats & AST_FORMAT_AUDIO_MASK),
03710 ast->nativeformats & AST_FORMAT_AUDIO_MASK,
03711 ast_getformatname_multiple(s2, sizeof(s2) - 1, ast->readformat),
03712 ast->readformat,
03713 ast_getformatname_multiple(s3, sizeof(s3) - 1, ast->writeformat),
03714 ast->writeformat);
03715 return 0;
03716 }
03717 if (p) {
03718 ast_mutex_lock(&p->lock);
03719 if (p->rtp) {
03720
03721 if ((ast->_state != AST_STATE_UP) &&
03722 !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
03723 !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
03724 ast_rtp_new_source(p->rtp);
03725 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, XMIT_UNRELIABLE);
03726 ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);
03727 }
03728 p->lastrtptx = time(NULL);
03729 res = ast_rtp_write(p->rtp, frame);
03730 }
03731 ast_mutex_unlock(&p->lock);
03732 }
03733 break;
03734 case AST_FRAME_VIDEO:
03735 if (p) {
03736 ast_mutex_lock(&p->lock);
03737 if (p->vrtp) {
03738
03739 if ((ast->_state != AST_STATE_UP) &&
03740 !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
03741 !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
03742 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, XMIT_UNRELIABLE);
03743 ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);
03744 }
03745 p->lastrtptx = time(NULL);
03746 res = ast_rtp_write(p->vrtp, frame);
03747 }
03748 ast_mutex_unlock(&p->lock);
03749 }
03750 break;
03751 case AST_FRAME_IMAGE:
03752 return 0;
03753 break;
03754 case AST_FRAME_MODEM:
03755 if (p) {
03756 ast_mutex_lock(&p->lock);
03757
03758
03759
03760
03761 if (p->udptl && ast->_state == AST_STATE_UP)
03762 res = ast_udptl_write(p->udptl, frame);
03763 ast_mutex_unlock(&p->lock);
03764 }
03765 break;
03766 default:
03767 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
03768 return 0;
03769 }
03770
03771 return res;
03772 }
03773
03774
03775
03776 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
03777 {
03778 int ret = -1;
03779 struct sip_pvt *p;
03780
03781 if (newchan && ast_test_flag(newchan, AST_FLAG_ZOMBIE) && option_debug)
03782 ast_log(LOG_DEBUG, "New channel is zombie\n");
03783 if (oldchan && ast_test_flag(oldchan, AST_FLAG_ZOMBIE) && option_debug)
03784 ast_log(LOG_DEBUG, "Old channel is zombie\n");
03785
03786 if (!newchan || !newchan->tech_pvt) {
03787 if (!newchan)
03788 ast_log(LOG_WARNING, "No new channel! Fixup of %s failed.\n", oldchan->name);
03789 else
03790 ast_log(LOG_WARNING, "No SIP tech_pvt! Fixup of %s failed.\n", oldchan->name);
03791 return -1;
03792 }
03793 p = newchan->tech_pvt;
03794
03795 if (!p) {
03796 ast_log(LOG_WARNING, "No pvt after masquerade. Strange things may happen\n");
03797 return -1;
03798 }
03799
03800 ast_mutex_lock(&p->lock);
03801 append_history(p, "Masq", "Old channel: %s\n", oldchan->name);
03802 append_history(p, "Masq (cont)", "...new owner: %s\n", newchan->name);
03803 if (p->owner != oldchan)
03804 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
03805 else {
03806 p->owner = newchan;
03807
03808
03809
03810
03811
03812
03813 sip_set_rtp_peer(newchan, NULL, NULL, 0, 0);
03814 ret = 0;
03815 }
03816 if (option_debug > 2)
03817 ast_log(LOG_DEBUG, "SIP Fixup: New owner for dialogue %s: %s (Old parent: %s)\n", p->callid, p->owner->name, oldchan->name);
03818
03819 ast_mutex_unlock(&p->lock);
03820 return ret;
03821 }
03822
03823 static int sip_senddigit_begin(struct ast_channel *ast, char digit)
03824 {
03825 struct sip_pvt *p = ast->tech_pvt;
03826 int res = 0;
03827
03828 ast_mutex_lock(&p->lock);
03829 switch (ast_test_flag(&p->flags[0], SIP_DTMF)) {
03830 case SIP_DTMF_INBAND:
03831 res = -1;
03832 break;
03833 case SIP_DTMF_RFC2833:
03834 if (p->rtp)
03835 ast_rtp_senddigit_begin(p->rtp, digit);
03836 break;
03837 default:
03838 break;
03839 }
03840 ast_mutex_unlock(&p->lock);
03841
03842 return res;
03843 }
03844
03845
03846
03847 static int sip_senddigit_end(struct ast_channel *ast, char digit, unsigned int duration)
03848 {
03849 struct sip_pvt *p = ast->tech_pvt;
03850 int res = 0;
03851
03852 ast_mutex_lock(&p->lock);
03853 switch (ast_test_flag(&p->flags[0], SIP_DTMF)) {
03854 case SIP_DTMF_INFO:
03855 transmit_info_with_digit(p, digit, duration);
03856 break;
03857 case SIP_DTMF_RFC2833:
03858 if (p->rtp)
03859 ast_rtp_senddigit_end(p->rtp, digit);
03860 break;
03861 case SIP_DTMF_INBAND:
03862 res = -1;
03863 break;
03864 }
03865 ast_mutex_unlock(&p->lock);
03866
03867 return res;
03868 }
03869
03870
03871 static int sip_transfer(struct ast_channel *ast, const char *dest)
03872 {
03873 struct sip_pvt *p = ast->tech_pvt;
03874 int res;
03875
03876 if (dest == NULL)
03877 dest = "";
03878 ast_mutex_lock(&p->lock);
03879 if (ast->_state == AST_STATE_RING)
03880 res = sip_sipredirect(p, dest);
03881 else
03882 res = transmit_refer(p, dest);
03883 ast_mutex_unlock(&p->lock);
03884 return res;
03885 }
03886
03887
03888
03889
03890
03891
03892 static int sip_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen)
03893 {
03894 struct sip_pvt *p = ast->tech_pvt;
03895 int res = 0;
03896
03897 ast_mutex_lock(&p->lock);
03898 switch(condition) {
03899 case AST_CONTROL_RINGING:
03900 if (ast->_state == AST_STATE_RING) {
03901 p->invitestate = INV_EARLY_MEDIA;
03902 if (!ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) ||
03903 (ast_test_flag(&p->flags[0], SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER)) {
03904
03905 transmit_response(p, "180 Ringing", &p->initreq);
03906 ast_set_flag(&p->flags[0], SIP_RINGING);
03907 if (ast_test_flag(&p->flags[0], SIP_PROG_INBAND) != SIP_PROG_INBAND_YES)
03908 break;
03909 } else {
03910
03911 }
03912 }
03913 res = -1;
03914 break;
03915 case AST_CONTROL_BUSY:
03916 if (ast->_state != AST_STATE_UP) {
03917 transmit_response(p, "486 Busy Here", &p->initreq);
03918 p->invitestate = INV_COMPLETED;
03919 sip_alreadygone(p);
03920 ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
03921 break;
03922 }
03923 res = -1;
03924 break;
03925 case AST_CONTROL_CONGESTION:
03926 if (ast->_state != AST_STATE_UP) {
03927 transmit_response(p, "503 Service Unavailable", &p->initreq);
03928 p->invitestate = INV_COMPLETED;
03929 sip_alreadygone(p);
03930 ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
03931 break;
03932 }
03933 res = -1;
03934 break;
03935 case AST_CONTROL_PROCEEDING:
03936 if ((ast->_state != AST_STATE_UP) &&
03937 !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
03938 !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
03939 transmit_response(p, "100 Trying", &p->initreq);
03940 p->invitestate = INV_PROCEEDING;
03941 break;
03942 }
03943 res = -1;
03944 break;
03945 case AST_CONTROL_PROGRESS:
03946 if ((ast->_state != AST_STATE_UP) &&
03947 !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
03948 !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
03949 p->invitestate = INV_EARLY_MEDIA;
03950 transmit_response_with_sdp(p, "183 Session Progress", &p->initreq, XMIT_UNRELIABLE);
03951 ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);
03952 break;
03953 }
03954 res = -1;
03955 break;
03956 case AST_CONTROL_HOLD:
03957 ast_rtp_new_source(p->rtp);
03958 ast_moh_start(ast, data, p->mohinterpret);
03959 break;
03960 case AST_CONTROL_UNHOLD:
03961 ast_rtp_new_source(p->rtp);
03962 ast_moh_stop(ast);
03963 break;
03964 case AST_CONTROL_VIDUPDATE:
03965 if (p->vrtp && !ast_test_flag(&p->flags[0], SIP_NOVIDEO)) {
03966 transmit_info_with_vidupdate(p);
03967
03968 } else
03969 res = -1;
03970 break;
03971 case AST_CONTROL_SRCUPDATE:
03972 ast_rtp_new_source(p->rtp);
03973 break;
03974 case -1:
03975 res = -1;
03976 break;
03977 default:
03978 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
03979 res = -1;
03980 break;
03981 }
03982 ast_mutex_unlock(&p->lock);
03983 return res;
03984 }
03985
03986
03987
03988
03989
03990
03991
03992 static struct ast_channel *sip_new(struct sip_pvt *i, int state, const char *title)
03993 {
03994 struct ast_channel *tmp;
03995 struct ast_variable *v = NULL;
03996 int fmt;
03997 int what;
03998 int needvideo = 0, video = 0;
03999 char *decoded_exten;
04000 {
04001 const char *my_name;
04002
04003 if (title)
04004 my_name = title;
04005 else if ( (my_name = strchr(i->fromdomain,':')) )
04006 my_name++;
04007 else
04008 my_name = i->fromdomain;
04009
04010 ast_mutex_unlock(&i->lock);
04011
04012 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);
04013
04014 }
04015 if (!tmp) {
04016 ast_log(LOG_WARNING, "Unable to allocate AST channel structure for SIP channel\n");
04017 ast_mutex_lock(&i->lock);
04018 return NULL;
04019 }
04020 ast_mutex_lock(&i->lock);
04021
04022 if (ast_test_flag(&i->flags[0], SIP_DTMF) == SIP_DTMF_INFO)
04023 tmp->tech = &sip_tech_info;
04024 else
04025 tmp->tech = &sip_tech;
04026
04027
04028
04029 if (i->jointcapability) {
04030 what = i->jointcapability;
04031 video = i->jointcapability & AST_FORMAT_VIDEO_MASK;
04032 } else if (i->capability) {
04033 what = i->capability;
04034 video = i->capability & AST_FORMAT_VIDEO_MASK;
04035 } else {
04036 what = global_capability;
04037 video = global_capability & AST_FORMAT_VIDEO_MASK;
04038 }
04039
04040
04041 tmp->nativeformats = ast_codec_choose(&i->prefs, what, 1) | video;
04042 if (option_debug > 2) {
04043 char buf[SIPBUFSIZE];
04044 ast_log(LOG_DEBUG, "*** Our native formats are %s \n", ast_getformatname_multiple(buf, SIPBUFSIZE, tmp->nativeformats));
04045 ast_log(LOG_DEBUG, "*** Joint capabilities are %s \n", ast_getformatname_multiple(buf, SIPBUFSIZE, i->jointcapability));
04046 ast_log(LOG_DEBUG, "*** Our capabilities are %s \n", ast_getformatname_multiple(buf, SIPBUFSIZE, i->capability));
04047 ast_log(LOG_DEBUG, "*** AST_CODEC_CHOOSE formats are %s \n", ast_getformatname_multiple(buf, SIPBUFSIZE, ast_codec_choose(&i->prefs, what, 1)));
04048 if (i->prefcodec)
04049 ast_log(LOG_DEBUG, "*** Our preferred formats from the incoming channel are %s \n", ast_getformatname_multiple(buf, SIPBUFSIZE, i->prefcodec));
04050 }
04051
04052
04053 fmt = ast_best_codec(tmp->nativeformats);
04054
04055
04056
04057
04058
04059 if (i->vrtp) {
04060 if (i->prefcodec)
04061 needvideo = i->prefcodec & AST_FORMAT_VIDEO_MASK;
04062 else
04063 needvideo = i->jointcapability & AST_FORMAT_VIDEO_MASK;
04064 }
04065
04066 if (option_debug > 2) {
04067 if (needvideo)
04068 ast_log(LOG_DEBUG, "This channel can handle video! HOLLYWOOD next!\n");
04069 else
04070 ast_log(LOG_DEBUG, "This channel will not be able to handle video.\n");
04071 }
04072
04073
04074
04075 if (ast_test_flag(&i->flags[0], SIP_DTMF) == SIP_DTMF_INBAND) {
04076 i->vad = ast_dsp_new();
04077 ast_dsp_set_features(i->vad, DSP_FEATURE_DTMF_DETECT);
04078 if (global_relaxdtmf)
04079 ast_dsp_digitmode(i->vad, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
04080 }
04081 if (i->rtp) {
04082 tmp->fds[0] = ast_rtp_fd(i->rtp);
04083 tmp->fds[1] = ast_rtcp_fd(i->rtp);
04084 }
04085 if (needvideo && i->vrtp) {
04086 tmp->fds[2] = ast_rtp_fd(i->vrtp);
04087 tmp->fds[3] = ast_rtcp_fd(i->vrtp);
04088 }
04089 if (i->udptl) {
04090 tmp->fds[5] = ast_udptl_fd(i->udptl);
04091 }
04092 if (state == AST_STATE_RING)
04093 tmp->rings = 1;
04094 tmp->adsicpe = AST_ADSI_UNAVAILABLE;
04095 tmp->writeformat = fmt;
04096 tmp->rawwriteformat = fmt;
04097 tmp->readformat = fmt;
04098 tmp->rawreadformat = fmt;
04099 tmp->tech_pvt = i;
04100
04101 tmp->callgroup = i->callgroup;
04102 tmp->pickupgroup = i->pickupgroup;
04103 tmp->cid.cid_pres = i->callingpres;
04104 if (!ast_strlen_zero(i->accountcode))
04105 ast_string_field_set(tmp, accountcode, i->accountcode);
04106 if (i->amaflags)
04107 tmp->amaflags = i->amaflags;
04108 if (!ast_strlen_zero(i->language))
04109 ast_string_field_set(tmp, language, i->language);
04110 i->owner = tmp;
04111 ast_module_ref(ast_module_info->self);
04112 ast_copy_string(tmp->context, i->context, sizeof(tmp->context));
04113
04114
04115
04116
04117 decoded_exten = ast_strdupa(i->exten);
04118 ast_uri_decode(decoded_exten);
04119 ast_copy_string(tmp->exten, decoded_exten, sizeof(tmp->exten));
04120
04121
04122
04123 tmp->cid.cid_ani = ast_strdup(i->cid_num);
04124 if (!ast_strlen_zero(i->rdnis))
04125 tmp->cid.cid_rdnis = ast_strdup(i->rdnis);
04126
04127 if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s"))
04128 tmp->cid.cid_dnid = ast_strdup(i->exten);
04129
04130 tmp->priority = 1;
04131 if (!ast_strlen_zero(i->uri))
04132 pbx_builtin_setvar_helper(tmp, "SIPURI", i->uri);
04133 if (!ast_strlen_zero(i->domain))
04134 pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
04135 if (!ast_strlen_zero(i->useragent))
04136 pbx_builtin_setvar_helper(tmp, "SIPUSERAGENT", i->useragent);
04137 if (!ast_strlen_zero(i->callid))
04138 pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
04139 if (i->rtp)
04140 ast_jb_configure(tmp, &global_jbconf);
04141
04142
04143 if (i->udptl && i->t38.state == T38_PEER_DIRECT)
04144 pbx_builtin_setvar_helper(tmp, "_T38CALL", "1");
04145
04146
04147 for (v = i->chanvars ; v ; v = v->next)
04148 pbx_builtin_setvar_helper(tmp, v->name, v->value);
04149
04150 if (state != AST_STATE_DOWN && ast_pbx_start(tmp)) {
04151 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
04152 tmp->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
04153 ast_hangup(tmp);
04154 tmp = NULL;
04155 }
04156
04157 if (!ast_test_flag(&i->flags[0], SIP_NO_HISTORY))
04158 append_history(i, "NewChan", "Channel %s - from %s", tmp->name, i->callid);
04159
04160 return tmp;
04161 }
04162
04163
04164 static char *get_body_by_line(const char *line, const char *name, int nameLen)
04165 {
04166 if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=')
04167 return ast_skip_blanks(line + nameLen + 1);
04168
04169 return "";
04170 }
04171
04172
04173
04174
04175
04176 static const char *get_sdp_iterate(int *start, struct sip_request *req, const char *name)
04177 {
04178 int len = strlen(name);
04179
04180 while (*start < req->sdp_end) {
04181 const char *r = get_body_by_line(req->line[(*start)++], name, len);
04182 if (r[0] != '\0')
04183 return r;
04184 }
04185
04186 return "";
04187 }
04188
04189
04190 static const char *get_sdp(struct sip_request *req, const char *name)
04191 {
04192 int dummy = 0;
04193
04194 return get_sdp_iterate(&dummy, req, name);
04195 }
04196
04197
04198 static char *get_body(struct sip_request *req, char *name)
04199 {
04200 int x;
04201 int len = strlen(name);
04202 char *r;
04203
04204 for (x = 0; x < req->lines; x++) {
04205 r = get_body_by_line(req->line[x], name, len);
04206 if (r[0] != '\0')
04207 return r;
04208 }
04209
04210 return "";
04211 }
04212
04213
04214 static const char *find_alias(const char *name, const char *_default)
04215 {
04216
04217 static const struct cfalias {
04218 char * const fullname;
04219 char * const shortname;
04220 } aliases[] = {
04221 { "Content-Type", "c" },
04222 { "Content-Encoding", "e" },
04223 { "From", "f" },
04224 { "Call-ID", "i" },
04225 { "Contact", "m" },
04226 { "Content-Length", "l" },
04227 { "Subject", "s" },
04228 { "To", "t" },
04229 { "Supported", "k" },
04230 { "Refer-To", "r" },
04231 { "Referred-By", "b" },
04232 { "Allow-Events", "u" },
04233 { "Event", "o" },
04234 { "Via", "v" },
04235 { "Accept-Contact", "a" },
04236 { "Reject-Contact", "j" },
04237 { "Request-Disposition", "d" },
04238 { "Session-Expires", "x" },
04239 { "Identity", "y" },
04240 { "Identity-Info", "n" },
04241 };
04242 int x;
04243
04244 for (x=0; x<sizeof(aliases) / sizeof(aliases[0]); x++)
04245 if (!strcasecmp(aliases[x].fullname, name))
04246 return aliases[x].shortname;
04247
04248 return _default;
04249 }
04250
04251 static const char *__get_header(const struct sip_request *req, const char *name, int *start)
04252 {
04253 int pass;
04254
04255
04256
04257
04258
04259
04260
04261
04262
04263
04264 for (pass = 0; name && pass < 2;pass++) {
04265 int x, len = strlen(name);
04266 for (x=*start; x<req->headers; x++) {
04267 if (!strncasecmp(req->header[x], name, len)) {
04268 char *r = req->header[x] + len;
04269 if (pedanticsipchecking)
04270 r = ast_skip_blanks(r);
04271
04272 if (*r == ':') {
04273 *start = x+1;
04274 return ast_skip_blanks(r+1);
04275 }
04276 }
04277 }
04278 if (pass == 0)
04279 name = find_alias(name, NULL);
04280 }
04281
04282
04283 return "";
04284 }
04285
04286
04287 static const char *get_header(const struct sip_request *req, const char *name)
04288 {
04289 int start = 0;
04290 return __get_header(req, name, &start);
04291 }
04292
04293
04294 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p, int *faxdetect)
04295 {
04296
04297 struct ast_frame *f;
04298
04299 if (!p->rtp) {
04300
04301 return &ast_null_frame;
04302 }
04303
04304 switch(ast->fdno) {
04305 case 0:
04306 f = ast_rtp_read(p->rtp);
04307 break;
04308 case 1:
04309 f = ast_rtcp_read(p->rtp);
04310 break;
04311 case 2:
04312 f = ast_rtp_read(p->vrtp);
04313 break;
04314 case 3:
04315 f = ast_rtcp_read(p->vrtp);
04316 break;
04317 case 5:
04318 f = ast_udptl_read(p->udptl);
04319 break;
04320 default:
04321 f = &ast_null_frame;
04322 }
04323
04324 if (f && (f->frametype == AST_FRAME_DTMF) &&
04325 (ast_test_flag(&p->flags[0], SIP_DTMF) != SIP_DTMF_RFC2833))
04326 return &ast_null_frame;
04327
04328
04329 if (!p->owner || (f && f->frametype != AST_FRAME_VOICE))
04330 return f;
04331
04332 if (f && f->subclass != (p->owner->nativeformats & AST_FORMAT_AUDIO_MASK)) {
04333 if (!(f->subclass & p->jointcapability)) {
04334 if (option_debug) {
04335 ast_log(LOG_DEBUG, "Bogus frame of format '%s' received from '%s'!\n",
04336 ast_getformatname(f->subclass), p->owner->name);
04337 }
04338 return &ast_null_frame;
04339 }
04340 if (option_debug)
04341 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
04342 p->owner->nativeformats = (p->owner->nativeformats & AST_FORMAT_VIDEO_MASK) | f->subclass;
04343 ast_set_read_format(p->owner, p->owner->readformat);
04344 ast_set_write_format(p->owner, p->owner->writeformat);
04345 }
04346
04347 if (f && (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_INBAND) && p->vad) {
04348 f = ast_dsp_process(p->owner, p->vad, f);
04349 if (f && f->frametype == AST_FRAME_DTMF) {
04350 if (ast_test_flag(&p->t38.t38support, SIP_PAGE2_T38SUPPORT_UDPTL) && f->subclass == 'f') {
04351 if (option_debug)
04352 ast_log(LOG_DEBUG, "Fax CNG detected on %s\n", ast->name);
04353 *faxdetect = 1;
04354 } else if (option_debug) {
04355 ast_log(LOG_DEBUG, "* Detected inband DTMF '%c'\n", f->subclass);
04356 }
04357 }
04358 }
04359
04360 return f;
04361 }
04362
04363
04364 static struct ast_frame *sip_read(struct ast_channel *ast)
04365 {
04366 struct ast_frame *fr;
04367 struct sip_pvt *p = ast->tech_pvt;
04368 int faxdetected = FALSE;
04369
04370 ast_mutex_lock(&p->lock);
04371 fr = sip_rtp_read(ast, p, &faxdetected);
04372 p->lastrtprx = time(NULL);
04373
04374
04375
04376 if (faxdetected && ast_test_flag(&p->t38.t38support, SIP_PAGE2_T38SUPPORT_UDPTL) && (p->t38.state == T38_DISABLED) && !(ast_bridged_channel(ast))) {
04377 if (!ast_test_flag(&p->flags[0], SIP_GOTREFER)) {
04378 if (!p->pendinginvite) {
04379 if (option_debug > 2)
04380 ast_log(LOG_DEBUG, "Sending reinvite on SIP (%s) for T.38 negotiation.\n",ast->name);
04381 p->t38.state = T38_LOCAL_REINVITE;
04382 transmit_reinvite_with_t38_sdp(p);
04383 if (option_debug > 1)
04384 ast_log(LOG_DEBUG, "T38 state changed to %d on channel %s\n", p->t38.state, ast->name);
04385 }
04386 } else if (!ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
04387 if (option_debug > 2)
04388 ast_log(LOG_DEBUG, "Deferring reinvite on SIP (%s) - it will be re-negotiated for T.38\n", ast->name);
04389 ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
04390 }
04391 }
04392
04393
04394 if (fr->frametype == AST_FRAME_VOICE && p->invitestate != INV_EARLY_MEDIA && ast->_state != AST_STATE_UP) {
04395 fr = &ast_null_frame;
04396 }
04397
04398 ast_mutex_unlock(&p->lock);
04399 return fr;
04400 }
04401
04402
04403
04404 static char *generate_random_string(char *buf, size_t size)
04405 {
04406 long val[4];
04407 int x;
04408
04409 for (x=0; x<4; x++)
04410 val[x] = ast_random();
04411 snprintf(buf, size, "%08lx%08lx%08lx%08lx", val[0], val[1], val[2], val[3]);
04412
04413 return buf;
04414 }
04415
04416
04417 static void build_callid_pvt(struct sip_pvt *pvt)
04418 {
04419 char buf[33];
04420
04421 const char *host = S_OR(pvt->fromdomain, ast_inet_ntoa(pvt->ourip));
04422
04423 ast_string_field_build(pvt, callid, "%s@%s", generate_random_string(buf, sizeof(buf)), host);
04424
04425 }
04426
04427
04428 static void build_callid_registry(struct sip_registry *reg, struct in_addr ourip, const char *fromdomain)
04429 {
04430 char buf[33];
04431
04432 const char *host = S_OR(fromdomain, ast_inet_ntoa(ourip));
04433
04434 ast_string_field_build(reg, callid, "%s@%s", generate_random_string(buf, sizeof(buf)), host);
04435 }
04436
04437
04438 static void make_our_tag(char *tagbuf, size_t len)
04439 {
04440 snprintf(tagbuf, len, "as%08lx", ast_random());
04441 }
04442
04443
04444 static struct sip_pvt *sip_alloc(ast_string_field callid, struct sockaddr_in *sin,
04445 int useglobal_nat, const int intended_method)
04446 {
04447 struct sip_pvt *p;
04448
04449 if (!(p = ast_calloc(1, sizeof(*p))))
04450 return NULL;
04451
04452 if (ast_string_field_init(p, 512)) {
04453 free(p);
04454 return NULL;
04455 }
04456
04457 ast_mutex_init(&p->lock);
04458
04459 p->method = intended_method;
04460 p->initid = -1;
04461 p->waitid = -1;
04462 p->autokillid = -1;
04463 p->subscribed = NONE;
04464 p->stateid = -1;
04465 p->prefs = default_prefs;
04466
04467 if (intended_method != SIP_OPTIONS)
04468 p->timer_t1 = 500;
04469
04470 if (sin) {
04471 p->sa = *sin;
04472 if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
04473 p->ourip = __ourip;
04474 } else
04475 p->ourip = __ourip;
04476
04477
04478 ast_copy_flags(&p->flags[0], &global_flags[0], SIP_FLAGS_TO_COPY);
04479 ast_copy_flags(&p->flags[1], &global_flags[1], SIP_PAGE2_FLAGS_TO_COPY);
04480
04481 ast_set2_flag(&p->flags[0], !recordhistory, SIP_NO_HISTORY);
04482
04483 p->branch = ast_random();
04484 make_our_tag(p->tag, sizeof(p->tag));
04485 p->ocseq = INITIAL_CSEQ;
04486
04487 if (sip_methods[intended_method].need_rtp) {
04488 p->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
04489
04490 if (ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT))
04491 p->vrtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
04492 if (ast_test_flag(&p->flags[1], SIP_PAGE2_T38SUPPORT))
04493 p->udptl = ast_udptl_new_with_bindaddr(sched, io, 0, bindaddr.sin_addr);
04494 if (!p->rtp || (ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT) && !p->vrtp)) {
04495 ast_log(LOG_WARNING, "Unable to create RTP audio %s session: %s\n",
04496 ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT) ? "and video" : "", strerror(errno));
04497 ast_mutex_destroy(&p->lock);
04498 if (p->chanvars) {
04499 ast_variables_destroy(p->chanvars);
04500 p->chanvars = NULL;
04501 }
04502 free(p);
04503 return NULL;
04504 }
04505 ast_rtp_setdtmf(p->rtp, ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833);
04506 ast_rtp_setdtmfcompensate(p->rtp, ast_test_flag(&p->flags[1], SIP_PAGE2_RFC2833_COMPENSATE));
04507 ast_rtp_settos(p->rtp, global_tos_audio);
04508 ast_rtp_set_rtptimeout(p->rtp, global_rtptimeout);
04509 ast_rtp_set_rtpholdtimeout(p->rtp, global_rtpholdtimeout);
04510 ast_rtp_set_rtpkeepalive(p->rtp, global_rtpkeepalive);
04511 if (p->vrtp) {
04512 ast_rtp_settos(p->vrtp, global_tos_video);
04513 ast_rtp_setdtmf(p->vrtp, 0);
04514 ast_rtp_setdtmfcompensate(p->vrtp, 0);
04515 ast_rtp_set_rtptimeout(p->vrtp, global_rtptimeout);
04516 ast_rtp_set_rtpholdtimeout(p->vrtp, global_rtpholdtimeout);
04517 ast_rtp_set_rtpkeepalive(p->vrtp, global_rtpkeepalive);
04518 }
04519 if (p->udptl)
04520 ast_udptl_settos(p->udptl, global_tos_audio);
04521 p->maxcallbitrate = default_maxcallbitrate;
04522 p->autoframing = global_autoframing;
04523 ast_rtp_codec_setpref(p->rtp, &p->prefs);
04524 }
04525
04526 if (useglobal_nat && sin) {
04527
04528 ast_copy_flags(&p->flags[0], &global_flags[0], SIP_NAT);
04529 p->recv = *sin;
04530 do_setnat(p, ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE);
04531 }
04532
04533 if (p->method != SIP_REGISTER)
04534 ast_string_field_set(p, fromdomain, default_fromdomain);
04535 build_via(p);
04536 if (!callid)
04537 build_callid_pvt(p);
04538 else
04539 ast_string_field_set(p, callid, callid);
04540
04541 ast_string_field_set(p, mohinterpret, default_mohinterpret);
04542 ast_string_field_set(p, mohsuggest, default_mohsuggest);
04543 p->capability = global_capability;
04544 p->allowtransfer = global_allowtransfer;
04545 if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
04546 (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO))
04547 p->noncodeccapability |= AST_RTP_DTMF;
04548 if (p->udptl) {
04549 p->t38.capability = global_t38_capability;
04550 if (ast_udptl_get_error_correction_scheme(p->udptl) == UDPTL_ERROR_CORRECTION_REDUNDANCY)
04551 p->t38.capability |= T38FAX_UDP_EC_REDUNDANCY;
04552 else if (ast_udptl_get_error_correction_scheme(p->udptl) == UDPTL_ERROR_CORRECTION_FEC)
04553 p->t38.capability |= T38FAX_UDP_EC_FEC;
04554 else if (ast_udptl_get_error_correction_scheme(p->udptl) == UDPTL_ERROR_CORRECTION_NONE)
04555 p->t38.capability |= T38FAX_UDP_EC_NONE;
04556 p->t38.capability |= T38FAX_RATE_MANAGEMENT_TRANSFERED_TCF;
04557 p->t38.jointcapability = p->t38.capability;
04558 }
04559 ast_string_field_set(p, context, default_context);
04560
04561
04562 ast_mutex_lock(&iflock);
04563 p->next = iflist;
04564 iflist = p;
04565 ast_mutex_unlock(&iflock);
04566 if (option_debug)
04567 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");
04568 return p;
04569 }
04570
04571
04572
04573 static struct sip_pvt *find_call(struct sip_request *req, struct sockaddr_in *sin, const int intended_method)
04574 {
04575 struct sip_pvt *p = NULL;
04576 char *tag = "";
04577 char totag[128];
04578 char fromtag[128];
04579 const char *callid = get_header(req, "Call-ID");
04580 const char *from = get_header(req, "From");
04581 const char *to = get_header(req, "To");
04582 const char *cseq = get_header(req, "Cseq");
04583
04584
04585
04586 if (ast_strlen_zero(callid) || ast_strlen_zero(to) ||
04587 ast_strlen_zero(from) || ast_strlen_zero(cseq))
04588 return NULL;
04589
04590 if (pedanticsipchecking) {
04591
04592
04593
04594
04595
04596
04597 if (gettag(req, "To", totag, sizeof(totag)))
04598 ast_set_flag(req, SIP_PKT_WITH_TOTAG);
04599 gettag(req, "From", fromtag, sizeof(fromtag));
04600
04601 tag = (req->method == SIP_RESPONSE) ? totag : fromtag;
04602
04603 if (option_debug > 4 )
04604 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);
04605 }
04606
04607 ast_mutex_lock(&iflock);
04608 for (p = iflist; p; p = p->next) {
04609
04610 int found = FALSE;
04611 if (ast_strlen_zero(p->callid))
04612 continue;
04613 if (req->method == SIP_REGISTER)
04614 found = (!strcmp(p->callid, callid));
04615 else
04616 found = (!strcmp(p->callid, callid) &&
04617 (!pedanticsipchecking || ast_strlen_zero(tag) || ast_strlen_zero(p->theirtag) || !strcmp(p->theirtag, tag))) ;
04618
04619 if (option_debug > 4)
04620 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);
04621
04622
04623 if (pedanticsipchecking && found && req->method != SIP_RESPONSE) {
04624 if (p->tag[0] == '\0' && totag[0]) {
04625
04626 found = FALSE;
04627 } else if (totag[0]) {
04628 if (strcmp(totag, p->tag)) {
04629 found = FALSE;
04630 }
04631 }
04632 if (!found && option_debug > 4)
04633 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);
04634 }
04635 if (found) {
04636
04637 ast_mutex_lock(&p->lock);
04638 ast_mutex_unlock(&iflock);
04639 return p;
04640 }
04641 }
04642 ast_mutex_unlock(&iflock);
04643
04644
04645 if (sip_methods[intended_method].can_create == CAN_CREATE_DIALOG) {
04646 if (intended_method == SIP_REFER) {
04647
04648 transmit_response_using_temp(callid, sin, 1, intended_method, req, "603 Declined (no dialog)");
04649 } else if (intended_method == SIP_NOTIFY) {
04650
04651
04652 transmit_response_using_temp(callid, sin, 1, intended_method, req, "489 Bad event");
04653 } else {
04654
04655 if ((p = sip_alloc(callid, sin, 1, intended_method))) {
04656
04657 ast_mutex_lock(&p->lock);
04658 } else {
04659
04660
04661
04662
04663
04664
04665
04666
04667 transmit_response_using_temp(callid, sin, 1, intended_method, req, "500 Server internal error");
04668 if (option_debug > 3)
04669 ast_log(LOG_DEBUG, "Failed allocating SIP dialog, sending 500 Server internal error and giving up\n");
04670 }
04671 }
04672 return p;
04673 } else if( sip_methods[intended_method].can_create == CAN_CREATE_DIALOG_UNSUPPORTED_METHOD) {
04674
04675 transmit_response_using_temp(callid, sin, 1, intended_method, req, "501 Method Not Implemented");
04676 } else if (intended_method != SIP_RESPONSE && intended_method != SIP_ACK) {
04677
04678
04679
04680 transmit_response_using_temp(callid, sin, 1, intended_method, req, "481 Call leg/transaction does not exist");
04681 }
04682
04683
04684
04685 return p;
04686 }
04687
04688
04689 static int sip_register(char *value, int lineno)
04690 {
04691 struct sip_registry *reg;
04692 int portnum = 0;
04693 char username[256] = "";
04694 char *hostname=NULL, *secret=NULL, *authuser=NULL;
04695 char *porta=NULL;
04696 char *contact=NULL;
04697
04698 if (!value)
04699 return -1;
04700 ast_copy_string(username, value, sizeof(username));
04701
04702 hostname = strrchr(username, '@');
04703 if (hostname)
04704 *hostname++ = '\0';
04705 if (ast_strlen_zero(username) || ast_strlen_zero(hostname)) {
04706 ast_log(LOG_WARNING, "Format for registration is user[:secret[:authuser]]@host[:port][/contact] at line %d\n", lineno);
04707 return -1;
04708 }
04709
04710 secret = strchr(username, ':');
04711 if (secret) {
04712 *secret++ = '\0';
04713 authuser = strchr(secret, ':');
04714 if (authuser)
04715 *authuser++ = '\0';
04716 }
04717
04718 contact = strchr(hostname, '/');
04719 if (contact)
04720 *contact++ = '\0';
04721 if (ast_strlen_zero(contact))
04722 contact = "s";
04723 porta = strchr(hostname, ':');
04724 if (porta) {
04725 *porta++ = '\0';
04726 portnum = atoi(porta);
04727 if (portnum == 0) {
04728 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
04729 return -1;
04730 }
04731 }
04732 if (!(reg = ast_calloc(1, sizeof(*reg)))) {
04733 ast_log(LOG_ERROR, "Out of memory. Can't allocate SIP registry entry\n");
04734 return -1;
04735 }
04736
04737 if (ast_string_field_init(reg, 256)) {
04738 ast_log(LOG_ERROR, "Out of memory. Can't allocate SIP registry strings\n");
04739 free(reg);
04740 return -1;
04741 }
04742
04743 regobjs++;
04744 ASTOBJ_INIT(reg);
04745 ast_string_field_set(reg, contact, contact);
04746 if (!ast_strlen_zero(username))
04747 ast_string_field_set(reg, username, username);
04748 if (hostname)
04749 ast_string_field_set(reg, hostname, hostname);
04750 if (authuser)
04751 ast_string_field_set(reg, authuser, authuser);
04752 if (secret)
04753 ast_string_field_set(reg, secret, secret);
04754 reg->expire = -1;
04755 reg->timeout = -1;
04756 reg->refresh = default_expiry;
04757 reg->portno = portnum;
04758 reg->callid_valid = FALSE;
04759 reg->ocseq = INITIAL_CSEQ;
04760 ASTOBJ_CONTAINER_LINK(®l, reg);
04761 ASTOBJ_UNREF(reg,sip_registry_destroy);
04762 return 0;
04763 }
04764
04765
04766
04767 static int lws2sws(char *msgbuf, int len)
04768 {
04769 int h = 0, t = 0;
04770 int lws = 0;
04771
04772 for (; h < len;) {
04773
04774 if (msgbuf[h] == '\r') {
04775 h++;
04776 continue;
04777 }
04778
04779 if (msgbuf[h] == '\n') {
04780
04781 if (h + 1 == len)
04782 break;
04783
04784 if (msgbuf[h + 1] == ' ' || msgbuf[h + 1] == '\t') {
04785
04786 h++;
04787 continue;
04788 }
04789
04790 msgbuf[t++] = msgbuf[h++];
04791 lws = 0;
04792 continue;
04793 }
04794 if (msgbuf[h] == ' ' || msgbuf[h] == '\t') {
04795 if (lws) {
04796 h++;
04797 continue;
04798 }
04799 msgbuf[t++] = msgbuf[h++];
04800 lws = 1;
04801 continue;
04802 }
04803 msgbuf[t++] = msgbuf[h++];
04804 if (lws)
04805 lws = 0;
04806 }
04807 msgbuf[t] = '\0';
04808 return t;
04809 }
04810
04811
04812
04813
04814 static int parse_request(struct sip_request *req)
04815 {
04816
04817 char *c;
04818 int f = 0;
04819
04820 c = req->data;
04821
04822
04823 req->header[f] = c;
04824 while(*c) {
04825 if (*c == '\n') {
04826
04827 *c = 0;
04828
04829 if (sipdebug && option_debug > 3)
04830 ast_log(LOG_DEBUG, "Header %d: %s (%d)\n", f, req->header[f], (int) strlen(req->header[f]));
04831 if (ast_strlen_zero(req->header[f])) {
04832
04833 c++;
04834 break;
04835 }
04836 if (f >= SIP_MAX_HEADERS - 1) {
04837 ast_log(LOG_WARNING, "Too many SIP headers. Ignoring.\n");
04838 } else
04839 f++;
04840 req->header[f] = c + 1;
04841 } else if (*c == '\r') {
04842
04843 *c = 0;
04844 }
04845 c++;
04846 }
04847
04848 if (!ast_strlen_zero(req->header[f])) {
04849 if (sipdebug && option_debug > 3)
04850 ast_log(LOG_DEBUG, "Header %d: %s (%d)\n", f, req->header[f], (int) strlen(req->header[f]));
04851 f++;
04852 }
04853 req->headers = f;
04854
04855 f = 0;
04856 req->line[f] = c;
04857 while(*c) {
04858 if (*c == '\n') {
04859
04860 *c = 0;
04861 if (sipdebug && option_debug > 3)
04862 ast_log(LOG_DEBUG, "Line: %s (%d)\n", req->line[f], (int) strlen(req->line[f]));
04863 if (f >= SIP_MAX_LINES - 1) {
04864 ast_log(LOG_WARNING, "Too many SDP lines. Ignoring.\n");
04865 } else
04866 f++;
04867 req->line[f] = c + 1;
04868 } else if (*c == '\r') {
04869
04870 *c = 0;
04871 }
04872 c++;
04873 }
04874
04875 if (!ast_strlen_zero(req->line[f]))
04876 f++;
04877 req->lines = f;
04878 if (*c)
04879 ast_log(LOG_WARNING, "Odd content, extra stuff left over ('%s')\n", c);
04880
04881 return determine_firstline_parts(req);
04882 }
04883
04884
04885
04886
04887
04888
04889
04890
04891
04892 static int find_sdp(struct sip_request *req)
04893 {
04894 const char *content_type;
04895 const char *content_length;
04896 const char *search;
04897 char *boundary;
04898 unsigned int x;
04899 int boundaryisquoted = FALSE;
04900 int found_application_sdp = FALSE;
04901 int found_end_of_headers = FALSE;
04902
04903 content_length = get_header(req, "Content-Length");
04904
04905 if (!ast_strlen_zero(content_length)) {
04906 if (sscanf(content_length, "%ud", &x) != 1) {
04907 ast_log(LOG_WARNING, "Invalid Content-Length: %s\n", content_length);
04908 return 0;
04909 }
04910
04911
04912
04913 if (x == 0)
04914 return 0;
04915 }
04916
04917 content_type = get_header(req, "Content-Type");
04918
04919
04920 if (!strcasecmp(content_type, "application/sdp")) {
04921 req->sdp_start = 0;
04922 req->sdp_end = req->lines;
04923 return req->lines ? 1 : 0;
04924 }
04925
04926
04927 if (strncasecmp(content_type, "multipart/mixed", 15))
04928 return 0;
04929
04930
04931 if ((search = strcasestr(content_type, ";boundary=")))
04932 search += 10;
04933 else if ((search = strcasestr(content_type, "; boundary=")))
04934 search += 11;
04935 else
04936 return 0;
04937
04938 if (ast_strlen_zero(search))
04939 return 0;
04940
04941
04942 if (*search == '\"') {
04943 search++;
04944 boundaryisquoted = TRUE;
04945 }
04946
04947
04948
04949 boundary = ast_strdupa(search - 2);
04950 boundary[0] = boundary[1] = '-';
04951
04952 if (boundaryisquoted)
04953 boundary[strlen(boundary) - 1] = '\0';
04954
04955
04956
04957
04958 for (x = 0; x < (req->lines ); x++) {
04959 if(!strncasecmp(req->line[x], boundary, strlen(boundary))){
04960 if(found_application_sdp && found_end_of_headers){
04961 req->sdp_end = x-1;
04962 return 1;
04963 }
04964 found_application_sdp = FALSE;
04965 }
04966 if(!strcasecmp(req->line[x], "Content-Type: application/sdp"))
04967 found_application_sdp = TRUE;
04968
04969 if(strlen(req->line[x]) == 0 ){
04970 if(found_application_sdp && !found_end_of_headers){
04971 req->sdp_start = x;
04972 found_end_of_headers = TRUE;
04973 }
04974 }
04975 }
04976 if(found_application_sdp && found_end_of_headers) {
04977 req->sdp_end = x;
04978 return TRUE;
04979 }
04980 return FALSE;
04981 }
04982
04983
04984 static void change_hold_state(struct sip_pvt *dialog, struct sip_request *req, int holdstate, int sendonly)
04985 {
04986 if (global_notifyhold && (!holdstate || !ast_test_flag(&dialog->flags[1], SIP_PAGE2_CALL_ONHOLD)))
04987 sip_peer_hold(dialog, holdstate);
04988 if (global_callevents)
04989 manager_event(EVENT_FLAG_CALL, holdstate ? "Hold" : "Unhold",
04990 "Channel: %s\r\n"
04991 "Uniqueid: %s\r\n",
04992 dialog->owner->name,
04993 dialog->owner->uniqueid);
04994 append_history(dialog, holdstate ? "Hold" : "Unhold", "%s", req->data);
04995 if (!holdstate) {
04996 ast_clear_flag(&dialog->flags[1], SIP_PAGE2_CALL_ONHOLD);
04997 return;
04998 }
04999
05000
05001 if (sendonly == 1)
05002 ast_set_flag(&dialog->flags[1], SIP_PAGE2_CALL_ONHOLD_ONEDIR);
05003 else if (sendonly == 2)
05004 ast_set_flag(&dialog->flags[1], SIP_PAGE2_CALL_ONHOLD_INACTIVE);
05005 else
05006 ast_set_flag(&dialog->flags[1], SIP_PAGE2_CALL_ONHOLD_ACTIVE);
05007 return;
05008 }
05009
05010
05011
05012
05013
05014
05015 static int process_sdp(struct sip_pvt *p, struct sip_request *req)
05016 {
05017 const char *m;
05018 const char *c;
05019 const char *a;
05020 char host[258];
05021 int len = -1;
05022 int portno = -1;
05023 int vportno = -1;
05024 int udptlportno = -1;
05025 int peert38capability = 0;
05026 char s[256];
05027 int old = 0;
05028
05029
05030 int peercapability = 0, peernoncodeccapability = 0;
05031 int vpeercapability = 0, vpeernoncodeccapability = 0;
05032 struct sockaddr_in sin;
05033 struct sockaddr_in vsin;
05034
05035 const char *codecs;
05036 struct hostent *hp;
05037 struct hostent *vhp = NULL;
05038 struct ast_hostent audiohp;
05039 struct ast_hostent videohp;
05040 int codec;
05041 int destiterator = 0;
05042 int iterator;
05043 int sendonly = -1;
05044 int numberofports;
05045 struct ast_rtp *newaudiortp, *newvideortp;
05046 int newjointcapability;
05047 int newpeercapability;
05048 int newnoncodeccapability;
05049 int numberofmediastreams = 0;
05050 int debug = sip_debug_test_pvt(p);
05051
05052 int found_rtpmap_codecs[SDP_MAX_RTPMAP_CODECS];
05053 int last_rtpmap_codec=0;
05054
05055 if (!p->rtp) {
05056 ast_log(LOG_ERROR, "Got SDP but have no RTP session allocated.\n");
05057 return -1;
05058 }
05059
05060
05061 newaudiortp = alloca(ast_rtp_alloc_size());
05062 memset(newaudiortp, 0, ast_rtp_alloc_size());
05063 ast_rtp_new_init(newaudiortp);
05064 ast_rtp_pt_clear(newaudiortp);
05065
05066 newvideortp = alloca(ast_rtp_alloc_size());
05067 memset(newvideortp, 0, ast_rtp_alloc_size());
05068 ast_rtp_new_init(newvideortp);
05069 ast_rtp_pt_clear(newvideortp);
05070
05071
05072 p->lastrtprx = p->lastrtptx = time(NULL);
05073
05074
05075
05076 m = get_sdp(req, "m");
05077 destiterator = req->sdp_start;
05078 c = get_sdp_iterate(&destiterator, req, "c");
05079 if (ast_strlen_zero(m) || ast_strlen_zero(c)) {
05080 ast_log(LOG_WARNING, "Insufficient information for SDP (m = '%s', c = '%s')\n", m, c);
05081 return -1;
05082 }
05083
05084
05085 if (sscanf(c, "IN IP4 %256s", host) != 1) {
05086 ast_log(LOG_WARNING, "Invalid host in c= line, '%s'\n", c);
05087 return -1;
05088 }
05089
05090
05091 hp = ast_gethostbyname(host, &audiohp);
05092 if (!hp) {
05093 ast_log(LOG_WARNING, "Unable to lookup host in c= line, '%s'\n", c);
05094 return -1;
05095 }
05096 vhp = hp;
05097
05098 iterator = req->sdp_start;
05099 ast_set_flag(&p->flags[0], SIP_NOVIDEO);
05100
05101
05102
05103 while ((m = get_sdp_iterate(&iterator, req, "m"))[0] != '\0') {
05104 int x;
05105 int audio = FALSE;
05106
05107 numberofports = 1;
05108 if ((sscanf(m, "audio %d/%d RTP/AVP %n", &x, &numberofports, &len) == 2) ||
05109 (sscanf(m, "audio %d RTP/AVP %n", &x, &len) == 1)) {
05110 audio = TRUE;
05111 numberofmediastreams++;
05112
05113 portno = x;
05114
05115 for (codecs = m + len; !ast_strlen_zero(codecs); codecs = ast_skip_blanks(codecs + len)) {
05116 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
05117 ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
05118 return -1;
05119 }
05120 if (debug)
05121 ast_verbose("Found RTP audio format %d\n", codec);
05122 ast_rtp_set_m_type(newaudiortp, codec);
05123 }
05124 } else if ((sscanf(m, "video %d/%d RTP/AVP %n", &x, &numberofports, &len) == 2) ||
05125 (sscanf(m, "video %d RTP/AVP %n", &x, &len) == 1)) {
05126
05127 ast_clear_flag(&p->flags[0], SIP_NOVIDEO);
05128 numberofmediastreams++;
05129 vportno = x;
05130
05131 for (codecs = m + len; !ast_strlen_zero(codecs); codecs = ast_skip_blanks(codecs + len)) {
05132 if (sscanf(codecs, "%d%n", &codec, &len) != 1) {
05133 ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
05134 return -1;
05135 }
05136 if (debug)
05137 ast_verbose("Found RTP video format %d\n", codec);
05138 ast_rtp_set_m_type(newvideortp, codec);
05139 }
05140 } else if (p->udptl && ( (sscanf(m, "image %d udptl t38%n", &x, &len) == 1) ||
05141 (sscanf(m, "image %d UDPTL t38%n", &x, &len) == 1) )) {
05142 if (debug)
05143 ast_verbose("Got T.38 offer in SDP in dialog %s\n", p->callid);
05144 udptlportno = x;
05145 numberofmediastreams++;
05146
05147 if (p->owner && p->lastinvite) {
05148 p->t38.state = T38_PEER_REINVITE;
05149 if (option_debug > 1)
05150 ast_log(LOG_DEBUG, "T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>" );
05151 } else {
05152 p->t38.state = T38_PEER_DIRECT;
05153 if (option_debug > 1)
05154 ast_log(LOG_DEBUG, "T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
05155 }
05156 } else
05157 ast_log(LOG_WARNING, "Unsupported SDP media type in offer: %s\n", m);
05158 if (numberofports > 1)
05159 ast_log(LOG_WARNING, "SDP offered %d ports for media, not supported by Asterisk. Will try anyway...\n", numberofports);
05160
05161
05162
05163 c = get_sdp_iterate(&destiterator, req, "c");
05164 if (!ast_strlen_zero(c)) {
05165 if (sscanf(c, "IN IP4 %256s", host) != 1) {
05166 ast_log(LOG_WARNING, "Invalid secondary host in c= line, '%s'\n", c);
05167 } else {
05168
05169 if (audio) {
05170 if ( !(hp = ast_gethostbyname(host, &audiohp))) {
05171 ast_log(LOG_WARNING, "Unable to lookup RTP Audio host in secondary c= line, '%s'\n", c);
05172 return -2;
05173 }
05174 } else if (!(vhp = ast_gethostbyname(host, &videohp))) {
05175 ast_log(LOG_WARNING, "Unable to lookup RTP video host in secondary c= line, '%s'\n", c);
05176 return -2;
05177 }
05178 }
05179
05180 }
05181 }
05182 if (portno == -1 && vportno == -1 && udptlportno == -1)
05183
05184
05185 return -2;
05186
05187 if (numberofmediastreams > 2)
05188
05189 return -3;
05190
05191
05192 sin.sin_family = AF_INET;
05193 vsin.sin_family = AF_INET;
05194 memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
05195 if (vhp)
05196 memcpy(&vsin.sin_addr, vhp->h_addr, sizeof(vsin.sin_addr));
05197
05198
05199 if (p->udptl) {
05200 if (udptlportno > 0) {
05201 sin.sin_port = htons(udptlportno);
05202 if (ast_test_flag(&p->flags[0], SIP_NAT) && ast_test_flag(&p->flags[1], SIP_PAGE2_UDPTL_DESTINATION)) {
05203 struct sockaddr_in peer;
05204 ast_rtp_get_peer(p->rtp, &peer);
05205 if (peer.sin_addr.s_addr) {
05206 memcpy(&sin.sin_addr, &peer.sin_addr, sizeof(&sin.sin_addr));
05207 if (debug) {
05208 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));
05209 }
05210 }
05211 }
05212 ast_udptl_set_peer(p->udptl, &sin);
05213 if (debug)
05214 ast_log(LOG_DEBUG,"Peer T.38 UDPTL is at port %s:%d\n",ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
05215 } else {
05216 ast_udptl_stop(p->udptl);
05217 if (debug)
05218 ast_log(LOG_DEBUG, "Peer doesn't provide T.38 UDPTL\n");
05219 }
05220 }
05221
05222
05223 if (p->rtp) {
05224 if (portno > 0) {
05225 sin.sin_port = htons(portno);
05226 ast_rtp_set_peer(p->rtp, &sin);
05227 if (debug)
05228 ast_verbose("Peer audio RTP is at port %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
05229 } else {
05230 if (udptlportno > 0) {
05231 if (debug)
05232 ast_verbose("Got T.38 Re-invite without audio. Keeping RTP active during T.38 session. Callid %s\n", p->callid);
05233 } else {
05234 ast_rtp_stop(p->rtp);
05235 if (debug)
05236 ast_verbose("Peer doesn't provide audio. Callid %s\n", p->callid);
05237 }
05238 }
05239 }
05240
05241 if (vportno != -1)
05242 vsin.sin_port = htons(vportno);
05243
05244
05245
05246
05247
05248 iterator = req->sdp_start;
05249 while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
05250 char* mimeSubtype = ast_strdupa(a);
05251 if (option_debug > 1) {
05252 int breakout = FALSE;
05253
05254
05255 if (!strncasecmp(a, "rtcp:", (size_t) 5)) {
05256 if (debug)
05257 ast_verbose("Got unsupported a:rtcp in SDP offer \n");
05258 breakout = TRUE;
05259 } else if (!strncasecmp(a, "fmtp:", (size_t) 5)) {
05260
05261
05262
05263
05264 if (debug)
05265 ast_verbose("Got unsupported a:fmtp in SDP offer \n");
05266 breakout = TRUE;
05267 } else if (!strncasecmp(a, "framerate:", (size_t) 10)) {
05268
05269 if (debug)
05270 ast_verbose("Got unsupported a:framerate in SDP offer \n");
05271 breakout = TRUE;
05272 } else if (!strncasecmp(a, "maxprate:", (size_t) 9)) {
05273
05274 if (debug)
05275 ast_verbose("Got unsupported a:maxprate in SDP offer \n");
05276 breakout = TRUE;
05277 } else if (!strncasecmp(a, "crypto:", (size_t) 7)) {
05278
05279 if (debug)
05280 ast_verbose("Got unsupported a:crypto in SDP offer \n");
05281 breakout = TRUE;
05282 }
05283 if (breakout)
05284 continue;
05285 }
05286 if (!strcasecmp(a, "sendonly")) {
05287 if (sendonly == -1)
05288 sendonly = 1;
05289 continue;
05290 } else if (!strcasecmp(a, "inactive")) {
05291 if (sendonly == -1)
05292 sendonly = 2;
05293 continue;
05294 } else if (!strcasecmp(a, "sendrecv")) {
05295 if (sendonly == -1)
05296 sendonly = 0;
05297 continue;
05298 } else if (strlen(a) > 5 && !strncasecmp(a, "ptime", 5)) {
05299 char *tmp = strrchr(a, ':');
05300 long int framing = 0;
05301 if (tmp) {
05302 tmp++;
05303 framing = strtol(tmp, NULL, 10);
05304 if (framing == LONG_MIN || framing == LONG_MAX) {
05305 framing = 0;
05306 if (option_debug)
05307 ast_log(LOG_DEBUG, "Can't read framing from SDP: %s\n", a);
05308 }
05309 }
05310 if (framing && p->autoframing) {
05311 struct ast_codec_pref *pref = ast_rtp_codec_getpref(p->rtp);
05312 int codec_n;
05313 int format = 0;
05314 for (codec_n = 0; codec_n < MAX_RTP_PT; codec_n++) {
05315 format = ast_rtp_codec_getformat(codec_n);
05316 if (!format)
05317 continue;
05318 if (option_debug)
05319 ast_log(LOG_DEBUG, "Setting framing for %d to %ld\n", format, framing);
05320 ast_codec_pref_setsize(pref, format, framing);
05321 }
05322 ast_rtp_codec_setpref(p->rtp, pref);
05323 }
05324 continue;
05325 } else if (sscanf(a, "rtpmap: %u %[^/]/", &codec, mimeSubtype) == 2) {
05326
05327 int found = FALSE;
05328
05329
05330
05331 if (last_rtpmap_codec < SDP_MAX_RTPMAP_CODECS) {
05332
05333 if(ast_rtp_set_rtpmap_type(newaudiortp, codec, "audio", mimeSubtype,
05334 ast_test_flag(&p->flags[0], SIP_G726_NONSTANDARD) ? AST_RTP_OPT_G726_NONSTANDARD : 0) != -1) {
05335 if (debug)
05336 ast_verbose("Found audio description format %s for ID %d\n", mimeSubtype, codec);
05337 found_rtpmap_codecs[last_rtpmap_codec] = codec;
05338 last_rtpmap_codec++;
05339 found = TRUE;
05340
05341 } else if (p->vrtp) {
05342 if(ast_rtp_set_rtpmap_type(newvideortp, codec, "video", mimeSubtype, 0) != -1) {
05343 if (debug)
05344 ast_verbose("Found video description format %s for ID %d\n", mimeSubtype, codec);
05345 found_rtpmap_codecs[last_rtpmap_codec] = codec;
05346 last_rtpmap_codec++;
05347 found = TRUE;
05348 }
05349 }
05350 } else {
05351 if (debug)
05352 ast_verbose("Discarded description format %s for ID %d\n", mimeSubtype, codec);
05353 }
05354
05355 if (!found) {
05356
05357
05358
05359 ast_rtp_unset_m_type(newaudiortp, codec);
05360 ast_rtp_unset_m_type(newvideortp, codec);
05361 if (debug)
05362 ast_verbose("Found unknown media description format %s for ID %d\n", mimeSubtype, codec);
05363 }
05364 }
05365 }
05366
05367 if (udptlportno != -1) {
05368 int found = 0, x;
05369
05370 old = 0;
05371
05372
05373 iterator = req->sdp_start;
05374 while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
05375 if ((sscanf(a, "T38FaxMaxBuffer:%d", &x) == 1)) {
05376 found = 1;
05377 if (option_debug > 2)
05378 ast_log(LOG_DEBUG, "MaxBufferSize:%d\n",x);
05379 } else if ((sscanf(a, "T38MaxBitRate:%d", &x) == 1)) {
05380 found = 1;
05381 if (option_debug > 2)
05382 ast_log(LOG_DEBUG,"T38MaxBitRate: %d\n",x);
05383 switch (x) {
05384 case 14400:
05385 peert38capability |= T38FAX_RATE_14400 | T38FAX_RATE_12000 | T38FAX_RATE_9600 | T38FAX_RATE_7200 | T38FAX_RATE_4800 | T38FAX_RATE_2400;
05386 break;
05387 case 12000:
05388 peert38capability |= T38FAX_RATE_12000 | T38FAX_RATE_9600 | T38FAX_RATE_7200 | T38FAX_RATE_4800 | T38FAX_RATE_2400;
05389 break;
05390 case 9600:
05391 peert38capability |= T38FAX_RATE_9600 | T38FAX_RATE_7200 | T38FAX_RATE_4800 | T38FAX_RATE_2400;
05392 break;
05393 case 7200:
05394 peert38capability |= T38FAX_RATE_7200 | T38FAX_RATE_4800 | T38FAX_RATE_2400;
05395 break;
05396 case 4800:
05397 peert38capability |= T38FAX_RATE_4800 | T38FAX_RATE_2400;
05398 break;
05399 case 2400:
05400 peert38capability |= T38FAX_RATE_2400;
05401 break;
05402 }
05403 } else if ((sscanf(a, "T38FaxVersion:%d", &x) == 1)) {
05404 found = 1;
05405 if (option_debug > 2)
05406 ast_log(LOG_DEBUG, "FaxVersion: %d\n",x);
05407 if (x == 0)
05408 peert38capability |= T38FAX_VERSION_0;
05409 else if (x == 1)
05410 peert38capability |= T38FAX_VERSION_1;
05411 } else if ((sscanf(a, "T38FaxMaxDatagram:%d", &x) == 1)) {
05412 found = 1;
05413 if (option_debug > 2)
05414 ast_log(LOG_DEBUG, "FaxMaxDatagram: %d\n",x);
05415 ast_udptl_set_far_max_datagram(p->udptl, x);
05416 ast_udptl_set_local_max_datagram(p->udptl, x);
05417 } else if ((sscanf(a, "T38FaxFillBitRemoval:%d", &x) == 1)) {
05418 found = 1;
05419 if (option_debug > 2)
05420 ast_log(LOG_DEBUG, "FillBitRemoval: %d\n",x);
05421 if (x == 1)
05422 peert38capability |= T38FAX_FILL_BIT_REMOVAL;
05423 } else if ((sscanf(a, "T38FaxTranscodingMMR:%d", &x) == 1)) {
05424 found = 1;
05425 if (option_debug > 2)
05426 ast_log(LOG_DEBUG, "Transcoding MMR: %d\n",x);
05427 if (x == 1)
05428 peert38capability |= T38FAX_TRANSCODING_MMR;
05429 }
05430 if ((sscanf(a, "T38FaxTranscodingJBIG:%d", &x) == 1)) {
05431 found = 1;
05432 if (option_debug > 2)
05433 ast_log(LOG_DEBUG, "Transcoding JBIG: %d\n",x);
05434 if (x == 1)
05435 peert38capability |= T38FAX_TRANSCODING_JBIG;
05436 } else if ((sscanf(a, "T38FaxRateManagement:%255s", s) == 1)) {
05437 found = 1;
05438 if (option_debug > 2)
05439 ast_log(LOG_DEBUG, "RateManagement: %s\n", s);
05440 if (!strcasecmp(s, "localTCF"))
05441 peert38capability |= T38FAX_RATE_MANAGEMENT_LOCAL_TCF;
05442 else if (!strcasecmp(s, "transferredTCF"))
05443 peert38capability |= T38FAX_RATE_MANAGEMENT_TRANSFERED_TCF;
05444 } else if ((sscanf(a, "T38FaxUdpEC:%255s", s) == 1)) {
05445 found = 1;
05446 if (option_debug > 2)
05447 ast_log(LOG_DEBUG, "UDP EC: %s\n", s);
05448 if (!strcasecmp(s, "t38UDPRedundancy")) {
05449 peert38capability |= T38FAX_UDP_EC_REDUNDANCY;
05450 ast_udptl_set_error_correction_scheme(p->udptl, UDPTL_ERROR_CORRECTION_REDUNDANCY);
05451 } else if (!strcasecmp(s, "t38UDPFEC")) {
05452 peert38capability |= T38FAX_UDP_EC_FEC;
05453 ast_udptl_set_error_correction_scheme(p->udptl, UDPTL_ERROR_CORRECTION_FEC);
05454 } else {
05455 peert38capability |= T38FAX_UDP_EC_NONE;
05456 ast_udptl_set_error_correction_scheme(p->udptl, UDPTL_ERROR_CORRECTION_NONE);
05457 }
05458 }
05459 }
05460 if (found) {
05461 p->t38.peercapability = peert38capability;
05462 p->t38.jointcapability = (peert38capability & 255);
05463 peert38capability &= (T38FAX_RATE_14400 | T38FAX_RATE_12000 | T38FAX_RATE_9600 | T38FAX_RATE_7200 | T38FAX_RATE_4800 | T38FAX_RATE_2400);
05464 p->t38.jointcapability |= (peert38capability & p->t38.capability);
05465 }
05466 if (debug)
05467 ast_log(LOG_DEBUG, "Our T38 capability = (%d), peer T38 capability (%d), joint T38 capability (%d)\n",
05468 p->t38.capability,
05469 p->t38.peercapability,
05470 p->t38.jointcapability);
05471 } else {
05472 p->t38.state = T38_DISABLED;
05473 if (option_debug > 2)
05474 ast_log(LOG_DEBUG, "T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
05475 }
05476
05477
05478 ast_rtp_get_current_formats(newaudiortp, &peercapability, &peernoncodeccapability);
05479 ast_rtp_get_current_formats(newvideortp, &vpeercapability, &vpeernoncodeccapability);
05480
05481 newjointcapability = p->capability & (peercapability | vpeercapability);
05482 newpeercapability = (peercapability | vpeercapability);
05483 newnoncodeccapability = p->noncodeccapability & peernoncodeccapability;
05484
05485
05486 if (debug) {
05487
05488 char s1[SIPBUFSIZE], s2[SIPBUFSIZE], s3[SIPBUFSIZE], s4[SIPBUFSIZE];
05489
05490 ast_verbose("Capabilities: us - %s, peer - audio=%s/video=%s, combined - %s\n",
05491 ast_getformatname_multiple(s1, SIPBUFSIZE, p->capability),
05492 ast_getformatname_multiple(s2, SIPBUFSIZE, newpeercapability),
05493 ast_getformatname_multiple(s3, SIPBUFSIZE, vpeercapability),
05494 ast_getformatname_multiple(s4, SIPBUFSIZE, newjointcapability));
05495
05496 ast_verbose("Non-codec capabilities (dtmf): us - %s, peer - %s, combined - %s\n",
05497 ast_rtp_lookup_mime_multiple(s1, SIPBUFSIZE, p->noncodeccapability, 0, 0),
05498 ast_rtp_lookup_mime_multiple(s2, SIPBUFSIZE, peernoncodeccapability, 0, 0),
05499 ast_rtp_lookup_mime_multiple(s3, SIPBUFSIZE, newnoncodeccapability, 0, 0));
05500 }
05501 if (!newjointcapability) {
05502
05503 if (!p->t38.jointcapability || !udptlportno) {
05504 ast_log(LOG_NOTICE, "No compatible codecs, not accepting this offer!\n");
05505
05506 return -1;
05507 } else {
05508 if (option_debug > 2)
05509 ast_log(LOG_DEBUG, "Have T.38 but no audio codecs, accepting offer anyway\n");
05510 return 0;
05511 }
05512 }
05513
05514
05515
05516 p->jointcapability = newjointcapability;
05517 p->peercapability = newpeercapability;
05518 p->jointnoncodeccapability = newnoncodeccapability;
05519
05520 ast_rtp_pt_copy(p->rtp, newaudiortp);
05521 if (p->vrtp)
05522 ast_rtp_pt_copy(p->vrtp, newvideortp);
05523
05524 if (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO) {
05525 ast_clear_flag(&p->flags[0], SIP_DTMF);
05526 if (newnoncodeccapability & AST_RTP_DTMF) {
05527
05528 ast_set_flag(&p->flags[0], SIP_DTMF_RFC2833);
05529
05530 ast_rtp_setdtmf(p->rtp, 1);
05531 ast_rtp_setdtmfcompensate(p->rtp, ast_test_flag(&p->flags[1], SIP_PAGE2_RFC2833_COMPENSATE));
05532 } else {
05533 ast_set_flag(&p->flags[0], SIP_DTMF_INBAND);
05534 }
05535 }
05536
05537
05538 if (p->rtp && sin.sin_port) {
05539 ast_rtp_set_peer(p->rtp, &sin);
05540 if (debug)
05541 ast_verbose("Peer audio RTP is at port %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
05542 }
05543
05544
05545 if (p->vrtp && vsin.sin_port) {
05546 ast_rtp_set_peer(p->vrtp, &vsin);
05547 if (debug)
05548 ast_verbose("Peer video RTP is at port %s:%d\n", ast_inet_ntoa(vsin.sin_addr), ntohs(vsin.sin_port));
05549 }
05550
05551
05552 if (option_debug > 1) {
05553 char buf[SIPBUFSIZE];
05554 ast_log(LOG_DEBUG, "We're settling with these formats: %s\n", ast_getformatname_multiple(buf, SIPBUFSIZE, p->jointcapability));
05555 }
05556
05557 if (!p->owner)
05558 return 0;
05559
05560 if (option_debug > 3)
05561 ast_log(LOG_DEBUG, "We have an owner, now see if we need to change this call\n");
05562
05563 if (!(p->owner->nativeformats & p->jointcapability) && (p->jointcapability & AST_FORMAT_AUDIO_MASK)) {
05564 if (debug) {
05565 char s1[SIPBUFSIZE], s2[SIPBUFSIZE];
05566 ast_log(LOG_DEBUG, "Oooh, we need to change our audio formats since our peer supports only %s and not %s\n",
05567 ast_getformatname_multiple(s1, SIPBUFSIZE, p->jointcapability),
05568 ast_getformatname_multiple(s2, SIPBUFSIZE, p->owner->nativeformats));
05569 }
05570 p->owner->nativeformats = ast_codec_choose(&p->prefs, p->jointcapability, 1) | (p->capability & vpeercapability);
05571 ast_set_read_format(p->owner, p->owner->readformat);
05572 ast_set_write_format(p->owner, p->owner->writeformat);
05573 }
05574
05575 if (ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD) && sin.sin_addr.s_addr && (!sendonly || sendonly == -1)) {
05576 ast_queue_control(p->owner, AST_CONTROL_UNHOLD);
05577
05578 ast_queue_frame(p->owner, &ast_null_frame);
05579 } else if (!sin.sin_addr.s_addr || (sendonly && sendonly != -1)) {
05580 ast_queue_control_data(p->owner, AST_CONTROL_HOLD,
05581 S_OR(p->mohsuggest, NULL),
05582 !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0);
05583 if (sendonly)
05584 ast_rtp_stop(p->rtp);
05585
05586
05587 ast_queue_frame(p->owner, &ast_null_frame);
05588 }
05589
05590
05591 if (ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD) && sin.sin_addr.s_addr && (!sendonly || sendonly == -1))
05592 change_hold_state(p, req, FALSE, sendonly);
05593 else if (!sin.sin_addr.s_addr || (sendonly && sendonly != -1))
05594 change_hold_state(p, req, TRUE, sendonly);
05595 return 0;
05596 }
05597
05598
05599
05600 static int add_header(struct sip_request *req, const char *var, const char *value)
05601 {
05602 int maxlen = sizeof(req->data) - 4 - req->len;
05603
05604 if (req->headers == SIP_MAX_HEADERS) {
05605 ast_log(LOG_WARNING, "Out of SIP header space\n");
05606 return -1;
05607 }
05608
05609 if (req->lines) {
05610 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
05611 return -1;
05612 }
05613
05614 if (maxlen <= 0) {
05615 ast_log(LOG_WARNING, "Out of space, can't add anymore (%s:%s)\n", var, value);
05616 return -1;
05617 }
05618
05619 req->header[req->headers] = req->data + req->len;
05620
05621 if (compactheaders)
05622 var = find_alias(var, var);
05623
05624 snprintf(req->header[req->headers], maxlen, "%s: %s\r\n", var, value);
05625 req->len += strlen(req->header[req->headers]);
05626 req->headers++;
05627
05628 return 0;
05629 }
05630
05631
05632 static int add_header_contentLength(struct sip_request *req, int len)
05633 {
05634 char clen[10];
05635
05636 snprintf(clen, sizeof(clen), "%d", len);
05637 return add_header(req, "Content-Length", clen);
05638 }
05639
05640
05641 static int add_line(struct sip_request *req, const char *line)
05642 {
05643 if (req->lines == SIP_MAX_LINES) {
05644 ast_log(LOG_WARNING, "Out of SIP line space\n");
05645 return -1;
05646 }
05647 if (!req->lines) {
05648
05649 snprintf(req->data + req->len, sizeof(req->data) - req->len, "\r\n");
05650 req->len += strlen(req->data + req->len);
05651 }
05652 if (req->len >= sizeof(req->data) - 4) {
05653 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
05654 return -1;
05655 }
05656 req->line[req->lines] = req->data + req->len;
05657 snprintf(req->line[req->lines], sizeof(req->data) - req->len, "%s", line);
05658 req->len += strlen(req->line[req->lines]);
05659 req->lines++;
05660 return 0;
05661 }
05662
05663
05664 static int copy_header(struct sip_request *req, const struct sip_request *orig, const char *field)
05665 {
05666 const char *tmp = get_header(orig, field);
05667
05668 if (!ast_strlen_zero(tmp))
05669 return add_header(req, field, tmp);
05670 ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
05671 return -1;
05672 }
05673
05674
05675 static int copy_all_header(struct sip_request *req, const struct sip_request *orig, const char *field)
05676 {
05677 int start = 0;
05678 int copied = 0;
05679 for (;;) {
05680 const char *tmp = __get_header(orig, field, &start);
05681
05682 if (ast_strlen_zero(tmp))
05683 break;
05684
05685 add_header(req, field, tmp);
05686 copied++;
05687 }
05688 return copied ? 0 : -1;
05689 }
05690
05691
05692
05693
05694
05695
05696
05697 static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, const struct sip_request *orig, const char *field)
05698 {
05699 int copied = 0;
05700 int start = 0;
05701
05702 for (;;) {
05703 char new[512];
05704 const char *oh = __get_header(orig, field, &start);
05705
05706 if (ast_strlen_zero(oh))
05707 break;
05708
05709 if (!copied) {
05710 char leftmost[512], *others, *rport;
05711
05712
05713 ast_copy_string(leftmost, oh, sizeof(leftmost));
05714 others = strchr(leftmost, ',');
05715 if (others)
05716 *others++ = '\0';
05717
05718
05719 rport = strstr(leftmost, ";rport");
05720 if (rport && *(rport+6) == '=')
05721 rport = NULL;
05722
05723
05724 if (rport && ((ast_test_flag(&p->flags[0], SIP_NAT) == SIP_NAT_ALWAYS) || (ast_test_flag(&p->flags[0], SIP_NAT) == SIP_NAT_RFC3581))) {
05725
05726 char *end;
05727
05728 rport = strstr(leftmost, ";rport");
05729
05730 if (rport) {
05731 end = strchr(rport + 1, ';');
05732 if (end)
05733 memmove(rport, end, strlen(end) + 1);
05734 else
05735 *rport = '\0';
05736 }
05737
05738
05739 snprintf(new, sizeof(new), "%s;received=%s;rport=%d%s%s",
05740 leftmost, ast_inet_ntoa(p->recv.sin_addr),
05741 ntohs(p->recv.sin_port),
05742 others ? "," : "", others ? others : "");
05743 } else {
05744
05745 snprintf(new, sizeof(new), "%s;received=%s%s%s",
05746 leftmost, ast_inet_ntoa(p->recv.sin_addr),
05747 others ? "," : "", others ? others : "");
05748 }
05749 oh = new;
05750 }
05751 add_header(req, field, oh);
05752 copied++;
05753 }
05754 if (!copied) {
05755 ast_log(LOG_NOTICE, "No header field '%s' present to copy\n", field);
05756 return -1;
05757 }
05758 return 0;
05759 }
05760
05761
05762 static void add_route(struct sip_request *req, struct sip_route *route)
05763 {
05764 char r[SIPBUFSIZE*2], *p;
05765 int n, rem = sizeof(r);
05766
05767 if (!route)
05768 return;
05769
05770 p = r;
05771 for (;route ; route = route->next) {
05772 n = strlen(route->hop);
05773 if (rem < n+3)
05774 break;
05775 if (p != r) {
05776 *p++ = ',';
05777 --rem;
05778 }
05779 *p++ = '<';
05780 ast_copy_string(p, route->hop, rem);
05781 p += n;
05782 *p++ = '>';
05783 rem -= (n+2);
05784 }
05785 *p = '\0';
05786 add_header(req, "Route", r);
05787 }
05788
05789
05790 static void set_destination(struct sip_pvt *p, char *uri)
05791 {
05792 char *h, *maddr, hostname[256];
05793 int port, hn;
05794 struct hostent *hp;
05795 struct ast_hostent ahp;
05796 int debug=sip_debug_test_pvt(p);
05797
05798
05799
05800
05801 if (debug)
05802 ast_verbose("set_destination: Parsing <%s> for address/port to send to\n", uri);
05803
05804
05805 h = strchr(uri, '@');
05806 if (h)
05807 ++h;
05808 else {
05809 h = uri;
05810 if (strncasecmp(h, "sip:", 4) == 0)
05811 h += 4;
05812 else if (strncasecmp(h, "sips:", 5) == 0)
05813 h += 5;
05814 }
05815 hn = strcspn(h, ":;>") + 1;
05816 if (hn > sizeof(hostname))
05817 hn = sizeof(hostname);
05818 ast_copy_string(hostname, h, hn);
05819
05820 h += hn - 1;
05821
05822
05823 if (*h == ':') {
05824
05825 ++h;
05826 port = strtol(h, &h, 10);
05827 }
05828 else
05829 port = STANDARD_SIP_PORT;
05830
05831
05832 maddr = strstr(h, "maddr=");
05833 if (maddr) {
05834 maddr += 6;
05835 hn = strspn(maddr, "0123456789.") + 1;
05836 if (hn > sizeof(hostname))
05837 hn = sizeof(hostname);
05838 ast_copy_string(hostname, maddr, hn);
05839 }
05840
05841 hp = ast_gethostbyname(hostname, &ahp);
05842 if (hp == NULL) {
05843 ast_log(LOG_WARNING, "Can't find address for host '%s'\n", hostname);
05844 return;
05845 }
05846 p->sa.sin_family = AF_INET;
05847 memcpy(&p->sa.sin_addr, hp->h_addr, sizeof(p->sa.sin_addr));
05848 p->sa.sin_port = htons(port);
05849 if (debug)
05850 ast_verbose("set_destination: set destination to %s, port %d\n", ast_inet_ntoa(p->sa.sin_addr), port);
05851 }
05852
05853
05854 static int init_resp(struct sip_request *resp, const char *msg)
05855 {
05856
05857 memset(resp, 0, sizeof(*resp));
05858 resp->method = SIP_RESPONSE;
05859 resp->header[0] = resp->data;
05860 snprintf(resp->header[0], sizeof(resp->data), "SIP/2.0 %s\r\n", msg);
05861 resp->len = strlen(resp->header[0]);
05862 resp->headers++;
05863 return 0;
05864 }
05865
05866
05867 static int init_req(struct sip_request *req, int sipmethod, const char *recip)
05868 {
05869
05870 memset(req, 0, sizeof(*req));
05871 req->method = sipmethod;
05872 req->header[0] = req->data;
05873 snprintf(req->header[0], sizeof(req->data), "%s %s SIP/2.0\r\n", sip_methods[sipmethod].text, recip);
05874 req->len = strlen(req->header[0]);
05875 req->headers++;
05876 return 0;
05877 }
05878
05879
05880
05881 static int respprep(struct sip_request *resp, struct sip_pvt *p, const char *msg, const struct sip_request *req)
05882 {
05883 char newto[256];
05884 const char *ot;
05885
05886 init_resp(resp, msg);
05887 copy_via_headers(p, resp, req, "Via");
05888 if (msg[0] == '1' || msg[0] == '2')
05889 copy_all_header(resp, req, "Record-Route");
05890 copy_header(resp, req, "From");
05891 ot = get_header(req, "To");
05892 if (!strcasestr(ot, "tag=") && strncmp(msg, "100", 3)) {
05893
05894
05895 if (!ast_strlen_zero(p->theirtag) && ast_test_flag(&p->flags[0], SIP_OUTGOING))
05896 snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
05897 else if (p->tag && !ast_test_flag(&p->flags[0], SIP_OUTGOING))
05898 snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->tag);
05899 else
05900 ast_copy_string(newto, ot, sizeof(newto));
05901 ot = newto;
05902 }
05903 add_header(resp, "To", ot);
05904 copy_header(resp, req, "Call-ID");
05905 copy_header(resp, req, "CSeq");
05906 if (!ast_strlen_zero(global_useragent))
05907 add_header(resp, "User-Agent", global_useragent);
05908 add_header(resp, "Allow", ALLOWED_METHODS);
05909 add_header(resp, "Supported", SUPPORTED_EXTENSIONS);
05910 if (msg[0] == '2' && (p->method == SIP_SUBSCRIBE || p->method == SIP_REGISTER)) {
05911
05912
05913 char tmp[256];
05914
05915 snprintf(tmp, sizeof(tmp), "%d", p->expiry);
05916 add_header(resp, "Expires", tmp);
05917 if (p->expiry) {
05918 char contact[SIPBUFSIZE];
05919 snprintf(contact, sizeof(contact), "%s;expires=%d", p->our_contact, p->expiry);
05920 add_header(resp, "Contact", contact);
05921 }
05922 } else if (msg[0] != '4' && !ast_strlen_zero(p->our_contact)) {
05923 add_header(resp, "Contact", p->our_contact);
05924 }
05925 return 0;
05926 }
05927
05928
05929 static int reqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod, int seqno, int newbranch)
05930 {
05931 struct sip_request *orig = &p->initreq;
05932 char stripped[80];
05933 char tmp[80];
05934 char newto[256];
05935 const char *c;
05936 const char *ot, *of;
05937 int is_strict = FALSE;
05938
05939 memset(req, 0, sizeof(struct sip_request));
05940
05941 snprintf(p->lastmsg, sizeof(p->lastmsg), "Tx: %s", sip_methods[sipmethod].text);
05942
05943 if (!seqno) {
05944 p->ocseq++;
05945 seqno = p->ocseq;
05946 }
05947
05948 if (newbranch) {
05949 p->branch ^= ast_random();
05950 build_via(p);
05951 }
05952
05953
05954 if (p->route && !ast_strlen_zero(p->route->hop) && strstr(p->route->hop,";lr") == NULL) {
05955 is_strict = TRUE;
05956 if (sipdebug)
05957 ast_log(LOG_DEBUG, "Strict routing enforced for session %s\n", p->callid);
05958 }
05959
05960 if (sipmethod == SIP_CANCEL)
05961 c = p->initreq.rlPart2;
05962 else if (sipmethod == SIP_ACK) {
05963
05964
05965 if (!ast_strlen_zero(p->okcontacturi))
05966 c = is_strict ? p->route->hop : p->okcontacturi;
05967 else
05968 c = p->initreq.rlPart2;
05969 } else if (!ast_strlen_zero(p->okcontacturi))
05970 c = is_strict ? p->route->hop : p->okcontacturi;
05971 else if (!ast_strlen_zero(p->uri))
05972 c = p->uri;
05973 else {
05974 char *n;
05975
05976 ast_copy_string(stripped, get_header(orig, (ast_test_flag(&p->flags[0], SIP_OUTGOING)) ? "To" : "From"),
05977 sizeof(stripped));
05978 n = get_in_brackets(stripped);
05979 c = strsep(&n, ";");
05980 }
05981 init_req(req, sipmethod, c);
05982
05983 snprintf(tmp, sizeof(tmp), "%d %s", seqno, sip_methods[sipmethod].text);
05984
05985 add_header(req, "Via", p->via);
05986 if (p->route) {
05987 set_destination(p, p->route->hop);
05988 add_route(req, is_strict ? p->route->next : p->route);
05989 }
05990
05991 ot = get_header(orig, "To");
05992 of = get_header(orig, "From");
05993
05994
05995
05996 if (!strcasestr(ot, "tag=") && sipmethod != SIP_CANCEL) {
05997
05998
05999 if (ast_test_flag(&p->flags[0], SIP_OUTGOING) && !ast_strlen_zero(p->theirtag))
06000 snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
06001 else if (!ast_test_flag(&p->flags[0], SIP_OUTGOING))
06002 snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->tag);
06003 else
06004 snprintf(newto, sizeof(newto), "%s", ot);
06005 ot = newto;
06006 }
06007
06008 if (ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
06009 add_header(req, "From", of);
06010 add_header(req, "To", ot);
06011 } else {
06012 add_header(req, "From", ot);
06013 add_header(req, "To", of);
06014 }
06015
06016 if (sipmethod != SIP_BYE && sipmethod != SIP_CANCEL && sipmethod != SIP_MESSAGE)
06017 add_header(req, "Contact", p->our_contact);
06018
06019 copy_header(req, orig, "Call-ID");
06020 add_header(req, "CSeq", tmp);
06021
06022 if (!ast_strlen_zero(global_useragent))
06023 add_header(req, "User-Agent", global_useragent);
06024 add_header(req, "Max-Forwards", DEFAULT_MAX_FORWARDS);
06025
06026 if (!ast_strlen_zero(p->rpid))
06027 add_header(req, "Remote-Party-ID", p->rpid);
06028
06029 return 0;
06030 }
06031
06032
06033 static int __transmit_response(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable)
06034 {
06035 struct sip_request resp;
06036 int seqno = 0;
06037
06038 if (reliable && (sscanf(get_header(req, "CSeq"), "%d ", &seqno) != 1)) {
06039 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
06040 return -1;
06041 }
06042 respprep(&resp, p, msg, req);
06043 add_header_contentLength(&resp, 0);
06044
06045
06046 if (p->method == SIP_INVITE && msg[0] != '1' && p->owner && p->owner->hangupcause) {
06047 char buf[10];
06048
06049 add_header(&resp, "X-Asterisk-HangupCause", ast_cause2str(p->owner->hangupcause));
06050 snprintf(buf, sizeof(buf), "%d", p->owner->hangupcause);
06051 add_header(&resp, "X-Asterisk-HangupCauseCode", buf);
06052 }
06053 return send_response(p, &resp, reliable, seqno);
06054 }
06055
06056 static void temp_pvt_cleanup(void *data)
06057 {
06058 struct sip_pvt *p = data;
06059
06060 ast_string_field_free_memory(p);
06061
06062 free(data);
06063 }
06064
06065
06066 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)
06067 {
06068 struct sip_pvt *p = NULL;
06069
06070 if (!(p = ast_threadstorage_get(&ts_temp_pvt, sizeof(*p)))) {
06071 ast_log(LOG_NOTICE, "Failed to get temporary pvt\n");
06072 return -1;
06073 }
06074
06075
06076 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY)) {
06077 ast_set_flag(&p->flags[0], SIP_NO_HISTORY);
06078 if (ast_string_field_init(p, 512))
06079 return -1;
06080 }
06081
06082
06083 p->method = intended_method;
06084
06085 if (sin) {
06086 p->sa = *sin;
06087 if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
06088 p->ourip = __ourip;
06089 } else
06090 p->ourip = __ourip;
06091
06092 p->branch = ast_random();
06093 make_our_tag(p->tag, sizeof(p->tag));
06094 p->ocseq = INITIAL_CSEQ;
06095
06096 if (useglobal_nat && sin) {
06097 ast_copy_flags(&p->flags[0], &global_flags[0], SIP_NAT);
06098 p->recv = *sin;
06099 do_setnat(p, ast_test_flag(&p->flags[0], SIP_NAT) & SIP_NAT_ROUTE);
06100 }
06101 check_via(p, req);
06102
06103 ast_string_field_set(p, fromdomain, default_fromdomain);
06104 build_via(p);
06105 ast_string_field_set(p, callid, callid);
06106
06107
06108 __transmit_response(p, msg, req, XMIT_UNRELIABLE);
06109
06110
06111 ast_string_field_reset_all(p);
06112
06113 return 0;
06114 }
06115
06116
06117 static int transmit_response(struct sip_pvt *p, const char *msg, const struct sip_request *req)
06118 {
06119 return __transmit_response(p, msg, req, XMIT_UNRELIABLE);
06120 }
06121
06122
06123 static int transmit_response_with_unsupported(struct sip_pvt *p, const char *msg, const struct sip_request *req, const char *unsupported)
06124 {
06125 struct sip_request resp;
06126 respprep(&resp, p, msg, req);
06127 append_date(&resp);
06128 add_header(&resp, "Unsupported", unsupported);
06129 add_header_contentLength(&resp, 0);
06130 return send_response(p, &resp, XMIT_UNRELIABLE, 0);
06131 }
06132
06133
06134
06135
06136 static int transmit_response_reliable(struct sip_pvt *p, const char *msg, const struct sip_request *req)
06137 {
06138 return __transmit_response(p, msg, req, XMIT_CRITICAL);
06139 }
06140
06141
06142 static void append_date(struct sip_request *req)
06143 {
06144 char tmpdat[256];
06145 struct tm tm;
06146 time_t t = time(NULL);
06147
06148 gmtime_r(&t, &tm);
06149 strftime(tmpdat, sizeof(tmpdat), "%a, %d %b %Y %T GMT", &tm);
06150 add_header(req, "Date", tmpdat);
06151 }
06152
06153
06154 static int transmit_response_with_date(struct sip_pvt *p, const char *msg, const struct sip_request *req)
06155 {
06156 struct sip_request resp;
06157 respprep(&resp, p, msg, req);
06158 append_date(&resp);
06159 add_header_contentLength(&resp, 0);
06160 return send_response(p, &resp, XMIT_UNRELIABLE, 0);
06161 }
06162
06163
06164 static int transmit_response_with_allow(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable)
06165 {
06166 struct sip_request resp;
06167 respprep(&resp, p, msg, req);
06168 add_header(&resp, "Accept", "application/sdp");
06169 add_header_contentLength(&resp, 0);
06170 return send_response(p, &resp, reliable, 0);
06171 }
06172
06173
06174 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)
06175 {
06176 struct sip_request resp;
06177 char tmp[512];
06178 int seqno = 0;
06179
06180 if (reliable && (sscanf(get_header(req, "CSeq"), "%d ", &seqno) != 1)) {
06181 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
06182 return -1;
06183 }
06184
06185
06186 snprintf(tmp, sizeof(tmp), "Digest algorithm=MD5, realm=\"%s\", nonce=\"%s\"%s", global_realm, randdata, stale ? ", stale=true" : "");
06187 respprep(&resp, p, msg, req);
06188 add_header(&resp, header, tmp);
06189 add_header_contentLength(&resp, 0);
06190 append_history(p, "AuthChal", "Auth challenge sent for %s - nc %d", p->username, p->noncecount);
06191 return send_response(p, &resp, reliable, seqno);
06192 }
06193
06194
06195 static int add_text(struct sip_request *req, const char *text)
06196 {
06197
06198 add_header(req, "Content-Type", "text/plain");
06199 add_header_contentLength(req, strlen(text));
06200 add_line(req, text);
06201 return 0;
06202 }
06203
06204
06205
06206 static int add_digit(struct sip_request *req, char digit, unsigned int duration)
06207 {
06208 char tmp[256];
06209
06210 snprintf(tmp, sizeof(tmp), "Signal=%c\r\nDuration=%u\r\n", digit, duration);
06211 add_header(req, "Content-Type", "application/dtmf-relay");
06212 add_header_contentLength(req, strlen(tmp));
06213 add_line(req, tmp);
06214 return 0;
06215 }
06216
06217
06218
06219 static int add_vidupdate(struct sip_request *req)
06220 {
06221 const char *xml_is_a_huge_waste_of_space =
06222 "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\r\n"
06223 " <media_control>\r\n"
06224 " <vc_primitive>\r\n"
06225 " <to_encoder>\r\n"
06226 " <picture_fast_update>\r\n"
06227 " </picture_fast_update>\r\n"
06228 " </to_encoder>\r\n"
06229 " </vc_primitive>\r\n"
06230 " </media_control>\r\n";
06231 add_header(req, "Content-Type", "application/media_control+xml");
06232 add_header_contentLength(req, strlen(xml_is_a_huge_waste_of_space));
06233 add_line(req, xml_is_a_huge_waste_of_space);
06234 return 0;
06235 }
06236
06237
06238 static void add_codec_to_sdp(const struct sip_pvt *p, int codec, int sample_rate,
06239 char **m_buf, size_t *m_size, char **a_buf, size_t *a_size,
06240 int debug, int *min_packet_size)
06241 {
06242 int rtp_code;
06243 struct ast_format_list fmt;
06244
06245
06246 if (debug)
06247 ast_verbose("Adding codec 0x%x (%s) to SDP\n", codec, ast_getformatname(codec));
06248 if ((rtp_code = ast_rtp_lookup_code(p->rtp, 1, codec)) == -1)
06249 return;
06250
06251 if (p->rtp) {
06252 struct ast_codec_pref *pref = ast_rtp_codec_getpref(p->rtp);
06253 fmt = ast_codec_pref_getsize(pref, codec);
06254 } else
06255 return;
06256 ast_build_string(m_buf, m_size, " %d", rtp_code);
06257 ast_build_string(a_buf, a_size, "a=rtpmap:%d %s/%d\r\n", rtp_code,
06258 ast_rtp_lookup_mime_subtype(1, codec,
06259 ast_test_flag(&p->flags[0], SIP_G726_NONSTANDARD) ? AST_RTP_OPT_G726_NONSTANDARD : 0),
06260 sample_rate);
06261 if (codec == AST_FORMAT_G729A) {
06262
06263 ast_build_string(a_buf, a_size, "a=fmtp:%d annexb=no\r\n", rtp_code);
06264 } else if (codec == AST_FORMAT_G723_1) {
06265
06266 ast_build_string(a_buf, a_size, "a=fmtp:%d annexa=no\r\n", rtp_code);
06267 } else if (codec == AST_FORMAT_ILBC) {
06268
06269 ast_build_string(a_buf, a_size, "a=fmtp:%d mode=%d\r\n", rtp_code, fmt.cur_ms);
06270 }
06271
06272 if (fmt.cur_ms && (fmt.cur_ms < *min_packet_size))
06273 *min_packet_size = fmt.cur_ms;
06274
06275
06276 if ((*min_packet_size) == 0 && fmt.cur_ms)
06277 *min_packet_size = fmt.cur_ms;
06278 }
06279
06280
06281 static int t38_get_rate(int t38cap)
06282 {
06283 int maxrate = (t38cap & (T38FAX_RATE_14400 | T38FAX_RATE_12000 | T38FAX_RATE_9600 | T38FAX_RATE_7200 | T38FAX_RATE_4800 | T38FAX_RATE_2400));
06284
06285 if (maxrate & T38FAX_RATE_14400) {
06286 if (option_debug > 1)
06287 ast_log(LOG_DEBUG, "T38MaxFaxRate 14400 found\n");
06288 return 14400;
06289 } else if (maxrate & T38FAX_RATE_12000) {
06290 if (option_debug > 1)
06291 ast_log(LOG_DEBUG, "T38MaxFaxRate 12000 found\n");
06292 return 12000;
06293 } else if (maxrate & T38FAX_RATE_9600) {
06294 if (option_debug > 1)
06295 ast_log(LOG_DEBUG, "T38MaxFaxRate 9600 found\n");
06296 return 9600;
06297 } else if (maxrate & T38FAX_RATE_7200) {
06298 if (option_debug > 1)
06299 ast_log(LOG_DEBUG, "T38MaxFaxRate 7200 found\n");
06300 return 7200;
06301 } else if (maxrate & T38FAX_RATE_4800) {
06302 if (option_debug > 1)
06303 ast_log(LOG_DEBUG, "T38MaxFaxRate 4800 found\n");
06304 return 4800;
06305 } else if (maxrate & T38FAX_RATE_2400) {
06306 if (option_debug > 1)
06307 ast_log(LOG_DEBUG, "T38MaxFaxRate 2400 found\n");
06308 return 2400;
06309 } else {
06310 if (option_debug > 1)
06311 ast_log(LOG_DEBUG, "Strange, T38MaxFaxRate NOT found in peers T38 SDP.\n");
06312 return 0;
06313 }
06314 }
06315
06316
06317 static int add_t38_sdp(struct sip_request *resp, struct sip_pvt *p)
06318 {
06319 int len = 0;
06320 int x = 0;
06321 struct sockaddr_in udptlsin;
06322 char v[256] = "";
06323 char s[256] = "";
06324 char o[256] = "";
06325 char c[256] = "";
06326 char t[256] = "";
06327 char m_modem[256];
06328 char a_modem[1024];
06329 char *m_modem_next = m_modem;
06330 size_t m_modem_left = sizeof(m_modem);
06331 char *a_modem_next = a_modem;
06332 size_t a_modem_left = sizeof(a_modem);
06333 struct sockaddr_in udptldest = { 0, };
06334 int debug;
06335
06336 debug = sip_debug_test_pvt(p);
06337 len = 0;
06338 if (!p->udptl) {
06339 ast_log(LOG_WARNING, "No way to add SDP without an UDPTL structure\n");
06340 return -1;
06341 }
06342
06343 if (!p->sessionid) {
06344 p->sessionid = getpid();
06345 p->sessionversion = p->sessionid;
06346 } else
06347 p->sessionversion++;
06348
06349
06350 ast_udptl_get_us(p->udptl, &udptlsin);
06351
06352
06353 if (p->udptlredirip.sin_addr.s_addr) {
06354 udptldest.sin_port = p->udptlredirip.sin_port;
06355 udptldest.sin_addr = p->udptlredirip.sin_addr;
06356 } else {
06357 udptldest.sin_addr = p->ourip;
06358 udptldest.sin_port = udptlsin.sin_port;
06359 }
06360
06361 if (debug)
06362 ast_log(LOG_DEBUG, "T.38 UDPTL is at %s port %d\n", ast_inet_ntoa(p->ourip), ntohs(udptlsin.sin_port));
06363
06364
06365
06366
06367 if (debug) {
06368 ast_log(LOG_DEBUG, "Our T38 capability (%d), peer T38 capability (%d), joint capability (%d)\n",
06369 p->t38.capability,
06370 p->t38.peercapability,
06371 p->t38.jointcapability);
06372 }
06373 snprintf(v, sizeof(v), "v=0\r\n");
06374 snprintf(o, sizeof(o), "o=root %d %d IN IP4 %s\r\n", p->sessionid, p->sessionversion, ast_inet_ntoa(udptldest.sin_addr));
06375 snprintf(s, sizeof(s), "s=session\r\n");
06376 snprintf(c, sizeof(c), "c=IN IP4 %s\r\n", ast_inet_ntoa(udptldest.sin_addr));
06377 snprintf(t, sizeof(t), "t=0 0\r\n");
06378 ast_build_string(&m_modem_next, &m_modem_left, "m=image %d udptl t38\r\n", ntohs(udptldest.sin_port));
06379
06380 if ((p->t38.jointcapability & T38FAX_VERSION) == T38FAX_VERSION_0)
06381 ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxVersion:0\r\n");
06382 if ((p->t38.jointcapability & T38FAX_VERSION) == T38FAX_VERSION_1)
06383 ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxVersion:1\r\n");
06384 if ((x = t38_get_rate(p->t38.jointcapability)))
06385 ast_build_string(&a_modem_next, &a_modem_left, "a=T38MaxBitRate:%d\r\n",x);
06386 ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxFillBitRemoval:%d\r\n", (p->t38.jointcapability & T38FAX_FILL_BIT_REMOVAL) ? 1 : 0);
06387 ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxTranscodingMMR:%d\r\n", (p->t38.jointcapability & T38FAX_TRANSCODING_MMR) ? 1 : 0);
06388 ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxTranscodingJBIG:%d\r\n", (p->t38.jointcapability & T38FAX_TRANSCODING_JBIG) ? 1 : 0);
06389 ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxRateManagement:%s\r\n", (p->t38.jointcapability & T38FAX_RATE_MANAGEMENT_LOCAL_TCF) ? "localTCF" : "transferredTCF");
06390 x = ast_udptl_get_local_max_datagram(p->udptl);
06391 ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxMaxBuffer:%d\r\n",x);
06392 ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxMaxDatagram:%d\r\n",x);
06393 if (p->t38.jointcapability != T38FAX_UDP_EC_NONE)
06394 ast_build_string(&a_modem_next, &a_modem_left, "a=T38FaxUdpEC:%s\r\n", (p->t38.jointcapability & T38FAX_UDP_EC_REDUNDANCY) ? "t38UDPRedundancy" : "t38UDPFEC");
06395 len = strlen(v) + strlen(s) + strlen(o) + strlen(c) + strlen(t) + strlen(m_modem) + strlen(a_modem);
06396 add_header(resp, "Content-Type", "application/sdp");
06397 add_header_contentLength(resp, len);
06398 add_line(resp, v);
06399 add_line(resp, o);
06400 add_line(resp, s);
06401 add_line(resp, c);
06402 add_line(resp, t);
06403 add_line(resp, m_modem);
06404 add_line(resp, a_modem);
06405
06406
06407 p->lastrtprx = p->lastrtptx = time(NULL);
06408
06409 return 0;
06410 }
06411
06412
06413
06414 static void add_noncodec_to_sdp(const struct sip_pvt *p, int format, int sample_rate,
06415 char **m_buf, size_t *m_size, char **a_buf, size_t *a_size,
06416 int debug)
06417 {
06418 int rtp_code;
06419
06420 if (debug)
06421 ast_verbose("Adding non-codec 0x%x (%s) to SDP\n", format, ast_rtp_lookup_mime_subtype(0, format, 0));
06422 if ((rtp_code = ast_rtp_lookup_code(p->rtp, 0, format)) == -1)
06423 return;
06424
06425 ast_build_string(m_buf, m_size, " %d", rtp_code);
06426 ast_build_string(a_buf, a_size, "a=rtpmap:%d %s/%d\r\n", rtp_code,
06427 ast_rtp_lookup_mime_subtype(0, format, 0),
06428 sample_rate);
06429 if (format == AST_RTP_DTMF)
06430
06431 ast_build_string(a_buf, a_size, "a=fmtp:%d 0-16\r\n", rtp_code);
06432 }
06433
06434
06435
06436
06437
06438
06439 #define SDP_SAMPLE_RATE(x) 8000
06440
06441
06442 static enum sip_result add_sdp(struct sip_request *resp, struct sip_pvt *p)
06443 {
06444 int len = 0;
06445 int alreadysent = 0;
06446
06447 struct sockaddr_in sin;
06448 struct sockaddr_in vsin;
06449 struct sockaddr_in dest;
06450 struct sockaddr_in vdest = { 0, };
06451
06452
06453 char *version = "v=0\r\n";
06454 char *subject = "s=session\r\n";
06455 char owner[256];
06456 char connection[256];
06457 char *stime = "t=0 0\r\n";
06458 char bandwidth[256] = "";
06459 char *hold;
06460 char m_audio[256];
06461 char m_video[256];
06462 char a_audio[1024];
06463 char a_video[1024];
06464 char *m_audio_next = m_audio;
06465 char *m_video_next = m_video;
06466 size_t m_audio_left = sizeof(m_audio);
06467 size_t m_video_left = sizeof(m_video);
06468 char *a_audio_next = a_audio;
06469 char *a_video_next = a_video;
06470 size_t a_audio_left = sizeof(a_audio);
06471 size_t a_video_left = sizeof(a_video);
06472
06473 int x;
06474 int capability;
06475 int needvideo = FALSE;
06476 int debug = sip_debug_test_pvt(p);
06477 int min_audio_packet_size = 0;
06478 int min_video_packet_size = 0;
06479
06480 m_video[0] = '\0';
06481
06482 if (!p->rtp) {
06483 ast_log(LOG_WARNING, "No way to add SDP without an RTP structure\n");
06484 return AST_FAILURE;
06485 }
06486
06487
06488 if (!p->sessionid) {
06489 p->sessionid = getpid();
06490 p->sessionversion = p->sessionid;
06491 } else
06492 p->sessionversion++;
06493
06494
06495 ast_rtp_get_us(p->rtp, &sin);
06496 if (p->vrtp)
06497 ast_rtp_get_us(p->vrtp, &vsin);
06498
06499
06500 if (p->redirip.sin_addr.s_addr) {
06501 dest.sin_port = p->redirip.sin_port;
06502 dest.sin_addr = p->redirip.sin_addr;
06503 } else {
06504 dest.sin_addr = p->ourip;
06505 dest.sin_port = sin.sin_port;
06506 }
06507
06508 capability = p->jointcapability;
06509
06510
06511 if (option_debug > 1) {
06512 char codecbuf[SIPBUFSIZE];
06513 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");
06514 ast_log(LOG_DEBUG, "** Our prefcodec: %s \n", ast_getformatname_multiple(codecbuf, sizeof(codecbuf), p->prefcodec));
06515 }
06516
06517 #ifdef WHEN_WE_HAVE_T38_FOR_OTHER_TRANSPORTS
06518 if (ast_test_flag(&p->t38.t38support, SIP_PAGE2_T38SUPPORT_RTP)) {
06519 ast_build_string(&m_audio_next, &m_audio_left, " %d", 191);
06520 ast_build_string(&a_audio_next, &a_audio_left, "a=rtpmap:%d %s/%d\r\n", 191, "t38", 8000);
06521 }
06522 #endif
06523
06524
06525 if ((capability & AST_FORMAT_VIDEO_MASK) && !ast_test_flag(&p->flags[0], SIP_NOVIDEO)) {
06526 if (p->vrtp) {
06527 needvideo = TRUE;
06528 if (option_debug > 1)
06529 ast_log(LOG_DEBUG, "This call needs video offers!\n");
06530 } else if (option_debug > 1)
06531 ast_log(LOG_DEBUG, "This call needs video offers, but there's no video support enabled!\n");
06532 }
06533
06534
06535
06536
06537 if (needvideo) {
06538
06539 if (p->vredirip.sin_addr.s_addr) {
06540 vdest.sin_addr = p->vredirip.sin_addr;
06541 vdest.sin_port = p->vredirip.sin_port;
06542 } else {
06543 vdest.sin_addr = p->ourip;
06544 vdest.sin_port = vsin.sin_port;
06545 }
06546 ast_build_string(&m_video_next, &m_video_left, "m=video %d RTP/AVP", ntohs(vdest.sin_port));
06547
06548
06549 if (p->maxcallbitrate)
06550 snprintf(bandwidth, sizeof(bandwidth), "b=CT:%d\r\n", p->maxcallbitrate);
06551 if (debug)
06552 ast_verbose("Video is at %s port %d\n", ast_inet_ntoa(p->ourip), ntohs(vsin.sin_port));
06553 }
06554
06555 if (debug)
06556 ast_verbose("Audio is at %s port %d\n", ast_inet_ntoa(p->ourip), ntohs(sin.sin_port));
06557
06558
06559
06560
06561
06562
06563 snprintf(owner, sizeof(owner), "o=root %d %d IN IP4 %s\r\n", p->sessionid, p->sessionversion, ast_inet_ntoa(dest.sin_addr));
06564 snprintf(connection, sizeof(connection), "c=IN IP4 %s\r\n", ast_inet_ntoa(dest.sin_addr));
06565 ast_build_string(&m_audio_next, &m_audio_left, "m=audio %d RTP/AVP", ntohs(dest.sin_port));
06566
06567 if (ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD) == SIP_PAGE2_CALL_ONHOLD_ONEDIR)
06568 hold = "a=recvonly\r\n";
06569 else if (ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD) == SIP_PAGE2_CALL_ONHOLD_INACTIVE)
06570 hold = "a=inactive\r\n";
06571 else
06572 hold = "a=sendrecv\r\n";
06573
06574
06575
06576
06577
06578
06579
06580
06581
06582
06583 if (capability & p->prefcodec) {
06584 int codec = p->prefcodec & AST_FORMAT_AUDIO_MASK;
06585
06586 add_codec_to_sdp(p, codec, SDP_SAMPLE_RATE(codec),
06587 &m_audio_next, &m_audio_left,
06588 &a_audio_next, &a_audio_left,
06589 debug, &min_audio_packet_size);
06590 alreadysent |= codec;
06591 }
06592
06593
06594 for (x = 0; x < 32; x++) {
06595 int codec;
06596
06597 if (!(codec = ast_codec_pref_index(&p->prefs, x)))
06598 break;
06599
06600 if (!(capability & codec))
06601 continue;
06602
06603 if (alreadysent & codec)
06604 continue;
06605
06606 add_codec_to_sdp(p, codec, SDP_SAMPLE_RATE(codec),
06607 &m_audio_next, &m_audio_left,
06608 &a_audio_next, &a_audio_left,
06609 debug, &min_audio_packet_size);
06610 alreadysent |= codec;
06611 }
06612
06613
06614 for (x = 1; x <= (needvideo ? AST_FORMAT_MAX_VIDEO : AST_FORMAT_MAX_AUDIO); x <<= 1) {
06615 if (!(capability & x))
06616 continue;
06617
06618 if (alreadysent & x)
06619 continue;
06620
06621 if (x <= AST_FORMAT_MAX_AUDIO)
06622 add_codec_to_sdp(p, x, SDP_SAMPLE_RATE(x),
06623 &m_audio_next, &m_audio_left,
06624 &a_audio_next, &a_audio_left,
06625 debug, &min_audio_packet_size);
06626 else
06627 add_codec_to_sdp(p, x, 90000,
06628 &m_video_next, &m_video_left,
06629 &a_video_next, &a_video_left,
06630 debug, &min_video_packet_size);
06631 }
06632
06633
06634 for (x = 1; x <= AST_RTP_MAX; x <<= 1) {
06635 if (!(p->jointnoncodeccapability & x))
06636 continue;
06637
06638 add_noncodec_to_sdp(p, x, 8000,
06639 &m_audio_next, &m_audio_left,
06640 &a_audio_next, &a_audio_left,
06641 debug);
06642 }
06643
06644 if (option_debug > 2)
06645 ast_log(LOG_DEBUG, "-- Done with adding codecs to SDP\n");
06646
06647 if (!p->owner || !ast_internal_timing_enabled(p->owner))
06648 ast_build_string(&a_audio_next, &a_audio_left, "a=silenceSupp:off - - - -\r\n");
06649
06650 if (min_audio_packet_size)
06651 ast_build_string(&a_audio_next, &a_audio_left, "a=ptime:%d\r\n", min_audio_packet_size);
06652
06653 if (min_video_packet_size)
06654 ast_build_string(&a_video_next, &a_video_left, "a=ptime:%d\r\n", min_video_packet_size);
06655
06656 if ((m_audio_left < 2) || (m_video_left < 2) || (a_audio_left == 0) || (a_video_left == 0))
06657 ast_log(LOG_WARNING, "SIP SDP may be truncated due to undersized buffer!!\n");
06658
06659 ast_build_string(&m_audio_next, &m_audio_left, "\r\n");
06660 if (needvideo)
06661 ast_build_string(&m_video_next, &m_video_left, "\r\n");
06662
06663 len = strlen(version) + strlen(subject) + strlen(owner) + strlen(connection) + strlen(stime) + strlen(m_audio) + strlen(a_audio) + strlen(hold);
06664 if (needvideo)
06665 len += strlen(m_video) + strlen(a_video) + strlen(bandwidth) + strlen(hold);
06666
06667 add_header(resp, "Content-Type", "application/sdp");
06668 add_header_contentLength(resp, len);
06669 add_line(resp, version);
06670 add_line(resp, owner);
06671 add_line(resp, subject);
06672 add_line(resp, connection);
06673 if (needvideo)
06674 add_line(resp, bandwidth);
06675 add_line(resp, stime);
06676 add_line(resp, m_audio);
06677 add_line(resp, a_audio);
06678 add_line(resp, hold);
06679 if (needvideo) {
06680 add_line(resp, m_video);
06681 add_line(resp, a_video);
06682 add_line(resp, hold);
06683 }
06684
06685
06686 p->lastrtprx = p->lastrtptx = time(NULL);
06687
06688 if (option_debug > 2) {
06689 char buf[SIPBUFSIZE];
06690 ast_log(LOG_DEBUG, "Done building SDP. Settling with this capability: %s\n", ast_getformatname_multiple(buf, SIPBUFSIZE, capability));
06691 }
06692
06693 return AST_SUCCESS;
06694 }
06695
06696
06697 static int transmit_response_with_t38_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans)
06698 {
06699 struct sip_request resp;
06700 int seqno;
06701
06702 if (sscanf(get_header(req, "CSeq"), "%d ", &seqno) != 1) {
06703 ast_log(LOG_WARNING, "Unable to get seqno from '%s'\n", get_header(req, "CSeq"));
06704 return -1;
06705 }
06706 respprep(&resp, p, msg, req);
06707 if (p->udptl) {
06708 ast_udptl_offered_from_local(p->udptl, 0);
06709 add_t38_sdp(&resp, p);
06710 } else
06711 ast_log(LOG_ERROR, "Can't add SDP to response, since we have no UDPTL session allocated. Call-ID %s\n", p->callid);
06712 if (retrans && !p->pendinginvite)
06713 p->pendinginvite = seqno;
06714 return send_response(p, &resp, retrans, seqno);
06715 }
06716
06717
06718 static void copy_request(struct sip_request *dst, const struct sip_request *src)
06719 {
06720 long offset;
06721 int x;
06722 offset = ((void *)dst) - ((void *)src);
06723
06724 memcpy(dst, src, sizeof(*dst));
06725
06726 for (x=0; x < src->headers; x++)
06727 dst->header[x] += offset;
06728 for (x=0; x < src->lines; x++)
06729 dst->line[x] += offset;
06730 dst->rlPart1 += offset;
06731 dst->rlPart2 += offset;
06732 }
06733
06734
06735
06736
06737 static int transmit_response_with_sdp(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable)
06738 {
06739 struct sip_request resp;
06740 int seqno;
06741 if (sscanf(get_header(req, "CSeq"), "%d ", &seqno) != 1) {
06742 ast_log(LOG_WARNING, "Unable to get seqno from '%s'\n", get_header(req, "CSeq"));
06743 return -1;
06744 }
06745 respprep(&resp, p, msg, req);
06746 if (p->rtp) {
06747 if (!p->autoframing && !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
06748 if (option_debug)
06749 ast_log(LOG_DEBUG, "Setting framing from config on incoming call\n");
06750 ast_rtp_codec_setpref(p->rtp, &p->prefs);
06751 }
06752 try_suggested_sip_codec(p);
06753 add_sdp(&resp, p);
06754 } else
06755 ast_log(LOG_ERROR, "Can't add SDP to response, since we have no RTP session allocated. Call-ID %s\n", p->callid);
06756 if (reliable && !p->pendinginvite)
06757 p->pendinginvite = seqno;
06758 return send_response(p, &resp, reliable, seqno);
06759 }
06760
06761
06762 static int determine_firstline_parts(struct sip_request *req)
06763 {
06764 char *e = ast_skip_blanks(req->header[0]);
06765
06766 if (!*e)
06767 return -1;
06768 req->rlPart1 = e;
06769 e = ast_skip_nonblanks(e);
06770 if (*e)
06771 *e++ = '\0';
06772
06773 e = ast_skip_blanks(e);
06774 if ( !*e )
06775 return -1;
06776 ast_trim_blanks(e);
06777
06778 if (!strcasecmp(req->rlPart1, "SIP/2.0") ) {
06779 if (strlen(e) < 3)
06780 return -1;
06781 req->rlPart2 = e;
06782 } else {
06783 if ( *e == '<' ) {
06784 ast_log(LOG_WARNING, "bogus uri in <> %s\n", e);
06785 e++;
06786 if (!*e)
06787 return -1;
06788 }
06789 req->rlPart2 = e;
06790 e = ast_skip_nonblanks(e);
06791 if (*e)
06792 *e++ = '\0';
06793 e = ast_skip_blanks(e);
06794 if (strcasecmp(e, "SIP/2.0") ) {
06795 ast_log(LOG_WARNING, "Bad request protocol %s\n", e);
06796 return -1;
06797 }
06798 }
06799 return 1;
06800 }
06801
06802
06803
06804
06805
06806
06807
06808 static int transmit_reinvite_with_sdp(struct sip_pvt *p)
06809 {
06810 struct sip_request req;
06811
06812 reqprep(&req, p, ast_test_flag(&p->flags[0], SIP_REINVITE_UPDATE) ? SIP_UPDATE : SIP_INVITE, 0, 1);
06813
06814 add_header(&req, "Allow", ALLOWED_METHODS);
06815 add_header(&req, "Supported", SUPPORTED_EXTENSIONS);
06816 if (sipdebug)
06817 add_header(&req, "X-asterisk-Info", "SIP re-invite (External RTP bridge)");
06818 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
06819 append_history(p, "ReInv", "Re-invite sent");
06820 add_sdp(&req, p);
06821
06822 initialize_initreq(p, &req);
06823 p->lastinvite = p->ocseq;
06824 ast_set_flag(&p->flags[0], SIP_OUTGOING);
06825 return send_request(p, &req, XMIT_CRITICAL, p->ocseq);
06826 }
06827
06828
06829
06830
06831
06832 static int transmit_reinvite_with_t38_sdp(struct sip_pvt *p)
06833 {
06834 struct sip_request req;
06835
06836 reqprep(&req, p, ast_test_flag(&p->flags[0], SIP_REINVITE_UPDATE) ? SIP_UPDATE : SIP_INVITE, 0, 1);
06837
06838 add_header(&req, "Allow", ALLOWED_METHODS);
06839 add_header(&req, "Supported", SUPPORTED_EXTENSIONS);
06840 if (sipdebug)
06841 add_header(&req, "X-asterisk-info", "SIP re-invite (T38 switchover)");
06842 ast_udptl_offered_from_local(p->udptl, 1);
06843 add_t38_sdp(&req, p);
06844
06845 initialize_initreq(p, &req);
06846 ast_set_flag(&p->flags[0], SIP_OUTGOING);
06847 p->lastinvite = p->ocseq;
06848 return send_request(p, &req, XMIT_CRITICAL, p->ocseq);
06849 }
06850
06851
06852 static void extract_uri(struct sip_pvt *p, struct sip_request *req)
06853 {
06854 char stripped[SIPBUFSIZE];
06855 char *c;
06856
06857 ast_copy_string(stripped, get_header(req, "Contact"), sizeof(stripped));
06858 c = get_in_brackets(stripped);
06859 c = strsep(&c, ";");
06860 if (!ast_strlen_zero(c))
06861 ast_string_field_set(p, uri, c);
06862 }
06863
06864
06865 static void build_contact(struct sip_pvt *p)
06866 {
06867
06868 if (ourport != STANDARD_SIP_PORT)
06869 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);
06870 else
06871 ast_string_field_build(p, our_contact, "<sip:%s%s%s>", p->exten, ast_strlen_zero(p->exten) ? "" : "@", ast_inet_ntoa(p->ourip));
06872 }
06873
06874
06875 static void build_rpid(struct sip_pvt *p)
06876 {
06877 int send_pres_tags = TRUE;
06878 const char *privacy=NULL;
06879 const char *screen=NULL;
06880 char buf[256];
06881 const char *clid = default_callerid;
06882 const char *clin = NULL;
06883 const char *fromdomain;
06884
06885 if (!ast_strlen_zero(p->rpid) || !ast_strlen_zero(p->rpid_from))
06886 return;
06887
06888 if (p->owner && p->owner->cid.cid_num)
06889 clid = p->owner->cid.cid_num;
06890 if (p->owner && p->owner->cid.cid_name)
06891 clin = p->owner->cid.cid_name;
06892 if (ast_strlen_zero(clin))
06893 clin = clid;
06894
06895 switch (p->callingpres) {
06896 case AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED:
06897 privacy = "off";
06898 screen = "no";
06899 break;
06900 case AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN:
06901 privacy = "off";
06902 screen = "yes";
06903 break;
06904 case AST_PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN:
06905 privacy = "off";
06906 screen = "no";
06907 break;
06908 case AST_PRES_ALLOWED_NETWORK_NUMBER:
06909 privacy = "off";
06910 screen = "yes";
06911 break;
06912 case AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED:
06913 privacy = "full";
06914 screen = "no";
06915 break;
06916 case AST_PRES_PROHIB_USER_NUMBER_PASSED_SCREEN:
06917 privacy = "full";
06918 screen = "yes";
06919 break;
06920 case AST_PRES_PROHIB_USER_NUMBER_FAILED_SCREEN:
06921 privacy = "full";
06922 screen = "no";
06923 break;
06924 case AST_PRES_PROHIB_NETWORK_NUMBER:
06925 privacy = "full";
06926 screen = "yes";
06927 break;
06928 case AST_PRES_NUMBER_NOT_AVAILABLE:
06929 send_pres_tags = FALSE;
06930 break;
06931 default:
06932 ast_log(LOG_WARNING, "Unsupported callingpres (%d)\n", p->callingpres);
06933 if ((p->callingpres & AST_PRES_RESTRICTION) != AST_PRES_ALLOWED)
06934 privacy = "full";
06935 else
06936 privacy = "off";
06937 screen = "no";
06938 break;
06939 }
06940
06941 fromdomain = S_OR(p->fromdomain, ast_inet_ntoa(p->ourip));
06942
06943 snprintf(buf, sizeof(buf), "\"%s\" <sip:%s@%s>", clin, clid, fromdomain);
06944 if (send_pres_tags)
06945 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), ";privacy=%s;screen=%s", privacy, screen);
06946 ast_string_field_set(p, rpid, buf);
06947
06948 ast_string_field_build(p, rpid_from, "\"%s\" <sip:%s@%s>;tag=%s", clin,
06949 S_OR(p->fromuser, clid),
06950 fromdomain, p->tag);
06951 }
06952
06953
06954 static void initreqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod)
06955 {
06956 char invite_buf[256] = "";
06957 char *invite = invite_buf;
06958 size_t invite_max = sizeof(invite_buf);
06959 char from[256];
06960 char to[256];
06961 char tmp[SIPBUFSIZE/2];
06962 char tmp2[SIPBUFSIZE/2];
06963 const char *l = NULL, *n = NULL;
06964 const char *urioptions = "";
06965
06966 if (ast_test_flag(&p->flags[0], SIP_USEREQPHONE)) {
06967 const char *s = p->username;
06968
06969
06970
06971
06972
06973
06974 if (*s == '+')
06975 s++;
06976 for (; *s; s++) {
06977 if (!strchr(AST_DIGIT_ANYNUM, *s) )
06978 break;
06979 }
06980
06981 if (*s)
06982 urioptions = ";user=phone";
06983 }
06984
06985
06986 snprintf(p->lastmsg, sizeof(p->lastmsg), "Init: %s", sip_methods[sipmethod].text);
06987
06988 if (p->owner) {
06989 l = p->owner->cid.cid_num;
06990 n = p->owner->cid.cid_name;
06991 }
06992
06993 if (!ast_test_flag(&p->flags[0], SIP_SENDRPID) &&
06994 ((p->callingpres & AST_PRES_RESTRICTION) != AST_PRES_ALLOWED)) {
06995 l = CALLERID_UNKNOWN;
06996 n = l;
06997 }
06998 if (ast_strlen_zero(l))
06999 l = default_callerid;
07000 if (ast_strlen_zero(n))
07001 n = l;
07002
07003 if (!ast_strlen_zero(p->fromuser))
07004 l = p->fromuser;
07005 else
07006 ast_string_field_set(p, fromuser, l);
07007
07008
07009 if (!ast_strlen_zero(p->fromname))
07010 n = p->fromname;
07011 else
07012 ast_string_field_set(p, fromname, n);
07013
07014 if (pedanticsipchecking) {
07015 ast_uri_encode(n, tmp, sizeof(tmp), 0);
07016 n = tmp;
07017 ast_uri_encode(l, tmp2, sizeof(tmp2), 0);
07018 l = tmp2;
07019 }
07020
07021 if (ourport != STANDARD_SIP_PORT && ast_strlen_zero(p->fromdomain))
07022 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);
07023 else
07024 snprintf(from, sizeof(from), "\"%s\" <sip:%s@%s>;tag=%s", n, l, S_OR(p->fromdomain, ast_inet_ntoa(p->ourip)), p->tag);
07025
07026
07027 if (!ast_strlen_zero(p->fullcontact)) {
07028
07029 ast_build_string(&invite, &invite_max, "%s", p->fullcontact);
07030 } else {
07031
07032 ast_build_string(&invite, &invite_max, "sip:");
07033 if (!ast_strlen_zero(p->username)) {
07034 n = p->username;
07035 if (pedanticsipchecking) {
07036 ast_uri_encode(n, tmp, sizeof(tmp), 0);
07037 n = tmp;
07038 }
07039 ast_build_string(&invite, &invite_max, "%s@", n);
07040 }
07041 ast_build_string(&invite, &invite_max, "%s", p->tohost);
07042 if (ntohs(p->sa.sin_port) != STANDARD_SIP_PORT)
07043 ast_build_string(&invite, &invite_max, ":%d", ntohs(p->sa.sin_port));
07044 ast_build_string(&invite, &invite_max, "%s", urioptions);
07045 }
07046
07047
07048 if (p->options && !ast_strlen_zero(p->options->uri_options))
07049 ast_build_string(&invite, &invite_max, ";%s", p->options->uri_options);
07050
07051 ast_string_field_set(p, uri, invite_buf);
07052
07053 if (sipmethod == SIP_NOTIFY && !ast_strlen_zero(p->theirtag)) {
07054
07055 snprintf(to, sizeof(to), "<%s%s>;tag=%s", (strncasecmp(p->uri, "sip:", 4) ? "" : "sip:"), p->uri, p->theirtag);
07056 } else if (p->options && p->options->vxml_url) {
07057
07058 snprintf(to, sizeof(to), "<%s>;%s", p->uri, p->options->vxml_url);
07059 } else
07060 snprintf(to, sizeof(to), "<%s>", p->uri);
07061
07062 init_req(req, sipmethod, p->uri);
07063 snprintf(tmp, sizeof(tmp), "%d %s", ++p->ocseq, sip_methods[sipmethod].text);
07064
07065 add_header(req, "Via", p->via);
07066
07067
07068
07069 if (ast_test_flag(&p->flags[0], SIP_SENDRPID) && (sipmethod == SIP_INVITE)) {
07070 build_rpid(p);
07071 add_header(req, "From", p->rpid_from);
07072 } else
07073 add_header(req, "From", from);
07074 add_header(req, "To", to);
07075 ast_string_field_set(p, exten, l);
07076 build_contact(p);
07077 add_header(req, "Contact", p->our_contact);
07078 add_header(req, "Call-ID", p->callid);
07079 add_header(req, "CSeq", tmp);
07080 if (!ast_strlen_zero(global_useragent))
07081 add_header(req, "User-Agent", global_useragent);
07082 add_header(req, "Max-Forwards", DEFAULT_MAX_FORWARDS);
07083 if (!ast_strlen_zero(p->rpid))
07084 add_header(req, "Remote-Party-ID", p->rpid);
07085 }
07086
07087
07088 static int transmit_invite(struct sip_pvt *p, int sipmethod, int sdp, int init)
07089 {
07090 struct sip_request req;
07091
07092 req.method = sipmethod;
07093 if (init) {
07094
07095 p->branch ^= ast_random();
07096 build_via(p);
07097 if (init > 1)
07098 initreqprep(&req, p, sipmethod);
07099 else
07100 reqprep(&req, p, sipmethod, 0, 1);
07101 } else
07102 reqprep(&req, p, sipmethod, 0, 1);
07103
07104 if (p->options && p->options->auth)
07105 add_header(&req, p->options->authheader, p->options->auth);
07106 append_date(&req);
07107 if (sipmethod == SIP_REFER) {
07108 if (p->refer) {
07109 char buf[SIPBUFSIZE];
07110 if (!ast_strlen_zero(p->refer->refer_to))
07111 add_header(&req, "Refer-To", p->refer->refer_to);
07112 if (!ast_strlen_zero(p->refer->referred_by)) {
07113 snprintf(buf, sizeof(buf), "%s <%s>", p->refer->referred_by_name, p->refer->referred_by);
07114 add_header(&req, "Referred-By", buf);
07115 }
07116 }
07117 }
07118
07119
07120 if (p->options && p->options->replaces && !ast_strlen_zero(p->options->replaces)) {
07121 add_header(&req, "Replaces", p->options->replaces);
07122 add_header(&req, "Require", "replaces");
07123 }
07124
07125 add_header(&req, "Allow", ALLOWED_METHODS);
07126 add_header(&req, "Supported", SUPPORTED_EXTENSIONS);
07127 if (p->options && p->options->addsipheaders && p->owner) {
07128 struct ast_channel *chan = p->owner;
07129 struct varshead *headp;
07130
07131 ast_channel_lock(chan);
07132
07133 headp = &chan->varshead;
07134
07135 if (!headp)
07136 ast_log(LOG_WARNING,"No Headp for the channel...ooops!\n");
07137 else {
07138 const struct ast_var_t *current;
07139 AST_LIST_TRAVERSE(headp, current, entries) {
07140
07141 if (!strncasecmp(ast_var_name(current), "SIPADDHEADER", strlen("SIPADDHEADER"))) {
07142 char *content, *end;
07143 const char *header = ast_var_value(current);
07144 char *headdup = ast_strdupa(header);
07145
07146
07147 if (*headdup == '"')
07148 headdup++;
07149 if ((content = strchr(headdup, ':'))) {
07150 *content++ = '\0';
07151 content = ast_skip_blanks(content);
07152
07153 end = content + strlen(content) -1;
07154 if (*end == '"')
07155 *end = '\0';
07156
07157 add_header(&req, headdup, content);
07158 if (sipdebug)
07159 ast_log(LOG_DEBUG, "Adding SIP Header \"%s\" with content :%s: \n", headdup, content);
07160 }
07161 }
07162 }
07163 }
07164
07165 ast_channel_unlock(chan);
07166 }
07167 if (sdp) {
07168 if (p->udptl && (p->t38.state == T38_LOCAL_DIRECT || p->t38.state == T38_LOCAL_REINVITE)) {
07169 ast_udptl_offered_from_local(p->udptl, 1);
07170 if (option_debug)
07171 ast_log(LOG_DEBUG, "T38 is in state %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
07172 add_t38_sdp(&req, p);
07173 } else if (p->rtp)
07174 add_sdp(&req, p);
07175 } else {
07176 add_header_contentLength(&req, 0);
07177 }
07178
07179 if (!p->initreq.headers || init > 2)
07180 initialize_initreq(p, &req);
07181 p->lastinvite = p->ocseq;
07182 return send_request(p, &req, init ? XMIT_CRITICAL : XMIT_RELIABLE, p->ocseq);
07183 }
07184
07185
07186 static int transmit_state_notify(struct sip_pvt *p, int state, int full, int timeout)
07187 {
07188 char tmp[4000], from[256], to[256];
07189 char *t = tmp, *c, *mfrom, *mto;
07190 size_t maxbytes = sizeof(tmp);
07191 struct sip_request req;
07192 char hint[AST_MAX_EXTENSION];
07193 char *statestring = "terminated";
07194 const struct cfsubscription_types *subscriptiontype;
07195 enum state { NOTIFY_OPEN, NOTIFY_INUSE, NOTIFY_CLOSED } local_state = NOTIFY_OPEN;
07196 char *pidfstate = "--";
07197 char *pidfnote= "Ready";
07198
07199 memset(from, 0, sizeof(from));
07200 memset(to, 0, sizeof(to));
07201 memset(tmp, 0, sizeof(tmp));
07202
07203 switch (state) {
07204 case (AST_EXTENSION_RINGING | AST_EXTENSION_INUSE):
07205 statestring = (global_notifyringing) ? "early" : "confirmed";
07206 local_state = NOTIFY_INUSE;
07207 pidfstate = "busy";
07208 pidfnote = "Ringing";
07209 break;
07210 case AST_EXTENSION_RINGING:
07211 statestring = "early";
07212 local_state = NOTIFY_INUSE;
07213 pidfstate = "busy";
07214 pidfnote = "Ringing";
07215 break;
07216 case AST_EXTENSION_INUSE:
07217 statestring = "confirmed";
07218 local_state = NOTIFY_INUSE;
07219 pidfstate = "busy";
07220 pidfnote = "On the phone";
07221 break;
07222 case AST_EXTENSION_BUSY:
07223 statestring = "confirmed";
07224 local_state = NOTIFY_CLOSED;
07225 pidfstate = "busy";
07226 pidfnote = "On the phone";
07227 break;
07228 case AST_EXTENSION_UNAVAILABLE:
07229 statestring = "terminated";
07230 local_state = NOTIFY_CLOSED;
07231 pidfstate = "away";
07232 pidfnote = "Unavailable";
07233 break;
07234 case AST_EXTENSION_ONHOLD:
07235 statestring = "confirmed";
07236 local_state = NOTIFY_CLOSED;
07237 pidfstate = "busy";
07238 pidfnote = "On Hold";
07239 break;
07240 case AST_EXTENSION_NOT_INUSE:
07241 default:
07242
07243 break;
07244 }
07245
07246 subscriptiontype = find_subscription_type(p->subscribed);
07247
07248
07249 if (ast_get_hint(hint, sizeof(hint), NULL, 0, NULL, p->context, p->exten)) {
07250 char *hint2 = hint, *individual_hint = NULL;
07251 int hint_count = 0, unavailable_count = 0;
07252
07253 while ((individual_hint = strsep(&hint2, "&"))) {
07254 hint_count++;
07255
07256 if (ast_device_state(individual_hint) == AST_DEVICE_UNAVAILABLE)
07257 unavailable_count++;
07258 }
07259
07260
07261
07262
07263 if (hint_count > 0 && hint_count == unavailable_count) {
07264 local_state = NOTIFY_CLOSED;
07265 pidfstate = "away";
07266 pidfnote = "Not online";
07267 }
07268 }
07269
07270 ast_copy_string(from, get_header(&p->initreq, "From"), sizeof(from));
07271 c = get_in_brackets(from);
07272 if (strncasecmp(c, "sip:", 4)) {
07273 ast_log(LOG_WARNING, "Huh? Not a SIP header (%s)?\n", c);
07274 return -1;
07275 }
07276 mfrom = strsep(&c, ";");
07277
07278 ast_copy_string(to, get_header(&p->initreq, "To"), sizeof(to));
07279 c = get_in_brackets(to);
07280 if (strncasecmp(c, "sip:", 4)) {
07281 ast_log(LOG_WARNING, "Huh? Not a SIP header (%s)?\n", c);
07282 return -1;
07283 }
07284 mto = strsep(&c, ";");
07285
07286 reqprep(&req, p, SIP_NOTIFY, 0, 1);
07287
07288
07289 add_header(&req, "Event", subscriptiontype->event);
07290 add_header(&req, "Content-Type", subscriptiontype->mediatype);
07291 switch(state) {
07292 case AST_EXTENSION_DEACTIVATED:
07293 if (timeout)
07294 add_header(&req, "Subscription-State", "terminated;reason=timeout");
07295 else {
07296 add_header(&req, "Subscription-State", "terminated;reason=probation");
07297 add_header(&req, "Retry-After", "60");
07298 }
07299 break;
07300 case AST_EXTENSION_REMOVED:
07301 add_header(&req, "Subscription-State", "terminated;reason=noresource");
07302 break;
07303 default:
07304 if (p->expiry)
07305 add_header(&req, "Subscription-State", "active");
07306 else
07307 add_header(&req, "Subscription-State", "terminated;reason=timeout");
07308 }
07309 switch (p->subscribed) {
07310 case XPIDF_XML:
07311 case CPIM_PIDF_XML:
07312 ast_build_string(&t, &maxbytes, "<?xml version=\"1.0\"?>\n");
07313 ast_build_string(&t, &maxbytes, "<!DOCTYPE presence PUBLIC \"-//IETF//DTD RFCxxxx XPIDF 1.0//EN\" \"xpidf.dtd\">\n");
07314 ast_build_string(&t, &maxbytes, "<presence>\n");
07315 ast_build_string(&t, &maxbytes, "<presentity uri=\"%s;method=SUBSCRIBE\" />\n", mfrom);
07316 ast_build_string(&t, &maxbytes, "<atom id=\"%s\">\n", p->exten);
07317 ast_build_string(&t, &maxbytes, "<address uri=\"%s;user=ip\" priority=\"0.800000\">\n", mto);
07318 ast_build_string(&t, &maxbytes, "<status status=\"%s\" />\n", (local_state == NOTIFY_OPEN) ? "open" : (local_state == NOTIFY_INUSE) ? "inuse" : "closed");
07319 ast_build_string(&t, &maxbytes, "<msnsubstatus substatus=\"%s\" />\n", (local_state == NOTIFY_OPEN) ? "online" : (local_state == NOTIFY_INUSE) ? "onthephone" : "offline");
07320 ast_build_string(&t, &maxbytes, "</address>\n</atom>\n</presence>\n");
07321 break;
07322 case PIDF_XML:
07323 ast_build_string(&t, &maxbytes, "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n");
07324 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);
07325 ast_build_string(&t, &maxbytes, "<pp:person><status>\n");
07326 if (pidfstate[0] != '-')
07327 ast_build_string(&t, &maxbytes, "<ep:activities><ep:%s/></ep:activities>\n", pidfstate);
07328 ast_build_string(&t, &maxbytes, "</status></pp:person>\n");
07329 ast_build_string(&t, &maxbytes, "<note>%s</note>\n", pidfnote);
07330 ast_build_string(&t, &maxbytes, "<tuple id=\"%s\">\n", p->exten);
07331 ast_build_string(&t, &maxbytes, "<contact priority=\"1\">%s</contact>\n", mto);
07332 if (pidfstate[0] == 'b')
07333 ast_build_string(&t, &maxbytes, "<status><basic>open</basic></status>\n");
07334 else
07335 ast_build_string(&t, &maxbytes, "<status><basic>%s</basic></status>\n", (local_state != NOTIFY_CLOSED) ? "open" : "closed");
07336 ast_build_string(&t, &maxbytes, "</tuple>\n</presence>\n");
07337 break;
07338 case DIALOG_INFO_XML:
07339 ast_build_string(&t, &maxbytes, "<?xml version=\"1.0\"?>\n");
07340 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);
07341 if ((state & AST_EXTENSION_RINGING) && global_notifyringing)
07342 ast_build_string(&t, &maxbytes, "<dialog id=\"%s\" direction=\"recipient\">\n", p->exten);
07343 else
07344 ast_build_string(&t, &maxbytes, "<dialog id=\"%s\">\n", p->exten);
07345 ast_build_string(&t, &maxbytes, "<state>%s</state>\n", statestring);
07346 if (state == AST_EXTENSION_ONHOLD) {
07347 ast_build_string(&t, &maxbytes, "<local>\n<target uri=\"%s\">\n"
07348 "<param pname=\"+sip.rendering\" pvalue=\"no\">\n"
07349 "</target>\n</local>\n", mto);
07350 }
07351 ast_build_string(&t, &maxbytes, "</dialog>\n</dialog-info>\n");
07352 break;
07353 case NONE:
07354 default:
07355 break;
07356 }
07357
07358 if (t > tmp + sizeof(tmp))
07359 ast_log(LOG_WARNING, "Buffer overflow detected!! (Please file a bug report)\n");
07360
07361 add_header_contentLength(&req, strlen(tmp));
07362 add_line(&req, tmp);
07363 p->pendinginvite = p->ocseq;
07364
07365 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
07366 }
07367
07368
07369
07370
07371
07372
07373
07374 static int transmit_notify_with_mwi(struct sip_pvt *p, int newmsgs, int oldmsgs, char *vmexten)
07375 {
07376 struct sip_request req;
07377 char tmp[500];
07378 char *t = tmp;
07379 size_t maxbytes = sizeof(tmp);
07380
07381 initreqprep(&req, p, SIP_NOTIFY);
07382 add_header(&req, "Event", "message-summary");
07383 add_header(&req, "Content-Type", default_notifymime);
07384
07385 ast_build_string(&t, &maxbytes, "Messages-Waiting: %s\r\n", newmsgs ? "yes" : "no");
07386 ast_build_string(&t, &maxbytes, "Message-Account: sip:%s@%s\r\n",
07387 S_OR(vmexten, default_vmexten), S_OR(p->fromdomain, ast_inet_ntoa(p->ourip)));
07388
07389
07390
07391 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)"));
07392
07393 if (p->subscribed) {
07394 if (p->expiry)
07395 add_header(&req, "Subscription-State", "active");
07396 else
07397 add_header(&req, "Subscription-State", "terminated;reason=timeout");
07398 }
07399
07400 if (t > tmp + sizeof(tmp))
07401 ast_log(LOG_WARNING, "Buffer overflow detected!! (Please file a bug report)\n");
07402
07403 add_header_contentLength(&req, strlen(tmp));
07404 add_line(&req, tmp);
07405
07406 if (!p->initreq.headers)
07407 initialize_initreq(p, &req);
07408 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
07409 }
07410
07411
07412 static int transmit_sip_request(struct sip_pvt *p, struct sip_request *req)
07413 {
07414 if (!p->initreq.headers)
07415 initialize_initreq(p, req);
07416 return send_request(p, req, XMIT_UNRELIABLE, p->ocseq);
07417 }
07418
07419
07420 static int transmit_notify_with_sipfrag(struct sip_pvt *p, int cseq, char *message, int terminate)
07421 {
07422 struct sip_request req;
07423 char tmp[SIPBUFSIZE/2];
07424
07425 reqprep(&req, p, SIP_NOTIFY, 0, 1);
07426 snprintf(tmp, sizeof(tmp), "refer;id=%d", cseq);
07427 add_header(&req, "Event", tmp);
07428 add_header(&req, "Subscription-state", terminate ? "terminated;reason=noresource" : "active");
07429 add_header(&req, "Content-Type", "message/sipfrag;version=2.0");
07430 add_header(&req, "Allow", ALLOWED_METHODS);
07431 add_header(&req, "Supported", SUPPORTED_EXTENSIONS);
07432
07433 snprintf(tmp, sizeof(tmp), "SIP/2.0 %s\r\n", message);
07434 add_header_contentLength(&req, strlen(tmp));
07435 add_line(&req, tmp);
07436
07437 if (!p->initreq.headers)
07438 initialize_initreq(p, &req);
07439
07440 p->lastnoninvite = p->ocseq;
07441
07442 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
07443 }
07444
07445
07446 static char *regstate2str(enum sipregistrystate regstate)
07447 {
07448 switch(regstate) {
07449 case REG_STATE_FAILED:
07450 return "Failed";
07451 case REG_STATE_UNREGISTERED:
07452 return "Unregistered";
07453 case REG_STATE_REGSENT:
07454 return "Request Sent";
07455 case REG_STATE_AUTHSENT:
07456 return "Auth. Sent";
07457 case REG_STATE_REGISTERED:
07458 return "Registered";
07459 case REG_STATE_REJECTED:
07460 return "Rejected";
07461 case REG_STATE_TIMEOUT:
07462 return "Timeout";
07463 case REG_STATE_NOAUTH:
07464 return "No Authentication";
07465 default:
07466 return "Unknown";
07467 }
07468 }
07469
07470
07471 static int sip_reregister(const void *data)
07472 {
07473
07474 struct sip_registry *r= ASTOBJ_REF((struct sip_registry *) data);
07475
07476
07477 if (!r)
07478 return 0;
07479
07480 if (r->call && !ast_test_flag(&r->call->flags[0], SIP_NO_HISTORY))
07481 append_history(r->call, "RegistryRenew", "Account: %s@%s", r->username, r->hostname);
07482
07483
07484 if (sipdebug)
07485 ast_log(LOG_NOTICE, " -- Re-registration for %s@%s\n", r->username, r->hostname);
07486
07487 r->expire = -1;
07488 __sip_do_register(r);
07489 ASTOBJ_UNREF(r, sip_registry_destroy);
07490 return 0;
07491 }
07492
07493
07494 static int __sip_do_register(struct sip_registry *r)
07495 {
07496 int res;
07497
07498 res = transmit_register(r, SIP_REGISTER, NULL, NULL);
07499 return res;
07500 }
07501
07502
07503 static int sip_reg_timeout(const void *data)
07504 {
07505
07506
07507 struct sip_registry *r = ASTOBJ_REF((struct sip_registry *) data);
07508 struct sip_pvt *p;
07509 int res;
07510
07511
07512 if (!r)
07513 return 0;
07514
07515 ast_log(LOG_NOTICE, " -- Registration for '%s@%s' timed out, trying again (Attempt #%d)\n", r->username, r->hostname, r->regattempts);
07516 if (r->call) {
07517
07518
07519 p = r->call;
07520 ast_mutex_lock(&p->lock);
07521 if (p->registry)
07522 ASTOBJ_UNREF(p->registry, sip_registry_destroy);
07523 r->call = NULL;
07524 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
07525
07526 __sip_pretend_ack(p);
07527 ast_mutex_unlock(&p->lock);
07528 }
07529
07530 if (global_regattempts_max && (r->regattempts > global_regattempts_max)) {
07531
07532
07533
07534 ast_log(LOG_NOTICE, " -- Giving up forever trying to register '%s@%s'\n", r->username, r->hostname);
07535 r->regstate = REG_STATE_FAILED;
07536 } else {
07537 r->regstate = REG_STATE_UNREGISTERED;
07538 r->timeout = -1;
07539 res=transmit_register(r, SIP_REGISTER, NULL, NULL);
07540 }
07541 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));
07542 ASTOBJ_UNREF(r, sip_registry_destroy);
07543 return 0;
07544 }
07545
07546
07547 static int transmit_register(struct sip_registry *r, int sipmethod, const char *auth, const char *authheader)
07548 {
07549 struct sip_request req;
07550 char from[256];
07551 char to[256];
07552 char tmp[80];
07553 char addr[80];
07554 struct sip_pvt *p;
07555
07556
07557 if ( r == NULL || ((auth==NULL) && (r->regstate==REG_STATE_REGSENT || r->regstate==REG_STATE_AUTHSENT))) {
07558 ast_log(LOG_NOTICE, "Strange, trying to register %s@%s when registration already pending\n", r->username, r->hostname);
07559 return 0;
07560 }
07561
07562 if (r->call) {
07563 if (!auth) {
07564 ast_log(LOG_WARNING, "Already have a REGISTER going on to %s@%s?? \n", r->username, r->hostname);
07565 return 0;
07566 } else {
07567 p = r->call;
07568 make_our_tag(p->tag, sizeof(p->tag));
07569 ast_string_field_free(p, theirtag);
07570 }
07571 } else {
07572
07573 if (!r->callid_valid) {
07574 build_callid_registry(r, __ourip, default_fromdomain);
07575 r->callid_valid = TRUE;
07576 }
07577
07578 if (!(p = sip_alloc( r->callid, NULL, 0, SIP_REGISTER))) {
07579 ast_log(LOG_WARNING, "Unable to allocate registration transaction (memory or socket error)\n");
07580 return 0;
07581 }
07582 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
07583 append_history(p, "RegistryInit", "Account: %s@%s", r->username, r->hostname);
07584
07585 if (create_addr(p, r->hostname)) {
07586
07587
07588 sip_destroy(p);
07589
07590 if (r->timeout > -1)
07591 ast_log(LOG_WARNING, "Still have a registration timeout for %s@%s (create_addr() error), %d\n", r->username, r->hostname, r->timeout);
07592 else
07593 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);
07594
07595 AST_SCHED_DEL(sched, r->timeout);
07596 r->timeout = ast_sched_add(sched, global_reg_timeout * 1000, sip_reg_timeout, r);
07597 r->regattempts++;
07598 return 0;
07599 }
07600
07601 ast_string_field_set(r, callid, p->callid);
07602 if (r->portno) {
07603 p->sa.sin_port = htons(r->portno);
07604 p->recv.sin_port = htons(r->portno);
07605 } else
07606 r->portno = ntohs(p->sa.sin_port);
07607 ast_set_flag(&p->flags[0], SIP_OUTGOING);
07608 r->call=p;
07609 p->registry = ASTOBJ_REF(r);
07610 if (!ast_strlen_zero(r->secret))
07611 ast_string_field_set(p, peersecret, r->secret);
07612 if (!ast_strlen_zero(r->md5secret))
07613 ast_string_field_set(p, peermd5secret, r->md5secret);
07614
07615
07616 if (!ast_strlen_zero(r->authuser)) {
07617 ast_string_field_set(p, peername, r->authuser);
07618 ast_string_field_set(p, authname, r->authuser);
07619 } else if (!ast_strlen_zero(r->username)) {
07620 ast_string_field_set(p, peername, r->username);
07621 ast_string_field_set(p, authname, r->username);
07622 ast_string_field_set(p, fromuser, r->username);
07623 }
07624 if (!ast_strlen_zero(r->username))
07625 ast_string_field_set(p, username, r->username);
07626
07627 ast_string_field_set(p, exten, r->contact);
07628
07629
07630
07631
07632
07633
07634 if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
07635 p->ourip = bindaddr.sin_addr;
07636 build_contact(p);
07637 }
07638
07639
07640 if (auth == NULL) {
07641 if (r->timeout > -1)
07642 ast_log(LOG_WARNING, "Still have a registration timeout, #%d - deleting it\n", r->timeout);
07643 AST_SCHED_DEL(sched, r->timeout);
07644 r->timeout = ast_sched_add(sched, global_reg_timeout * 1000, sip_reg_timeout, r);
07645 if (option_debug)
07646 ast_log(LOG_DEBUG, "Scheduled a registration timeout for %s id #%d \n", r->hostname, r->timeout);
07647 }
07648
07649 if (strchr(r->username, '@')) {
07650 snprintf(from, sizeof(from), "<sip:%s>;tag=%s", r->username, p->tag);
07651 if (!ast_strlen_zero(p->theirtag))
07652 snprintf(to, sizeof(to), "<sip:%s>;tag=%s", r->username, p->theirtag);
07653 else
07654 snprintf(to, sizeof(to), "<sip:%s>", r->username);
07655 } else {
07656 snprintf(from, sizeof(from), "<sip:%s@%s>;tag=%s", r->username, p->tohost, p->tag);
07657 if (!ast_strlen_zero(p->theirtag))
07658 snprintf(to, sizeof(to), "<sip:%s@%s>;tag=%s", r->username, p->tohost, p->theirtag);
07659 else
07660 snprintf(to, sizeof(to), "<sip:%s@%s>", r->username, p->tohost);
07661 }
07662
07663
07664
07665 if (!ast_strlen_zero(p->fromdomain)) {
07666 if (r->portno && r->portno != STANDARD_SIP_PORT)
07667 snprintf(addr, sizeof(addr), "sip:%s:%d", p->fromdomain, r->portno);
07668 else
07669 snprintf(addr, sizeof(addr), "sip:%s", p->fromdomain);
07670 } else {
07671 if (r->portno && r->portno != STANDARD_SIP_PORT)
07672 snprintf(addr, sizeof(addr), "sip:%s:%d", r->hostname, r->portno);
07673 else
07674 snprintf(addr, sizeof(addr), "sip:%s", r->hostname);
07675 }
07676 ast_string_field_set(p, uri, addr);
07677
07678 p->branch ^= ast_random();
07679
07680 init_req(&req, sipmethod, addr);
07681
07682
07683 snprintf(tmp, sizeof(tmp), "%u %s", ++r->ocseq, sip_methods[sipmethod].text);
07684 p->ocseq = r->ocseq;
07685
07686 build_via(p);
07687 add_header(&req, "Via", p->via);
07688 add_header(&req, "From", from);
07689 add_header(&req, "To", to);
07690 add_header(&req, "Call-ID", p->callid);
07691 add_header(&req, "CSeq", tmp);
07692 if (!ast_strlen_zero(global_useragent))
07693 add_header(&req, "User-Agent", global_useragent);
07694 add_header(&req, "Max-Forwards", DEFAULT_MAX_FORWARDS);
07695
07696
07697 if (auth)
07698 add_header(&req, authheader, auth);
07699 else if (!ast_strlen_zero(r->nonce)) {
07700 char digest[1024];
07701
07702
07703 if (sipdebug)
07704 ast_log(LOG_DEBUG, " >>> Re-using Auth data for %s@%s\n", r->username, r->hostname);
07705 ast_string_field_set(p, realm, r->realm);
07706 ast_string_field_set(p, nonce, r->nonce);
07707 ast_string_field_set(p, domain, r->domain);
07708 ast_string_field_set(p, opaque, r->opaque);
07709 ast_string_field_set(p, qop, r->qop);
07710 r->noncecount++;
07711 p->noncecount = r->noncecount;
07712
07713 memset(digest,0,sizeof(digest));
07714 if(!build_reply_digest(p, sipmethod, digest, sizeof(digest)))
07715 add_header(&req, "Authorization", digest);
07716 else
07717 ast_log(LOG_NOTICE, "No authorization available for authentication of registration to %s@%s\n", r->username, r->hostname);
07718
07719 }
07720
07721 snprintf(tmp, sizeof(tmp), "%d", default_expiry);
07722 add_header(&req, "Expires", tmp);
07723 add_header(&req, "Contact", p->our_contact);
07724 add_header(&req, "Event", "registration");
07725 add_header_contentLength(&req, 0);
07726
07727 initialize_initreq(p, &req);
07728 if (sip_debug_test_pvt(p))
07729 ast_verbose("REGISTER %d headers, %d lines\n", p->initreq.headers, p->initreq.lines);
07730 r->regstate = auth ? REG_STATE_AUTHSENT : REG_STATE_REGSENT;
07731 r->regattempts++;
07732 if (option_debug > 3)
07733 ast_verbose("REGISTER attempt %d to %s@%s\n", r->regattempts, r->username, r->hostname);
07734 return send_request(p, &req, XMIT_CRITICAL, p->ocseq);
07735 }
07736
07737
07738 static int transmit_message_with_text(struct sip_pvt *p, const char *text)
07739 {
07740 struct sip_request req;
07741
07742 reqprep(&req, p, SIP_MESSAGE, 0, 1);
07743 add_text(&req, text);
07744 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
07745 }
07746
07747
07748 static int sip_refer_allocate(struct sip_pvt *p)
07749 {
07750 p->refer = ast_calloc(1, sizeof(struct sip_refer));
07751 return p->refer ? 1 : 0;
07752 }
07753
07754
07755
07756
07757
07758
07759 static int transmit_refer(struct sip_pvt *p, const char *dest)
07760 {
07761 struct sip_request req = {
07762 .headers = 0,
07763 };
07764 char from[256];
07765 const char *of;
07766 char *c;
07767 char referto[256];
07768 char *ttag, *ftag;
07769 char *theirtag = ast_strdupa(p->theirtag);
07770
07771 if (option_debug || sipdebug)
07772 ast_log(LOG_DEBUG, "SIP transfer of %s to %s\n", p->callid, dest);
07773
07774
07775 if (ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
07776 of = get_header(&p->initreq, "To");
07777 ttag = theirtag;
07778 ftag = p->tag;
07779 } else {
07780 of = get_header(&p->initreq, "From");
07781 ftag = theirtag;
07782 ttag = p->tag;
07783 }
07784
07785 ast_copy_string(from, of, sizeof(from));
07786 of = get_in_brackets(from);
07787 ast_string_field_set(p, from, of);
07788 if (strncasecmp(of, "sip:", 4))
07789 ast_log(LOG_NOTICE, "From address missing 'sip:', using it anyway\n");
07790 else
07791 of += 4;
07792
07793 if ((c = strchr(dest, '@')))
07794 c = NULL;
07795 else if ((c = strchr(of, '@')))
07796 *c++ = '\0';
07797 if (c)
07798 snprintf(referto, sizeof(referto), "<sip:%s@%s>", dest, c);
07799 else
07800 snprintf(referto, sizeof(referto), "<sip:%s>", dest);
07801
07802
07803 sip_refer_allocate(p);
07804 ast_copy_string(p->refer->refer_to, referto, sizeof(p->refer->refer_to));
07805 ast_copy_string(p->refer->referred_by, p->our_contact, sizeof(p->refer->referred_by));
07806 p->refer->status = REFER_SENT;
07807
07808 reqprep(&req, p, SIP_REFER, 0, 1);
07809
07810 add_header(&req, "Refer-To", referto);
07811 add_header(&req, "Allow", ALLOWED_METHODS);
07812 add_header(&req, "Supported", SUPPORTED_EXTENSIONS);
07813 if (!ast_strlen_zero(p->our_contact))
07814 add_header(&req, "Referred-By", p->our_contact);
07815
07816 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
07817
07818
07819
07820
07821
07822
07823
07824
07825 }
07826
07827
07828
07829 static int transmit_info_with_digit(struct sip_pvt *p, const char digit, unsigned int duration)
07830 {
07831 struct sip_request req;
07832
07833 reqprep(&req, p, SIP_INFO, 0, 1);
07834 add_digit(&req, digit, duration);
07835 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
07836 }
07837
07838
07839 static int transmit_info_with_vidupdate(struct sip_pvt *p)
07840 {
07841 struct sip_request req;
07842
07843 reqprep(&req, p, SIP_INFO, 0, 1);
07844 add_vidupdate(&req);
07845 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
07846 }
07847
07848
07849
07850
07851 static int transmit_request(struct sip_pvt *p, int sipmethod, int seqno, enum xmittype reliable, int newbranch)
07852 {
07853 struct sip_request resp;
07854
07855 if (sipmethod == SIP_ACK)
07856 p->invitestate = INV_CONFIRMED;
07857
07858 reqprep(&resp, p, sipmethod, seqno, newbranch);
07859 add_header_contentLength(&resp, 0);
07860 return send_request(p, &resp, reliable, seqno ? seqno : p->ocseq);
07861 }
07862
07863
07864 static int transmit_request_with_auth(struct sip_pvt *p, int sipmethod, int seqno, enum xmittype reliable, int newbranch)
07865 {
07866 struct sip_request resp;
07867
07868 reqprep(&resp, p, sipmethod, seqno, newbranch);
07869 if (!ast_strlen_zero(p->realm)) {
07870 char digest[1024];
07871
07872 memset(digest, 0, sizeof(digest));
07873 if(!build_reply_digest(p, sipmethod, digest, sizeof(digest))) {
07874 if (p->options && p->options->auth_type == PROXY_AUTH)
07875 add_header(&resp, "Proxy-Authorization", digest);
07876 else if (p->options && p->options->auth_type == WWW_AUTH)
07877 add_header(&resp, "Authorization", digest);
07878 else
07879 add_header(&resp, "Proxy-Authorization", digest);
07880 } else
07881 ast_log(LOG_WARNING, "No authentication available for call %s\n", p->callid);
07882 }
07883
07884
07885 if (sipmethod == SIP_BYE && p->owner && p->owner->hangupcause) {
07886 char buf[10];
07887
07888 add_header(&resp, "X-Asterisk-HangupCause", ast_cause2str(p->owner->hangupcause));
07889 snprintf(buf, sizeof(buf), "%d", p->owner->hangupcause);
07890 add_header(&resp, "X-Asterisk-HangupCauseCode", buf);
07891 }
07892
07893 add_header_contentLength(&resp, 0);
07894 return send_request(p, &resp, reliable, seqno ? seqno : p->ocseq);
07895 }
07896
07897
07898 static void destroy_association(struct sip_peer *peer)
07899 {
07900 if (!ast_test_flag(&global_flags[1], SIP_PAGE2_IGNOREREGEXPIRE)) {
07901 if (ast_test_flag(&peer->flags[1], SIP_PAGE2_RT_FROMCONTACT))
07902 ast_update_realtime("sippeers", "name", peer->name, "fullcontact", "", "ipaddr", "", "port", "", "regseconds", "0", "username", "", "regserver", "", NULL);
07903 else
07904 ast_db_del("SIP/Registry", peer->name);
07905 }
07906 }
07907
07908
07909 static int expire_register(const void *data)
07910 {
07911 struct sip_peer *peer = (struct sip_peer *)data;
07912
07913 if (!peer)
07914 return 0;
07915
07916 memset(&peer->addr, 0, sizeof(peer->addr));
07917
07918 destroy_association(peer);
07919
07920 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "Peer: SIP/%s\r\nPeerStatus: Unregistered\r\nCause: Expired\r\n", peer->name);
07921 register_peer_exten(peer, FALSE);
07922 peer->expire = -1;
07923 ast_device_state_changed("SIP/%s", peer->name);
07924
07925
07926
07927
07928 if (ast_test_flag(&peer->flags[1], SIP_PAGE2_SELFDESTRUCT) ||
07929 ast_test_flag(&peer->flags[1], SIP_PAGE2_RTAUTOCLEAR)) {
07930 struct sip_peer *peer_ptr = peer_ptr;
07931 peer_ptr = ASTOBJ_CONTAINER_UNLINK(&peerl, peer);
07932 if (peer_ptr) {
07933 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
07934 }
07935 }
07936
07937 ASTOBJ_UNREF(peer, sip_destroy_peer);
07938
07939 return 0;
07940 }
07941
07942
07943 static int sip_poke_peer_s(const void *data)
07944 {
07945 struct sip_peer *peer = (struct sip_peer *) data;
07946
07947 peer->pokeexpire = -1;
07948
07949 sip_poke_peer(peer);
07950
07951 ASTOBJ_UNREF(peer, sip_destroy_peer);
07952
07953 return 0;
07954 }
07955
07956
07957 static void reg_source_db(struct sip_peer *peer)
07958 {
07959 char data[256];
07960 struct in_addr in;
07961 int expiry;
07962 int port;
07963 char *scan, *addr, *port_str, *expiry_str, *username, *contact;
07964
07965 if (ast_test_flag(&peer->flags[1], SIP_PAGE2_RT_FROMCONTACT))
07966 return;
07967 if (ast_db_get("SIP/Registry", peer->name, data, sizeof(data)))
07968 return;
07969
07970 scan = data;
07971 addr = strsep(&scan, ":");
07972 port_str = strsep(&scan, ":");
07973 expiry_str = strsep(&scan, ":");
07974 username = strsep(&scan, ":");
07975 contact = scan;
07976
07977 if (!inet_aton(addr, &in))
07978 return;
07979
07980 if (port_str)
07981 port = atoi(port_str);
07982 else
07983 return;
07984
07985 if (expiry_str)
07986 expiry = atoi(expiry_str);
07987 else
07988 return;
07989
07990 if (username)
07991 ast_copy_string(peer->username, username, sizeof(peer->username));
07992 if (contact)
07993 ast_copy_string(peer->fullcontact, contact, sizeof(peer->fullcontact));
07994
07995 if (option_debug > 1)
07996 ast_log(LOG_DEBUG, "SIP Seeding peer from astdb: '%s' at %s@%s:%d for %d\n",
07997 peer->name, peer->username, ast_inet_ntoa(in), port, expiry);
07998
07999 memset(&peer->addr, 0, sizeof(peer->addr));
08000 peer->addr.sin_family = AF_INET;
08001 peer->addr.sin_addr = in;
08002 peer->addr.sin_port = htons(port);
08003 if (sipsock < 0) {
08004
08005 if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
08006 struct sip_peer *peer_ptr = peer;
08007 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
08008 }
08009 peer->pokeexpire = ast_sched_add(sched, ast_random() % 5000 + 1, sip_poke_peer_s, ASTOBJ_REF(peer));
08010 if (peer->pokeexpire == -1) {
08011 struct sip_peer *peer_ptr = peer;
08012 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
08013 }
08014 } else
08015 sip_poke_peer(peer);
08016 if (!AST_SCHED_DEL(sched, peer->expire)) {
08017 struct sip_peer *peer_ptr = peer;
08018 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
08019 }
08020 peer->expire = ast_sched_add(sched, (expiry + 10) * 1000, expire_register, ASTOBJ_REF(peer));
08021 if (peer->expire == -1) {
08022 struct sip_peer *peer_ptr = peer;
08023 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
08024 }
08025 register_peer_exten(peer, TRUE);
08026 }
08027
08028
08029 static int parse_ok_contact(struct sip_pvt *pvt, struct sip_request *req)
08030 {
08031 char contact[SIPBUFSIZE];
08032 char *c;
08033
08034
08035 ast_copy_string(contact, get_header(req, "Contact"), sizeof(contact));
08036 c = get_in_brackets(contact);
08037
08038
08039 ast_string_field_set(pvt, fullcontact, c);
08040
08041
08042 ast_string_field_set(pvt, okcontacturi, c);
08043
08044
08045
08046 return TRUE;
08047 }
08048
08049
08050 static int set_address_from_contact(struct sip_pvt *pvt)
08051 {
08052 struct hostent *hp;
08053 struct ast_hostent ahp;
08054 int port;
08055 char *c, *host, *pt;
08056 char contact_buf[256];
08057 char *contact;
08058
08059 if (ast_test_flag(&pvt->flags[0], SIP_NAT_ROUTE)) {
08060
08061
08062 pvt->sa = pvt->recv;
08063 return 0;
08064 }
08065
08066
08067 ast_copy_string(contact_buf, pvt->fullcontact, sizeof(contact_buf));
08068 contact = contact_buf;
08069
08070
08071 if (strncasecmp(contact, "sip:", 4)) {
08072 ast_log(LOG_NOTICE, "'%s' is not a valid SIP contact (missing sip:) trying to use anyway\n", contact);
08073 } else
08074 contact += 4;
08075
08076
08077
08078
08079
08080 host = strchr(contact, '@');
08081 if (!host) {
08082 host = contact;
08083 c = NULL;
08084 } else {
08085 *host++ = '\0';
08086 }
08087 pt = strchr(host, ':');
08088 if (pt) {
08089 *pt++ = '\0';
08090 port = atoi(pt);
08091 } else
08092 port = STANDARD_SIP_PORT;
08093
08094 contact = strsep(&contact, ";");
08095 host = strsep(&host, ";");
08096
08097
08098
08099 hp = ast_gethostbyname(host, &ahp);
08100 if (!hp) {
08101 ast_log(LOG_WARNING, "Invalid host name in Contact: (can't resolve in DNS) : '%s'\n", host);
08102 return -1;
08103 }
08104 pvt->sa.sin_family = AF_INET;
08105 memcpy(&pvt->sa.sin_addr, hp->h_addr, sizeof(pvt->sa.sin_addr));
08106 pvt->sa.sin_port = htons(port);
08107
08108 return 0;
08109 }
08110
08111
08112
08113 static enum parse_register_result parse_register_contact(struct sip_pvt *pvt, struct sip_peer *peer, struct sip_request *req)
08114 {
08115 char contact[SIPBUFSIZE];
08116 char data[SIPBUFSIZE];
08117 const char *expires = get_header(req, "Expires");
08118 int expiry = atoi(expires);
08119 char *curi, *n, *pt;
08120 int port;
08121 const char *useragent;
08122 struct hostent *hp;
08123 struct ast_hostent ahp;
08124 struct sockaddr_in oldsin;
08125
08126 ast_copy_string(contact, get_header(req, "Contact"), sizeof(contact));
08127
08128 if (ast_strlen_zero(expires)) {
08129 expires = strcasestr(contact, ";expires=");
08130 if (expires) {
08131
08132 expires = strsep((char **) &expires, ";");
08133 if (sscanf(expires + 9, "%d", &expiry) != 1)
08134 expiry = default_expiry;
08135 } else {
08136
08137 expiry = default_expiry;
08138 }
08139 }
08140
08141
08142 curi = contact;
08143 if (strchr(contact, '<') == NULL)
08144 strsep(&curi, ";");
08145 curi = get_in_brackets(contact);
08146
08147
08148
08149
08150
08151 if (ast_strlen_zero(curi) && ast_strlen_zero(expires)) {
08152
08153 if (peer->expire > -1 && !ast_strlen_zero(peer->fullcontact))
08154 pvt->expiry = ast_sched_when(sched, peer->expire);
08155 return PARSE_REGISTER_QUERY;
08156 } else if (!strcasecmp(curi, "*") || !expiry) {
08157
08158 memset(&peer->addr, 0, sizeof(peer->addr));
08159 if (!AST_SCHED_DEL(sched, peer->expire)) {
08160 struct sip_peer *peer_ptr = peer;
08161 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
08162 }
08163
08164 destroy_association(peer);
08165
08166 register_peer_exten(peer, 0);
08167 peer->fullcontact[0] = '\0';
08168 peer->useragent[0] = '\0';
08169 peer->sipoptions = 0;
08170 peer->lastms = 0;
08171
08172 if (option_verbose > 2)
08173 ast_verbose(VERBOSE_PREFIX_3 "Unregistered SIP '%s'\n", peer->name);
08174 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "Peer: SIP/%s\r\nPeerStatus: Unregistered\r\n", peer->name);
08175 return PARSE_REGISTER_UPDATE;
08176 }
08177
08178
08179 ast_copy_string(peer->fullcontact, curi, sizeof(peer->fullcontact));
08180
08181
08182 ast_string_field_build(pvt, our_contact, "<%s>", curi);
08183
08184
08185 if (strncasecmp(curi, "sip:", 4)) {
08186 ast_log(LOG_NOTICE, "'%s' is not a valid SIP contact (missing sip:) trying to use anyway\n", curi);
08187 } else
08188 curi += 4;
08189
08190 curi = strsep(&curi, ";");
08191
08192 n = strchr(curi, '@');
08193 if (!n) {
08194 n = curi;
08195 curi = NULL;
08196 } else
08197 *n++ = '\0';
08198 pt = strchr(n, ':');
08199 if (pt) {
08200 *pt++ = '\0';
08201 port = atoi(pt);
08202 } else
08203 port = STANDARD_SIP_PORT;
08204 oldsin = peer->addr;
08205 if (!ast_test_flag(&peer->flags[0], SIP_NAT_ROUTE)) {
08206
08207 hp = ast_gethostbyname(n, &ahp);
08208 if (!hp) {
08209 ast_log(LOG_WARNING, "Invalid host '%s'\n", n);
08210 return PARSE_REGISTER_FAILED;
08211 }
08212 peer->addr.sin_family = AF_INET;
08213 memcpy(&peer->addr.sin_addr, hp->h_addr, sizeof(peer->addr.sin_addr));
08214 peer->addr.sin_port = htons(port);
08215 } else {
08216
08217
08218 peer->addr = pvt->recv;
08219 }
08220
08221
08222 peer->sipoptions = pvt->sipoptions;
08223
08224 if (curi && ast_strlen_zero(peer->username))
08225 ast_copy_string(peer->username, curi, sizeof(peer->username));
08226
08227 if (!AST_SCHED_DEL(sched, peer->expire)) {
08228 struct sip_peer *peer_ptr = peer;
08229 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
08230 }
08231 if (expiry > max_expiry)
08232 expiry = max_expiry;
08233 if (expiry < min_expiry)
08234 expiry = min_expiry;
08235 if (ast_test_flag(&peer->flags[0], SIP_REALTIME)) {
08236 peer->expire = -1;
08237 } else {
08238 peer->expire = ast_sched_add(sched, (expiry + 10) * 1000, expire_register, ASTOBJ_REF(peer));
08239 if (peer->expire == -1) {
08240 struct sip_peer *peer_ptr = peer;
08241 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
08242 }
08243 }
08244 pvt->expiry = expiry;
08245 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);
08246 if (!ast_test_flag(&peer->flags[1], SIP_PAGE2_RT_FROMCONTACT))
08247 ast_db_put("SIP/Registry", peer->name, data);
08248 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "Peer: SIP/%s\r\nPeerStatus: Registered\r\n", peer->name);
08249
08250
08251 if (inaddrcmp(&peer->addr, &oldsin)) {
08252 sip_poke_peer(peer);
08253 if (option_verbose > 2)
08254 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);
08255 register_peer_exten(peer, 1);
08256 }
08257
08258
08259 useragent = get_header(req, "User-Agent");
08260 if (strcasecmp(useragent, peer->useragent)) {
08261 ast_copy_string(peer->useragent, useragent, sizeof(peer->useragent));
08262 if (option_verbose > 3)
08263 ast_verbose(VERBOSE_PREFIX_3 "Saved useragent \"%s\" for peer %s\n", peer->useragent, peer->name);
08264 }
08265 return PARSE_REGISTER_UPDATE;
08266 }
08267
08268
08269 static void free_old_route(struct sip_route *route)
08270 {
08271 struct sip_route *next;
08272
08273 while (route) {
08274 next = route->next;
08275 free(route);
08276 route = next;
08277 }
08278 }
08279
08280
08281 static void list_route(struct sip_route *route)
08282 {
08283 if (!route)
08284 ast_verbose("list_route: no route\n");
08285 else {
08286 for (;route; route = route->next)
08287 ast_verbose("list_route: hop: <%s>\n", route->hop);
08288 }
08289 }
08290
08291
08292 static void build_route(struct sip_pvt *p, struct sip_request *req, int backwards)
08293 {
08294 struct sip_route *thishop, *head, *tail;
08295 int start = 0;
08296 int len;
08297 const char *rr, *contact, *c;
08298
08299
08300 if (p->route && p->route_persistant) {
08301 if (option_debug)
08302 ast_log(LOG_DEBUG, "build_route: Retaining previous route: <%s>\n", p->route->hop);
08303 return;
08304 }
08305
08306 if (p->route) {
08307 free_old_route(p->route);
08308 p->route = NULL;
08309 }
08310
08311
08312 p->route_persistant = 1;
08313
08314
08315
08316
08317
08318
08319 head = NULL;
08320 tail = head;
08321
08322 for (;;) {
08323
08324 rr = __get_header(req, "Record-Route", &start);
08325 if (*rr == '\0')
08326 break;
08327 for (; (rr = strchr(rr, '<')) ; rr += len) {
08328 ++rr;
08329 len = strcspn(rr, ">") + 1;
08330
08331 if ((thishop = ast_malloc(sizeof(*thishop) + len))) {
08332
08333 ast_copy_string(thishop->hop, rr, len);
08334 if (option_debug > 1)
08335 ast_log(LOG_DEBUG, "build_route: Record-Route hop: <%s>\n", thishop->hop);
08336
08337 if (backwards) {
08338
08339 thishop->next = head;
08340 head = thishop;
08341
08342 if (!tail)
08343 tail = thishop;
08344 } else {
08345 thishop->next = NULL;
08346
08347 if (tail)
08348 tail->next = thishop;
08349 else
08350 head = thishop;
08351 tail = thishop;
08352 }
08353 }
08354 }
08355 }
08356
08357
08358 if (!head || (!ast_strlen_zero(head->hop) && strstr(head->hop,";lr") == NULL) ) {
08359
08360
08361 contact = get_header(req, "Contact");
08362 if (!ast_strlen_zero(contact)) {
08363 if (option_debug > 1)
08364 ast_log(LOG_DEBUG, "build_route: Contact hop: %s\n", contact);
08365
08366 c = strchr(contact, '<');
08367 if (c) {
08368
08369 ++c;
08370 len = strcspn(c, ">") + 1;
08371 } else {
08372
08373 c = contact;
08374 len = strlen(contact) + 1;
08375 }
08376 if ((thishop = ast_malloc(sizeof(*thishop) + len))) {
08377
08378 ast_copy_string(thishop->hop, c, len);
08379 thishop->next = NULL;
08380
08381 if (tail)
08382 tail->next = thishop;
08383 else
08384 head = thishop;
08385 }
08386 }
08387 }
08388
08389
08390 p->route = head;
08391
08392
08393 if (sip_debug_test_pvt(p))
08394 list_route(p->route);
08395 }
08396
08397 AST_THREADSTORAGE(check_auth_buf, check_auth_buf_init);
08398 #define CHECK_AUTH_BUF_INITLEN 256
08399
08400
08401
08402
08403
08404
08405 static enum check_auth_result check_auth(struct sip_pvt *p, struct sip_request *req, const char *username,
08406 const char *secret, const char *md5secret, int sipmethod,
08407 char *uri, enum xmittype reliable, int ignore)
08408 {
08409 const char *response = "407 Proxy Authentication Required";
08410 const char *reqheader = "Proxy-Authorization";
08411 const char *respheader = "Proxy-Authenticate";
08412 const char *authtoken;
08413 char a1_hash[256];
08414 char resp_hash[256]="";
08415 char *c;
08416 int wrongnonce = FALSE;
08417 int good_response;
08418 const char *usednonce = p->randdata;
08419 struct ast_dynamic_str *buf;
08420 int res;
08421
08422
08423 enum keys { K_RESP, K_URI, K_USER, K_NONCE, K_LAST };
08424 struct x {
08425 const char *key;
08426 const char *s;
08427 } *i, keys[] = {
08428 [K_RESP] = { "response=", "" },
08429 [K_URI] = { "uri=", "" },
08430 [K_USER] = { "username=", "" },
08431 [K_NONCE] = { "nonce=", "" },
08432 [K_LAST] = { NULL, NULL}
08433 };
08434
08435
08436 if (ast_strlen_zero(secret) && ast_strlen_zero(md5secret))
08437 return AUTH_SUCCESSFUL;
08438 if (sipmethod == SIP_REGISTER || sipmethod == SIP_SUBSCRIBE) {
08439
08440
08441
08442 response = "401 Unauthorized";
08443 reqheader = "Authorization";
08444 respheader = "WWW-Authenticate";
08445 }
08446 authtoken = get_header(req, reqheader);
08447 if (ignore && !ast_strlen_zero(p->randdata) && ast_strlen_zero(authtoken)) {
08448
08449
08450 if (!reliable) {
08451
08452
08453 transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, 0);
08454
08455 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
08456 }
08457 return AUTH_CHALLENGE_SENT;
08458 } else if (ast_strlen_zero(p->randdata) || ast_strlen_zero(authtoken)) {
08459
08460 ast_string_field_build(p, randdata, "%08lx", ast_random());
08461 transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, 0);
08462
08463 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
08464 return AUTH_CHALLENGE_SENT;
08465 }
08466
08467
08468
08469
08470
08471
08472 if (!(buf = ast_dynamic_str_thread_get(&check_auth_buf, CHECK_AUTH_BUF_INITLEN)))
08473 return AUTH_SECRET_FAILED;
08474
08475
08476 res = ast_dynamic_str_thread_set(&buf, 0, &check_auth_buf, "%s", authtoken);
08477
08478 if (res == AST_DYNSTR_BUILD_FAILED)
08479 return AUTH_SECRET_FAILED;
08480
08481 c = buf->str;
08482
08483 while(c && *(c = ast_skip_blanks(c)) ) {
08484 for (i = keys; i->key != NULL; i++) {
08485 const char *separator = ",";
08486
08487 if (strncasecmp(c, i->key, strlen(i->key)) != 0)
08488 continue;
08489
08490 c += strlen(i->key);
08491 if (*c == '"') {
08492 c++;
08493 separator = "\"";
08494 }
08495 i->s = c;
08496 strsep(&c, separator);
08497 break;
08498 }
08499 if (i->key == NULL)
08500 strsep(&c, " ,");
08501 }
08502
08503
08504 if (strcmp(username, keys[K_USER].s)) {
08505 ast_log(LOG_WARNING, "username mismatch, have <%s>, digest has <%s>\n",
08506 username, keys[K_USER].s);
08507
08508 return AUTH_USERNAME_MISMATCH;
08509 }
08510
08511
08512 if (strcasecmp(p->randdata, keys[K_NONCE].s)) {
08513 wrongnonce = TRUE;
08514 usednonce = keys[K_NONCE].s;
08515 }
08516
08517 if (!ast_strlen_zero(md5secret))
08518 ast_copy_string(a1_hash, md5secret, sizeof(a1_hash));
08519 else {
08520 char a1[256];
08521 snprintf(a1, sizeof(a1), "%s:%s:%s", username, global_realm, secret);
08522 ast_md5_hash(a1_hash, a1);
08523 }
08524
08525
08526 {
08527 char a2[256];
08528 char a2_hash[256];
08529 char resp[256];
08530
08531 snprintf(a2, sizeof(a2), "%s:%s", sip_methods[sipmethod].text,
08532 S_OR(keys[K_URI].s, uri));
08533 ast_md5_hash(a2_hash, a2);
08534 snprintf(resp, sizeof(resp), "%s:%s:%s", a1_hash, usednonce, a2_hash);
08535 ast_md5_hash(resp_hash, resp);
08536 }
08537
08538 good_response = keys[K_RESP].s &&
08539 !strncasecmp(keys[K_RESP].s, resp_hash, strlen(resp_hash));
08540 if (wrongnonce) {
08541 if (good_response) {
08542 if (sipdebug)
08543 ast_log(LOG_NOTICE, "Correct auth, but based on stale nonce received from '%s'\n", get_header(req, "To"));
08544
08545 ast_string_field_build(p, randdata, "%08lx", ast_random());
08546 transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, TRUE);
08547 } else {
08548
08549 if (!ast_test_flag(req, SIP_PKT_IGNORE)) {
08550 if (sipdebug)
08551 ast_log(LOG_NOTICE, "Bad authentication received from '%s'\n", get_header(req, "To"));
08552 ast_string_field_build(p, randdata, "%08lx", ast_random());
08553 } else {
08554 if (sipdebug)
08555 ast_log(LOG_NOTICE, "Duplicate authentication received from '%s'\n", get_header(req, "To"));
08556 }
08557 transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, FALSE);
08558 }
08559
08560
08561 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
08562 return AUTH_CHALLENGE_SENT;
08563 }
08564 if (good_response) {
08565 append_history(p, "AuthOK", "Auth challenge succesful for %s", username);
08566 return AUTH_SUCCESSFUL;
08567 }
08568
08569
08570
08571
08572
08573
08574 return AUTH_SECRET_FAILED;
08575 }
08576
08577
08578 static void sip_peer_hold(struct sip_pvt *p, int hold)
08579 {
08580 struct sip_peer *peer = find_peer(p->peername, NULL, 1);
08581
08582 if (!peer)
08583 return;
08584
08585
08586 if (hold)
08587 peer->onHold++;
08588 else
08589 peer->onHold--;
08590
08591
08592 ast_device_state_changed("SIP/%s", peer->name);
08593
08594 return;
08595 }
08596
08597
08598
08599
08600 static int cb_extensionstate(char *context, char* exten, int state, void *data, char *cid_num, char *cid_name)
08601 {
08602 struct sip_pvt *p = data;
08603
08604 ast_mutex_lock(&p->lock);
08605
08606 switch(state) {
08607 case AST_EXTENSION_DEACTIVATED:
08608 case AST_EXTENSION_REMOVED:
08609 if (p->autokillid > -1 && sip_cancel_destroy(p))
08610 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
08611 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
08612 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);
08613 p->stateid = -1;
08614 p->subscribed = NONE;
08615 append_history(p, "Subscribestatus", "%s", state == AST_EXTENSION_REMOVED ? "HintRemoved" : "Deactivated");
08616 break;
08617 default:
08618 p->laststate = state;
08619 break;
08620 }
08621 if (p->subscribed != NONE) {
08622 if (!p->pendinginvite) {
08623 transmit_state_notify(p, state, 1, FALSE);
08624 } else {
08625
08626
08627 ast_set_flag(&p->flags[1], SIP_PAGE2_STATECHANGEQUEUE);
08628 }
08629 }
08630 if (option_verbose > 1)
08631 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,
08632 ast_test_flag(&p->flags[1], SIP_PAGE2_STATECHANGEQUEUE) ? "(queued)" : "");
08633
08634
08635 ast_mutex_unlock(&p->lock);
08636
08637 return 0;
08638 }
08639
08640
08641
08642
08643 static void transmit_fake_auth_response(struct sip_pvt *p, int sipmethod, struct sip_request *req, enum xmittype reliable)
08644 {
08645
08646
08647 const char *response = "407 Proxy Authentication Required";
08648 const char *reqheader = "Proxy-Authorization";
08649 const char *respheader = "Proxy-Authenticate";
08650 const char *authtoken;
08651 struct ast_dynamic_str *buf;
08652 char *c;
08653
08654
08655 enum keys { K_NONCE, K_LAST };
08656 struct x {
08657 const char *key;
08658 const char *s;
08659 } *i, keys[] = {
08660 [K_NONCE] = { "nonce=", "" },
08661 [K_LAST] = { NULL, NULL}
08662 };
08663
08664 if (sipmethod == SIP_REGISTER || sipmethod == SIP_SUBSCRIBE) {
08665 response = "401 Unauthorized";
08666 reqheader = "Authorization";
08667 respheader = "WWW-Authenticate";
08668 }
08669 authtoken = get_header(req, reqheader);
08670 if (ast_test_flag(req, SIP_PKT_IGNORE) && !ast_strlen_zero(p->randdata) && ast_strlen_zero(authtoken)) {
08671
08672
08673 transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, 0);
08674
08675 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
08676 return;
08677 } else if (ast_strlen_zero(p->randdata) || ast_strlen_zero(authtoken)) {
08678
08679 ast_string_field_build(p, randdata, "%08lx", ast_random());
08680 transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, 0);
08681
08682 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
08683 return;
08684 }
08685
08686 if (!(buf = ast_dynamic_str_thread_get(&check_auth_buf, CHECK_AUTH_BUF_INITLEN))) {
08687 transmit_response(p, "403 Forbidden (Bad auth)", &p->initreq);
08688 return;
08689 }
08690
08691
08692 if (ast_dynamic_str_thread_set(&buf, 0, &check_auth_buf, "%s", authtoken) == AST_DYNSTR_BUILD_FAILED) {
08693 transmit_response(p, "403 Forbidden (Bad auth)", &p->initreq);
08694 return;
08695 }
08696
08697 c = buf->str;
08698
08699 while (c && *(c = ast_skip_blanks(c))) {
08700 for (i = keys; i->key != NULL; i++) {
08701 const char *separator = ",";
08702
08703 if (strncasecmp(c, i->key, strlen(i->key)) != 0) {
08704 continue;
08705 }
08706
08707 c += strlen(i->key);
08708 if (*c == '"') {
08709 c++;
08710 separator = "\"";
08711 }
08712 i->s = c;
08713 strsep(&c, separator);
08714 break;
08715 }
08716 if (i->key == NULL) {
08717 strsep(&c, " ,");
08718 }
08719 }
08720
08721
08722 if (strcasecmp(p->randdata, keys[K_NONCE].s)) {
08723 if (!ast_test_flag(req, SIP_PKT_IGNORE)) {
08724 ast_string_field_build(p, randdata, "%08lx", ast_random());
08725 }
08726 transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, FALSE);
08727
08728
08729 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
08730 } else {
08731 transmit_response(p, "403 Forbidden (Bad auth)", &p->initreq);
08732 }
08733 }
08734
08735
08736
08737
08738
08739
08740 static enum check_auth_result register_verify(struct sip_pvt *p, struct sockaddr_in *sin,
08741 struct sip_request *req, char *uri)
08742 {
08743 enum check_auth_result res = AUTH_NOT_FOUND;
08744 struct sip_peer *peer;
08745 char tmp[256];
08746 char *name, *c;
08747 char *t;
08748 char *domain;
08749
08750
08751 t = uri;
08752 while(*t && (*t > 32) && (*t != ';'))
08753 t++;
08754 *t = '\0';
08755
08756 ast_copy_string(tmp, get_header(req, "To"), sizeof(tmp));
08757 if (pedanticsipchecking)
08758 ast_uri_decode(tmp);
08759
08760 c = get_in_brackets(tmp);
08761 c = strsep(&c, ";");
08762
08763 if (!strncasecmp(c, "sip:", 4)) {
08764 name = c + 4;
08765 } else {
08766 name = c;
08767 ast_log(LOG_NOTICE, "Invalid to address: '%s' from %s (missing sip:) trying to use anyway...\n", c, ast_inet_ntoa(sin->sin_addr));
08768 }
08769
08770
08771 if ((c = strchr(name, '@'))) {
08772 *c++ = '\0';
08773 domain = c;
08774 if ((c = strchr(domain, ':')))
08775 *c = '\0';
08776 if (!AST_LIST_EMPTY(&domain_list)) {
08777 if (!check_sip_domain(domain, NULL, 0)) {
08778 transmit_response(p, "404 Not found (unknown domain)", &p->initreq);
08779 return AUTH_UNKNOWN_DOMAIN;
08780 }
08781 }
08782 }
08783
08784 ast_string_field_set(p, exten, name);
08785 build_contact(p);
08786 peer = find_peer(name, NULL, 1);
08787 if (!(peer && ast_apply_ha(peer->ha, sin))) {
08788
08789 if (peer) {
08790 ASTOBJ_UNREF(peer, sip_destroy_peer);
08791 res = AUTH_ACL_FAILED;
08792 } else
08793 res = AUTH_NOT_FOUND;
08794 }
08795 if (peer) {
08796
08797 if (p->rtp) {
08798 ast_rtp_codec_setpref(p->rtp, &peer->prefs);
08799 p->autoframing = peer->autoframing;
08800 }
08801 if (!ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC)) {
08802 ast_log(LOG_ERROR, "Peer '%s' is trying to register, but not configured as host=dynamic\n", peer->name);
08803 res = AUTH_PEER_NOT_DYNAMIC;
08804 } else {
08805 ast_copy_flags(&p->flags[0], &peer->flags[0], SIP_NAT);
08806 transmit_response(p, "100 Trying", req);
08807 if (!(res = check_auth(p, req, peer->name, peer->secret, peer->md5secret, SIP_REGISTER, uri, XMIT_UNRELIABLE, ast_test_flag(req, SIP_PKT_IGNORE)))) {
08808 if (sip_cancel_destroy(p))
08809 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
08810
08811
08812
08813 switch (parse_register_contact(p, peer, req)) {
08814 case PARSE_REGISTER_FAILED:
08815 ast_log(LOG_WARNING, "Failed to parse contact info\n");
08816 transmit_response_with_date(p, "400 Bad Request", req);
08817 peer->lastmsgssent = -1;
08818 res = 0;
08819 break;
08820 case PARSE_REGISTER_QUERY:
08821 transmit_response_with_date(p, "200 OK", req);
08822 peer->lastmsgssent = -1;
08823 res = 0;
08824 break;
08825 case PARSE_REGISTER_UPDATE:
08826 update_peer(peer, p->expiry);
08827
08828 transmit_response_with_date(p, "200 OK", req);
08829 if (!ast_test_flag((&peer->flags[1]), SIP_PAGE2_SUBSCRIBEMWIONLY))
08830 peer->lastmsgssent = -1;
08831 res = 0;
08832 break;
08833 }
08834 }
08835 }
08836 }
08837 if (!peer && autocreatepeer) {
08838
08839 peer = temp_peer(name);
08840 if (peer) {
08841 ASTOBJ_CONTAINER_LINK(&peerl, peer);
08842 if (sip_cancel_destroy(p))
08843 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
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
08858 transmit_response_with_date(p, "200 OK", req);
08859 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "Peer: SIP/%s\r\nPeerStatus: Registered\r\n", peer->name);
08860 peer->lastmsgssent = -1;
08861 res = 0;
08862 break;
08863 }
08864 }
08865 }
08866 if (!peer && global_alwaysauthreject) {
08867
08868
08869
08870 transmit_response(p, "100 Trying", req);
08871
08872 sched_yield();
08873 }
08874 if (!res) {
08875 ast_device_state_changed("SIP/%s", peer->name);
08876 }
08877 if (res < 0) {
08878 switch (res) {
08879 case AUTH_SECRET_FAILED:
08880
08881 transmit_response(p, "403 Forbidden (Bad auth)", &p->initreq);
08882 break;
08883 case AUTH_USERNAME_MISMATCH:
08884
08885
08886
08887
08888 case AUTH_NOT_FOUND:
08889 case AUTH_PEER_NOT_DYNAMIC:
08890 case AUTH_ACL_FAILED:
08891 if (global_alwaysauthreject) {
08892 transmit_fake_auth_response(p, SIP_REGISTER, &p->initreq, XMIT_UNRELIABLE);
08893 } else {
08894
08895 if (res == AUTH_PEER_NOT_DYNAMIC)
08896 transmit_response(p, "403 Forbidden", &p->initreq);
08897 else
08898 transmit_response(p, "404 Not found", &p->initreq);
08899 }
08900 break;
08901 default:
08902 break;
08903 }
08904 }
08905 if (peer)
08906 ASTOBJ_UNREF(peer, sip_destroy_peer);
08907
08908 return res;
08909 }
08910
08911
08912 static int get_rdnis(struct sip_pvt *p, struct sip_request *oreq)
08913 {
08914 char tmp[256], *c, *a;
08915 struct sip_request *req;
08916
08917 req = oreq;
08918 if (!req)
08919 req = &p->initreq;
08920 ast_copy_string(tmp, get_header(req, "Diversion"), sizeof(tmp));
08921 if (ast_strlen_zero(tmp))
08922 return 0;
08923 c = get_in_brackets(tmp);
08924 if (strncasecmp(c, "sip:", 4)) {
08925 ast_log(LOG_WARNING, "Huh? Not an RDNIS SIP header (%s)?\n", c);
08926 return -1;
08927 }
08928 c += 4;
08929 a = c;
08930 strsep(&a, "@;");
08931 if (sip_debug_test_pvt(p))
08932 ast_verbose("RDNIS is %s\n", c);
08933 ast_string_field_set(p, rdnis, c);
08934
08935 return 0;
08936 }
08937
08938
08939
08940
08941 static int get_destination(struct sip_pvt *p, struct sip_request *oreq)
08942 {
08943 char tmp[256] = "", *uri, *a;
08944 char tmpf[256] = "", *from;
08945 struct sip_request *req;
08946 char *colon;
08947
08948 req = oreq;
08949 if (!req)
08950 req = &p->initreq;
08951
08952
08953 if (req->rlPart2)
08954 ast_copy_string(tmp, req->rlPart2, sizeof(tmp));
08955
08956 if (pedanticsipchecking)
08957 ast_uri_decode(tmp);
08958
08959 uri = get_in_brackets(tmp);
08960
08961 if (strncasecmp(uri, "sip:", 4)) {
08962 ast_log(LOG_WARNING, "Huh? Not a SIP header (%s)?\n", uri);
08963 return -1;
08964 }
08965 uri += 4;
08966
08967
08968 ast_copy_string(tmpf, get_header(req, "From"), sizeof(tmpf));
08969 if (!ast_strlen_zero(tmpf)) {
08970 if (pedanticsipchecking)
08971 ast_uri_decode(tmpf);
08972 from = get_in_brackets(tmpf);
08973 } else {
08974 from = NULL;
08975 }
08976
08977 if (!ast_strlen_zero(from)) {
08978 if (strncasecmp(from, "sip:", 4)) {
08979 ast_log(LOG_WARNING, "Huh? Not a SIP header (%s)?\n", from);
08980 return -1;
08981 }
08982 from += 4;
08983 if ((a = strchr(from, '@')))
08984 *a++ = '\0';
08985 else
08986 a = from;
08987 from = strsep(&from, ";");
08988 a = strsep(&a, ";");
08989 ast_string_field_set(p, fromdomain, a);
08990 }
08991
08992
08993
08994
08995 if ((a = strchr(uri, '@'))) {
08996 *a++ = '\0';
08997 } else {
08998 a = uri;
08999 uri = "s";
09000 }
09001 colon = strchr(a, ':');
09002 if (colon)
09003 *colon = '\0';
09004
09005 uri = strsep(&uri, ";");
09006 a = strsep(&a, ";");
09007
09008 ast_string_field_set(p, domain, a);
09009
09010 if (!AST_LIST_EMPTY(&domain_list)) {
09011 char domain_context[AST_MAX_EXTENSION];
09012
09013 domain_context[0] = '\0';
09014 if (!check_sip_domain(p->domain, domain_context, sizeof(domain_context))) {
09015 if (!allow_external_domains && (req->method == SIP_INVITE || req->method == SIP_REFER)) {
09016 if (option_debug)
09017 ast_log(LOG_DEBUG, "Got SIP %s to non-local domain '%s'; refusing request.\n", sip_methods[req->method].text, p->domain);
09018 return -2;
09019 }
09020 }
09021
09022 if (!ast_strlen_zero(domain_context))
09023 ast_string_field_set(p, context, domain_context);
09024 }
09025
09026
09027 if (req->method == SIP_SUBSCRIBE && !ast_strlen_zero(p->subscribecontext))
09028 ast_string_field_set(p, context, p->subscribecontext);
09029
09030 if (sip_debug_test_pvt(p))
09031 ast_verbose("Looking for %s in %s (domain %s)\n", uri, p->context, p->domain);
09032
09033
09034 if (req->method == SIP_SUBSCRIBE) {
09035 char hint[AST_MAX_EXTENSION];
09036 return (ast_get_hint(hint, sizeof(hint), NULL, 0, NULL, p->context, p->exten) ? 0 : -1);
09037 } else {
09038
09039
09040
09041
09042
09043 char *decoded_uri = ast_strdupa(uri);
09044 ast_uri_decode(decoded_uri);
09045 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)) ||
09046 !strcmp(uri, ast_pickup_ext())) {
09047 if (!oreq)
09048 ast_string_field_set(p, exten, uri);
09049 return 0;
09050 }
09051 }
09052
09053
09054 if((ast_test_flag(&global_flags[1], SIP_PAGE2_ALLOWOVERLAP) &&
09055 ast_canmatch_extension(NULL, p->context, uri, 1, S_OR(p->cid_num, from))) ||
09056 !strncmp(uri, ast_pickup_ext(), strlen(uri))) {
09057 return 1;
09058 }
09059
09060 return -1;
09061 }
09062
09063
09064
09065
09066
09067
09068 static struct sip_pvt *get_sip_pvt_byid_locked(const char *callid, const char *totag, const char *fromtag)
09069 {
09070 struct sip_pvt *sip_pvt_ptr;
09071
09072 ast_mutex_lock(&iflock);
09073
09074 if (option_debug > 3 && totag)
09075 ast_log(LOG_DEBUG, "Looking for callid %s (fromtag %s totag %s)\n", callid, fromtag ? fromtag : "<no fromtag>", totag ? totag : "<no totag>");
09076
09077
09078 for (sip_pvt_ptr = iflist; sip_pvt_ptr; sip_pvt_ptr = sip_pvt_ptr->next) {
09079 if (!strcmp(sip_pvt_ptr->callid, callid)) {
09080 int match = 1;
09081 char *ourtag = sip_pvt_ptr->tag;
09082
09083
09084 ast_mutex_lock(&sip_pvt_ptr->lock);
09085
09086
09087
09088
09089
09090 if (pedanticsipchecking && (strcmp(fromtag, sip_pvt_ptr->theirtag) || (!ast_strlen_zero(totag) && strcmp(totag, ourtag))))
09091 match = 0;
09092
09093 if (!match) {
09094 ast_mutex_unlock(&sip_pvt_ptr->lock);
09095 continue;
09096 }
09097
09098 if (option_debug > 3 && totag)
09099 ast_log(LOG_DEBUG, "Matched %s call - their tag is %s Our tag is %s\n",
09100 ast_test_flag(&sip_pvt_ptr->flags[0], SIP_OUTGOING) ? "OUTGOING": "INCOMING",
09101 sip_pvt_ptr->theirtag, sip_pvt_ptr->tag);
09102
09103
09104 while (sip_pvt_ptr->owner && ast_channel_trylock(sip_pvt_ptr->owner)) {
09105 DEADLOCK_AVOIDANCE(&sip_pvt_ptr->lock);
09106 }
09107 break;
09108 }
09109 }
09110 ast_mutex_unlock(&iflock);
09111 if (option_debug > 3 && !sip_pvt_ptr)
09112 ast_log(LOG_DEBUG, "Found no match for callid %s to-tag %s from-tag %s\n", callid, totag, fromtag);
09113 return sip_pvt_ptr;
09114 }
09115
09116
09117
09118 static int get_refer_info(struct sip_pvt *transferer, struct sip_request *outgoing_req)
09119 {
09120
09121 const char *p_referred_by = NULL;
09122 char *h_refer_to = NULL;
09123 char *h_referred_by = NULL;
09124 char *refer_to;
09125 const char *p_refer_to;
09126 char *referred_by_uri = NULL;
09127 char *ptr;
09128 struct sip_request *req = NULL;
09129 const char *transfer_context = NULL;
09130 struct sip_refer *referdata;
09131
09132
09133 req = outgoing_req;
09134 referdata = transferer->refer;
09135
09136 if (!req)
09137 req = &transferer->initreq;
09138
09139 p_refer_to = get_header(req, "Refer-To");
09140 if (ast_strlen_zero(p_refer_to)) {
09141 ast_log(LOG_WARNING, "Refer-To Header missing. Skipping transfer.\n");
09142 return -2;
09143 }
09144 h_refer_to = ast_strdupa(p_refer_to);
09145 refer_to = get_in_brackets(h_refer_to);
09146 if (pedanticsipchecking)
09147 ast_uri_decode(refer_to);
09148
09149 if (strncasecmp(refer_to, "sip:", 4)) {
09150 ast_log(LOG_WARNING, "Can't transfer to non-sip: URI. (Refer-to: %s)?\n", refer_to);
09151 return -3;
09152 }
09153 refer_to += 4;
09154
09155
09156 p_referred_by = get_header(req, "Referred-By");
09157 if (!ast_strlen_zero(p_referred_by)) {
09158 char *lessthan;
09159 h_referred_by = ast_strdupa(p_referred_by);
09160 if (pedanticsipchecking)
09161 ast_uri_decode(h_referred_by);
09162
09163
09164 ast_copy_string(referdata->referred_by_name, h_referred_by, sizeof(referdata->referred_by_name));
09165 if ((lessthan = strchr(referdata->referred_by_name, '<'))) {
09166 *(lessthan - 1) = '\0';
09167 }
09168
09169 referred_by_uri = get_in_brackets(h_referred_by);
09170 if(strncasecmp(referred_by_uri, "sip:", 4)) {
09171 ast_log(LOG_WARNING, "Huh? Not a sip: header (Referred-by: %s). Skipping.\n", referred_by_uri);
09172 referred_by_uri = (char *) NULL;
09173 } else {
09174 referred_by_uri += 4;
09175 }
09176 }
09177
09178
09179 if ((ptr = strchr(refer_to, '?'))) {
09180 *ptr++ = '\0';
09181 if (!strncasecmp(ptr, "REPLACES=", 9)) {
09182 char *to = NULL, *from = NULL;
09183
09184
09185 referdata->attendedtransfer = 1;
09186 ast_copy_string(referdata->replaces_callid, ptr+9, sizeof(referdata->replaces_callid));
09187 ast_uri_decode(referdata->replaces_callid);
09188 if ((ptr = strchr(referdata->replaces_callid, ';'))) {
09189 *ptr++ = '\0';
09190 }
09191
09192 if (ptr) {
09193
09194 to = strcasestr(ptr, "to-tag=");
09195 from = strcasestr(ptr, "from-tag=");
09196 }
09197
09198
09199 if (to) {
09200 ptr = to + 7;
09201 if ((to = strchr(ptr, '&')))
09202 *to = '\0';
09203 if ((to = strchr(ptr, ';')))
09204 *to = '\0';
09205 ast_copy_string(referdata->replaces_callid_totag, ptr, sizeof(referdata->replaces_callid_totag));
09206 }
09207
09208 if (from) {
09209 ptr = from + 9;
09210 if ((to = strchr(ptr, '&')))
09211 *to = '\0';
09212 if ((to = strchr(ptr, ';')))
09213 *to = '\0';
09214 ast_copy_string(referdata->replaces_callid_fromtag, ptr, sizeof(referdata->replaces_callid_fromtag));
09215 }
09216
09217 if (option_debug > 1) {
09218 if (!pedanticsipchecking)
09219 ast_log(LOG_DEBUG,"Attended transfer: Will use Replace-Call-ID : %s (No check of from/to tags)\n", referdata->replaces_callid );
09220 else
09221 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>" );
09222 }
09223 }
09224 }
09225
09226 if ((ptr = strchr(refer_to, '@'))) {
09227 char *urioption = NULL, *domain;
09228 *ptr++ = '\0';
09229
09230 if ((urioption = strchr(ptr, ';')))
09231 *urioption++ = '\0';
09232
09233 domain = ptr;
09234 if ((ptr = strchr(domain, ':')))
09235 *ptr = '\0';
09236
09237
09238 ast_copy_string(referdata->refer_to_domain, domain, sizeof(referdata->refer_to_domain));
09239 if (urioption)
09240 ast_copy_string(referdata->refer_to_urioption, urioption, sizeof(referdata->refer_to_urioption));
09241 }
09242
09243 if ((ptr = strchr(refer_to, ';')))
09244 *ptr = '\0';
09245 ast_copy_string(referdata->refer_to, refer_to, sizeof(referdata->refer_to));
09246
09247 if (referred_by_uri) {
09248 if ((ptr = strchr(referred_by_uri, ';')))
09249 *ptr = '\0';
09250 ast_copy_string(referdata->referred_by, referred_by_uri, sizeof(referdata->referred_by));
09251 } else {
09252 referdata->referred_by[0] = '\0';
09253 }
09254
09255
09256 if (transferer->owner)
09257 transfer_context = pbx_builtin_getvar_helper(transferer->owner, "TRANSFER_CONTEXT");
09258
09259
09260 if (ast_strlen_zero(transfer_context)) {
09261 transfer_context = S_OR(transferer->owner->macrocontext,
09262 S_OR(transferer->context, default_context));
09263 }
09264
09265 ast_copy_string(referdata->refer_to_context, transfer_context, sizeof(referdata->refer_to_context));
09266
09267
09268 if (ast_exists_extension(NULL, transfer_context, refer_to, 1, NULL) ) {
09269 if (sip_debug_test_pvt(transferer)) {
09270 ast_verbose("SIP transfer to extension %s@%s by %s\n", refer_to, transfer_context, referred_by_uri);
09271 }
09272
09273 return 0;
09274 }
09275 if (sip_debug_test_pvt(transferer))
09276 ast_verbose("Failed SIP Transfer to non-existing extension %s in context %s\n n", refer_to, transfer_context);
09277
09278
09279 return -1;
09280 }
09281
09282
09283
09284 static int get_also_info(struct sip_pvt *p, struct sip_request *oreq)
09285 {
09286 char tmp[256] = "", *c, *a;
09287 struct sip_request *req = oreq ? oreq : &p->initreq;
09288 struct sip_refer *referdata = NULL;
09289 const char *transfer_context = NULL;
09290
09291 if (!p->refer && !sip_refer_allocate(p))
09292 return -1;
09293
09294 referdata = p->refer;
09295
09296 ast_copy_string(tmp, get_header(req, "Also"), sizeof(tmp));
09297 c = get_in_brackets(tmp);
09298
09299 if (pedanticsipchecking)
09300 ast_uri_decode(c);
09301
09302 if (strncasecmp(c, "sip:", 4)) {
09303 ast_log(LOG_WARNING, "Huh? Not a SIP header in Also: transfer (%s)?\n", c);
09304 return -1;
09305 }
09306 c += 4;
09307 if ((a = strchr(c, ';')))
09308 *a = '\0';
09309
09310 if ((a = strchr(c, '@'))) {
09311 *a++ = '\0';
09312 ast_copy_string(referdata->refer_to_domain, a, sizeof(referdata->refer_to_domain));
09313 }
09314
09315 if (sip_debug_test_pvt(p))
09316 ast_verbose("Looking for %s in %s\n", c, p->context);
09317
09318 if (p->owner)
09319 transfer_context = pbx_builtin_getvar_helper(p->owner, "TRANSFER_CONTEXT");
09320
09321
09322 if (ast_strlen_zero(transfer_context)) {
09323 transfer_context = S_OR(p->owner->macrocontext,
09324 S_OR(p->context, default_context));
09325 }
09326 if (ast_exists_extension(NULL, transfer_context, c, 1, NULL)) {
09327
09328 if (option_debug)
09329 ast_log(LOG_DEBUG,"SIP Bye-also transfer to Extension %s@%s \n", c, transfer_context);
09330 ast_copy_string(referdata->refer_to, c, sizeof(referdata->refer_to));
09331 ast_copy_string(referdata->referred_by, "", sizeof(referdata->referred_by));
09332 ast_copy_string(referdata->refer_contact, "", sizeof(referdata->refer_contact));
09333 referdata->refer_call = NULL;
09334
09335 ast_string_field_set(p, context, transfer_context);
09336 return 0;
09337 } else if (ast_canmatch_extension(NULL, p->context, c, 1, NULL)) {
09338 return 1;
09339 }
09340
09341 return -1;
09342 }
09343
09344 static void check_via(struct sip_pvt *p, const struct sip_request *req)
09345 {
09346 char via[512];
09347 char *c, *pt;
09348 struct hostent *hp;
09349 struct ast_hostent ahp;
09350
09351 ast_copy_string(via, get_header(req, "Via"), sizeof(via));
09352
09353
09354 c = strchr(via, ',');
09355 if (c)
09356 *c = '\0';
09357
09358
09359 c = strstr(via, ";rport");
09360 if (c && (c[6] != '='))
09361 ast_set_flag(&p->flags[0], SIP_NAT_ROUTE);
09362
09363 c = strchr(via, ';');
09364 if (c)
09365 *c = '\0';
09366
09367 c = strchr(via, ' ');
09368 if (c) {
09369 *c = '\0';
09370 c = ast_skip_blanks(c+1);
09371 if (strcasecmp(via, "SIP/2.0/UDP")) {
09372 ast_log(LOG_WARNING, "Don't know how to respond via '%s'\n", via);
09373 return;
09374 }
09375 pt = strchr(c, ':');
09376 if (pt)
09377 *pt++ = '\0';
09378 hp = ast_gethostbyname(c, &ahp);
09379 if (!hp) {
09380 ast_log(LOG_WARNING, "'%s' is not a valid host\n", c);
09381 return;
09382 }
09383 memset(&p->sa, 0, sizeof(p->sa));
09384 p->sa.sin_family = AF_INET;
09385 memcpy(&p->sa.sin_addr, hp->h_addr, sizeof(p->sa.sin_addr));
09386 p->sa.sin_port = htons(pt ? atoi(pt) : STANDARD_SIP_PORT);
09387
09388 if (sip_debug_test_pvt(p)) {
09389 const struct sockaddr_in *dst = sip_real_dst(p);
09390 ast_verbose("Sending to %s : %d (%s)\n", ast_inet_ntoa(dst->sin_addr), ntohs(dst->sin_port), sip_nat_mode(p));
09391 }
09392 }
09393 }
09394
09395
09396 static char *get_calleridname(const char *input, char *output, size_t outputsize)
09397 {
09398 const char *end = strchr(input,'<');
09399 const char *tmp = strchr(input,'"');
09400 int bytes = 0;
09401 int maxbytes = outputsize - 1;
09402
09403 if (!end || end == input)
09404 return NULL;
09405
09406 end--;
09407
09408 if (tmp && tmp <= end) {
09409
09410
09411
09412 end = strchr(tmp+1, '"');
09413 if (!end)
09414 return NULL;
09415 bytes = (int) (end - tmp);
09416
09417 if (bytes > maxbytes)
09418 bytes = maxbytes;
09419 ast_copy_string(output, tmp + 1, bytes);
09420 } else {
09421
09422
09423 input = ast_skip_blanks(input);
09424
09425 while(*end && *end < 33 && end > input)
09426 end--;
09427 if (end >= input) {
09428 bytes = (int) (end - input) + 2;
09429
09430 if (bytes > maxbytes)
09431 bytes = maxbytes;
09432 ast_copy_string(output, input, bytes);
09433 } else
09434 return NULL;
09435 }
09436 return output;
09437 }
09438
09439
09440
09441
09442
09443 static int get_rpid_num(const char *input, char *output, int maxlen)
09444 {
09445 char *start;
09446 char *end;
09447
09448 start = strchr(input,':');
09449 if (!start) {
09450 output[0] = '\0';
09451 return 0;
09452 }
09453 start++;
09454
09455
09456 ast_copy_string(output,start,maxlen);
09457 output[maxlen-1] = '\0';
09458
09459 end = strchr(output,'@');
09460 if (end)
09461 *end = '\0';
09462 else
09463 output[0] = '\0';
09464 if (strstr(input,"privacy=full") || strstr(input,"privacy=uri"))
09465 return AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
09466
09467 return 0;
09468 }
09469
09470
09471
09472
09473
09474
09475
09476 static enum check_auth_result check_user_full(struct sip_pvt *p, struct sip_request *req,
09477 int sipmethod, char *uri, enum xmittype reliable,
09478 struct sockaddr_in *sin, struct sip_peer **authpeer)
09479 {
09480 struct sip_user *user = NULL;
09481 struct sip_peer *peer;
09482 char from[256], *c;
09483 char *of;
09484 char rpid_num[50];
09485 const char *rpid;
09486 enum check_auth_result res = AUTH_SUCCESSFUL;
09487 char *t;
09488 char calleridname[50];
09489 int debug=sip_debug_test_addr(sin);
09490 struct ast_variable *tmpvar = NULL, *v = NULL;
09491 char *uri2 = ast_strdupa(uri);
09492
09493
09494 t = uri2;
09495 while (*t && *t > 32 && *t != ';')
09496 t++;
09497 *t = '\0';
09498 ast_copy_string(from, get_header(req, "From"), sizeof(from));
09499 if (pedanticsipchecking)
09500 ast_uri_decode(from);
09501
09502 memset(calleridname, 0, sizeof(calleridname));
09503 get_calleridname(from, calleridname, sizeof(calleridname));
09504 if (calleridname[0])
09505 ast_string_field_set(p, cid_name, calleridname);
09506
09507 rpid = get_header(req, "Remote-Party-ID");
09508 memset(rpid_num, 0, sizeof(rpid_num));
09509 if (!ast_strlen_zero(rpid))
09510 p->callingpres = get_rpid_num(rpid, rpid_num, sizeof(rpid_num));
09511
09512 of = get_in_brackets(from);
09513 if (ast_strlen_zero(p->exten)) {
09514 t = uri2;
09515 if (!strncasecmp(t, "sip:", 4))
09516 t+= 4;
09517 ast_string_field_set(p, exten, t);
09518 t = strchr(p->exten, '@');
09519 if (t)
09520 *t = '\0';
09521 if (ast_strlen_zero(p->our_contact))
09522 build_contact(p);
09523 }
09524
09525 ast_string_field_set(p, from, of);
09526 if (strncasecmp(of, "sip:", 4)) {
09527 ast_log(LOG_NOTICE, "From address missing 'sip:', using it anyway\n");
09528 } else
09529 of += 4;
09530
09531 if ((c = strchr(of, '@'))) {
09532 char *tmp;
09533 *c = '\0';
09534 if ((c = strchr(of, ':')))
09535 *c = '\0';
09536 tmp = ast_strdupa(of);
09537
09538
09539
09540 tmp = strsep(&tmp, ";");
09541 if (ast_is_shrinkable_phonenumber(tmp))
09542 ast_shrink_phone_number(tmp);
09543 ast_string_field_set(p, cid_num, tmp);
09544 }
09545
09546 if (!authpeer)
09547 user = find_user(of, 1);
09548
09549
09550 if (user && ast_apply_ha(user->ha, sin)) {
09551 ast_copy_flags(&p->flags[0], &user->flags[0], SIP_FLAGS_TO_COPY);
09552 ast_copy_flags(&p->flags[1], &user->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
09553
09554 for (v = user->chanvars ; v ; v = v->next) {
09555 if ((tmpvar = ast_variable_new(v->name, v->value))) {
09556 tmpvar->next = p->chanvars;
09557 p->chanvars = tmpvar;
09558 }
09559 }
09560 p->prefs = user->prefs;
09561
09562 if (p->rtp) {
09563 ast_rtp_codec_setpref(p->rtp, &p->prefs);
09564 p->autoframing = user->autoframing;
09565 }
09566
09567 if (!ast_strlen_zero(rpid_num) && ast_test_flag(&p->flags[0], SIP_TRUSTRPID)) {
09568 char *tmp;
09569 if (*calleridname)
09570 ast_string_field_set(p, cid_name, calleridname);
09571 tmp = ast_strdupa(rpid_num);
09572 if (ast_is_shrinkable_phonenumber(tmp))
09573 ast_shrink_phone_number(tmp);
09574 ast_string_field_set(p, cid_num, tmp);
09575 }
09576
09577 do_setnat(p, ast_test_flag(&p->flags[0], SIP_NAT_ROUTE) );
09578
09579 if (!(res = check_auth(p, req, user->name, user->secret, user->md5secret, sipmethod, uri2, reliable, ast_test_flag(req, SIP_PKT_IGNORE)))) {
09580 if (sip_cancel_destroy(p))
09581 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
09582 ast_copy_flags(&p->flags[0], &user->flags[0], SIP_FLAGS_TO_COPY);
09583 ast_copy_flags(&p->flags[1], &user->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
09584
09585 if (p->sipoptions)
09586 user->sipoptions = p->sipoptions;
09587
09588
09589 if (user->call_limit)
09590 ast_set_flag(&p->flags[0], SIP_CALL_LIMIT);
09591 if (!ast_strlen_zero(user->context))
09592 ast_string_field_set(p, context, user->context);
09593 if (!ast_strlen_zero(user->cid_num)) {
09594 char *tmp = ast_strdupa(user->cid_num);
09595 if (ast_is_shrinkable_phonenumber(tmp))
09596 ast_shrink_phone_number(tmp);
09597 ast_string_field_set(p, cid_num, tmp);
09598 }
09599 if (!ast_strlen_zero(user->cid_name))
09600 ast_string_field_set(p, cid_name, user->cid_name);
09601 ast_string_field_set(p, username, user->name);
09602 ast_string_field_set(p, peername, user->name);
09603 ast_string_field_set(p, peersecret, user->secret);
09604 ast_string_field_set(p, peermd5secret, user->md5secret);
09605 ast_string_field_set(p, subscribecontext, user->subscribecontext);
09606 ast_string_field_set(p, accountcode, user->accountcode);
09607 ast_string_field_set(p, language, user->language);
09608 ast_string_field_set(p, mohsuggest, user->mohsuggest);
09609 ast_string_field_set(p, mohinterpret, user->mohinterpret);
09610 p->allowtransfer = user->allowtransfer;
09611 p->amaflags = user->amaflags;
09612 p->callgroup = user->callgroup;
09613 p->pickupgroup = user->pickupgroup;
09614 if (user->callingpres)
09615 p->callingpres = user->callingpres;
09616
09617
09618 p->capability = user->capability;
09619 p->jointcapability = user->capability;
09620 if (p->peercapability)
09621 p->jointcapability &= p->peercapability;
09622 if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
09623 (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO))
09624 p->noncodeccapability |= AST_RTP_DTMF;
09625 else
09626 p->noncodeccapability &= ~AST_RTP_DTMF;
09627 p->jointnoncodeccapability = p->noncodeccapability;
09628 if (p->t38.peercapability)
09629 p->t38.jointcapability &= p->t38.peercapability;
09630 p->maxcallbitrate = user->maxcallbitrate;
09631
09632 if ((!ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT) || !(p->capability & AST_FORMAT_VIDEO_MASK)) && p->vrtp) {
09633 ast_rtp_destroy(p->vrtp);
09634 p->vrtp = NULL;
09635 }
09636 }
09637 if (user && debug)
09638 ast_verbose("Found user '%s'\n", user->name);
09639 } else {
09640 if (user) {
09641 if (!authpeer && debug)
09642 ast_verbose("Found user '%s', but fails host access\n", user->name);
09643 ASTOBJ_UNREF(user,sip_destroy_user);
09644 }
09645 user = NULL;
09646 }
09647
09648 if (!user) {
09649
09650 if (sipmethod == SIP_SUBSCRIBE)
09651
09652 peer = find_peer(of, NULL, 1);
09653 else
09654
09655
09656
09657
09658 peer = find_peer(NULL, &p->recv, 1);
09659
09660 if (peer) {
09661
09662 if (p->rtp) {
09663 ast_rtp_codec_setpref(p->rtp, &peer->prefs);
09664 p->autoframing = peer->autoframing;
09665 }
09666 if (debug)
09667 ast_verbose("Found peer '%s'\n", peer->name);
09668
09669
09670 ast_copy_flags(&p->flags[0], &peer->flags[0], SIP_FLAGS_TO_COPY);
09671 ast_copy_flags(&p->flags[1], &peer->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
09672
09673
09674 if (p->sipoptions)
09675 peer->sipoptions = p->sipoptions;
09676
09677
09678 if (!ast_strlen_zero(rpid_num) && ast_test_flag(&p->flags[0], SIP_TRUSTRPID)) {
09679 char *tmp = ast_strdupa(rpid_num);
09680 if (*calleridname)
09681 ast_string_field_set(p, cid_name, calleridname);
09682 if (ast_is_shrinkable_phonenumber(tmp))
09683 ast_shrink_phone_number(tmp);
09684 ast_string_field_set(p, cid_num, tmp);
09685 }
09686 do_setnat(p, ast_test_flag(&p->flags[0], SIP_NAT_ROUTE));
09687
09688 ast_string_field_set(p, peersecret, peer->secret);
09689 ast_string_field_set(p, peermd5secret, peer->md5secret);
09690 ast_string_field_set(p, subscribecontext, peer->subscribecontext);
09691 ast_string_field_set(p, mohinterpret, peer->mohinterpret);
09692 ast_string_field_set(p, mohsuggest, peer->mohsuggest);
09693 if (peer->callingpres)
09694 p->callingpres = peer->callingpres;
09695 if (peer->maxms && peer->lastms)
09696 p->timer_t1 = peer->lastms < global_t1min ? global_t1min : peer->lastms;
09697 if (ast_test_flag(&peer->flags[0], SIP_INSECURE_INVITE)) {
09698
09699 ast_string_field_free(p, peersecret);
09700 ast_string_field_free(p, peermd5secret);
09701 }
09702 if (!(res = check_auth(p, req, peer->name, p->peersecret, p->peermd5secret, sipmethod, uri2, reliable, ast_test_flag(req, SIP_PKT_IGNORE)))) {
09703 ast_copy_flags(&p->flags[0], &peer->flags[0], SIP_FLAGS_TO_COPY);
09704 ast_copy_flags(&p->flags[1], &peer->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
09705
09706 if (peer->call_limit)
09707 ast_set_flag(&p->flags[0], SIP_CALL_LIMIT);
09708 ast_string_field_set(p, peername, peer->name);
09709 ast_string_field_set(p, authname, peer->name);
09710
09711
09712 for (v = peer->chanvars ; v ; v = v->next) {
09713 if ((tmpvar = ast_variable_new(v->name, v->value))) {
09714 tmpvar->next = p->chanvars;
09715 p->chanvars = tmpvar;
09716 }
09717 }
09718 if (authpeer) {
09719 (*authpeer) = ASTOBJ_REF(peer);
09720 }
09721
09722 if (!ast_strlen_zero(peer->username)) {
09723 ast_string_field_set(p, username, peer->username);
09724
09725
09726 ast_string_field_set(p, authname, peer->username);
09727 }
09728 if (!ast_strlen_zero(peer->cid_num)) {
09729 char *tmp = ast_strdupa(peer->cid_num);
09730 if (ast_is_shrinkable_phonenumber(tmp))
09731 ast_shrink_phone_number(tmp);
09732 ast_string_field_set(p, cid_num, tmp);
09733 }
09734 if (!ast_strlen_zero(peer->cid_name))
09735 ast_string_field_set(p, cid_name, peer->cid_name);
09736 ast_string_field_set(p, fullcontact, peer->fullcontact);
09737 if (!ast_strlen_zero(peer->context))
09738 ast_string_field_set(p, context, peer->context);
09739 ast_string_field_set(p, peersecret, peer->secret);
09740 ast_string_field_set(p, peermd5secret, peer->md5secret);
09741 ast_string_field_set(p, language, peer->language);
09742 ast_string_field_set(p, accountcode, peer->accountcode);
09743 p->amaflags = peer->amaflags;
09744 p->callgroup = peer->callgroup;
09745 p->pickupgroup = peer->pickupgroup;
09746 p->capability = peer->capability;
09747 p->prefs = peer->prefs;
09748 p->jointcapability = peer->capability;
09749 if (p->peercapability)
09750 p->jointcapability &= p->peercapability;
09751 p->maxcallbitrate = peer->maxcallbitrate;
09752 if ((!ast_test_flag(&p->flags[1], SIP_PAGE2_VIDEOSUPPORT) || !(p->capability & AST_FORMAT_VIDEO_MASK)) && p->vrtp) {
09753 ast_rtp_destroy(p->vrtp);
09754 p->vrtp = NULL;
09755 }
09756 if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
09757 (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO))
09758 p->noncodeccapability |= AST_RTP_DTMF;
09759 else
09760 p->noncodeccapability &= ~AST_RTP_DTMF;
09761 p->jointnoncodeccapability = p->noncodeccapability;
09762 if (p->t38.peercapability)
09763 p->t38.jointcapability &= p->t38.peercapability;
09764 }
09765 ASTOBJ_UNREF(peer, sip_destroy_peer);
09766 } else {
09767 if (debug)
09768 ast_verbose("Found no matching peer or user for '%s:%d'\n", ast_inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));
09769
09770
09771 if (!global_allowguest) {
09772 if (global_alwaysauthreject)
09773 res = AUTH_FAKE_AUTH;
09774 else
09775 res = AUTH_SECRET_FAILED;
09776 } else if (!ast_strlen_zero(rpid_num) && ast_test_flag(&p->flags[0], SIP_TRUSTRPID)) {
09777 char *tmp = ast_strdupa(rpid_num);
09778 if (*calleridname)
09779 ast_string_field_set(p, cid_name, calleridname);
09780 if (ast_is_shrinkable_phonenumber(tmp))
09781 ast_shrink_phone_number(tmp);
09782 ast_string_field_set(p, cid_num, tmp);
09783 }
09784 }
09785
09786 }
09787
09788 if (user)
09789 ASTOBJ_UNREF(user, sip_destroy_user);
09790 return res;
09791 }
09792
09793
09794
09795
09796 static int check_user(struct sip_pvt *p, struct sip_request *req, int sipmethod, char *uri, enum xmittype reliable, struct sockaddr_in *sin)
09797 {
09798 return check_user_full(p, req, sipmethod, uri, reliable, sin, NULL);
09799 }
09800
09801
09802 static int get_msg_text(char *buf, int len, struct sip_request *req)
09803 {
09804 int x;
09805 int y;
09806
09807 buf[0] = '\0';
09808 y = len - strlen(buf) - 5;
09809 if (y < 0)
09810 y = 0;
09811 for (x=0;x<req->lines;x++) {
09812 strncat(buf, req->line[x], y);
09813 y -= strlen(req->line[x]) + 1;
09814 if (y < 0)
09815 y = 0;
09816 if (y != 0)
09817 strcat(buf, "\n");
09818 }
09819 return 0;
09820 }
09821
09822
09823
09824
09825
09826 static void receive_message(struct sip_pvt *p, struct sip_request *req)
09827 {
09828 char buf[1024];
09829 struct ast_frame f;
09830 const char *content_type = get_header(req, "Content-Type");
09831
09832 if (strncmp(content_type, "text/plain", strlen("text/plain"))) {
09833 transmit_response(p, "415 Unsupported Media Type", req);
09834 if (!p->owner)
09835 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
09836 return;
09837 }
09838
09839 if (get_msg_text(buf, sizeof(buf), req)) {
09840 ast_log(LOG_WARNING, "Unable to retrieve text from %s\n", p->callid);
09841 transmit_response(p, "202 Accepted", req);
09842 if (!p->owner)
09843 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
09844 return;
09845 }
09846
09847 if (p->owner) {
09848 if (sip_debug_test_pvt(p))
09849 ast_verbose("Message received: '%s'\n", buf);
09850 memset(&f, 0, sizeof(f));
09851 f.frametype = AST_FRAME_TEXT;
09852 f.subclass = 0;
09853 f.offset = 0;
09854 f.data = buf;
09855 f.datalen = strlen(buf);
09856 ast_queue_frame(p->owner, &f);
09857 transmit_response(p, "202 Accepted", req);
09858 } else {
09859 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);
09860 transmit_response(p, "405 Method Not Allowed", req);
09861 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
09862 }
09863 return;
09864 }
09865
09866
09867 static int sip_show_inuse(int fd, int argc, char *argv[])
09868 {
09869 #define FORMAT "%-25.25s %-15.15s %-15.15s \n"
09870 #define FORMAT2 "%-25.25s %-15.15s %-15.15s \n"
09871 char ilimits[40];
09872 char iused[40];
09873 int showall = FALSE;
09874
09875 if (argc < 3)
09876 return RESULT_SHOWUSAGE;
09877
09878 if (argc == 4 && !strcmp(argv[3],"all"))
09879 showall = TRUE;
09880
09881 ast_cli(fd, FORMAT, "* User name", "In use", "Limit");
09882 ASTOBJ_CONTAINER_TRAVERSE(&userl, 1, do {
09883 ASTOBJ_RDLOCK(iterator);
09884 if (iterator->call_limit)
09885 snprintf(ilimits, sizeof(ilimits), "%d", iterator->call_limit);
09886 else
09887 ast_copy_string(ilimits, "N/A", sizeof(ilimits));
09888 snprintf(iused, sizeof(iused), "%d", iterator->inUse);
09889 if (showall || iterator->call_limit)
09890 ast_cli(fd, FORMAT2, iterator->name, iused, ilimits);
09891 ASTOBJ_UNLOCK(iterator);
09892 } while (0) );
09893
09894 ast_cli(fd, FORMAT, "* Peer name", "In use", "Limit");
09895
09896 ASTOBJ_CONTAINER_TRAVERSE(&peerl, 1, do {
09897 ASTOBJ_RDLOCK(iterator);
09898 if (iterator->call_limit)
09899 snprintf(ilimits, sizeof(ilimits), "%d", iterator->call_limit);
09900 else
09901 ast_copy_string(ilimits, "N/A", sizeof(ilimits));
09902 snprintf(iused, sizeof(iused), "%d/%d", iterator->inUse, iterator->inRinging);
09903 if (showall || iterator->call_limit)
09904 ast_cli(fd, FORMAT2, iterator->name, iused, ilimits);
09905 ASTOBJ_UNLOCK(iterator);
09906 } while (0) );
09907
09908 return RESULT_SUCCESS;
09909 #undef FORMAT
09910 #undef FORMAT2
09911 }
09912
09913
09914 static char *transfermode2str(enum transfermodes mode)
09915 {
09916 if (mode == TRANSFER_OPENFORALL)
09917 return "open";
09918 else if (mode == TRANSFER_CLOSED)
09919 return "closed";
09920 return "strict";
09921 }
09922
09923
09924 static char *nat2str(int nat)
09925 {
09926 switch(nat) {
09927 case SIP_NAT_NEVER:
09928 return "No";
09929 case SIP_NAT_ROUTE:
09930 return "Route";
09931 case SIP_NAT_ALWAYS:
09932 return "Always";
09933 case SIP_NAT_RFC3581:
09934 return "RFC3581";
09935 default:
09936 return "Unknown";
09937 }
09938 }
09939
09940
09941
09942
09943 static int peer_status(struct sip_peer *peer, char *status, int statuslen)
09944 {
09945 int res = 0;
09946 if (peer->maxms) {
09947 if (peer->lastms < 0) {
09948 ast_copy_string(status, "UNREACHABLE", statuslen);
09949 } else if (peer->lastms > peer->maxms) {
09950 snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
09951 res = 1;
09952 } else if (peer->lastms) {
09953 snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
09954 res = 1;
09955 } else {
09956 ast_copy_string(status, "UNKNOWN", statuslen);
09957 }
09958 } else {
09959 ast_copy_string(status, "Unmonitored", statuslen);
09960
09961 res = -1;
09962 }
09963 return res;
09964 }
09965
09966
09967 static int sip_show_users(int fd, int argc, char *argv[])
09968 {
09969 regex_t regexbuf;
09970 int havepattern = FALSE;
09971
09972 #define FORMAT "%-25.25s %-15.15s %-15.15s %-15.15s %-5.5s%-10.10s\n"
09973
09974 switch (argc) {
09975 case 5:
09976 if (!strcasecmp(argv[3], "like")) {
09977 if (regcomp(®exbuf, argv[4], REG_EXTENDED | REG_NOSUB))
09978 return RESULT_SHOWUSAGE;
09979 havepattern = TRUE;
09980 } else
09981 return RESULT_SHOWUSAGE;
09982 case 3:
09983 break;
09984 default:
09985 return RESULT_SHOWUSAGE;
09986 }
09987
09988 ast_cli(fd, FORMAT, "Username", "Secret", "Accountcode", "Def.Context", "ACL", "NAT");
09989 ASTOBJ_CONTAINER_TRAVERSE(&userl, 1, do {
09990 ASTOBJ_RDLOCK(iterator);
09991
09992 if (havepattern && regexec(®exbuf, iterator->name, 0, NULL, 0)) {
09993 ASTOBJ_UNLOCK(iterator);
09994 continue;
09995 }
09996
09997 ast_cli(fd, FORMAT, iterator->name,
09998 iterator->secret,
09999 iterator->accountcode,
10000 iterator->context,
10001 iterator->ha ? "Yes" : "No",
10002 nat2str(ast_test_flag(&iterator->flags[0], SIP_NAT)));
10003 ASTOBJ_UNLOCK(iterator);
10004 } while (0)
10005 );
10006
10007 if (havepattern)
10008 regfree(®exbuf);
10009
10010 return RESULT_SUCCESS;
10011 #undef FORMAT
10012 }
10013
10014 static char mandescr_show_peers[] =
10015 "Description: Lists SIP peers in text format with details on current status.\n"
10016 "Variables: \n"
10017 " ActionID: <id> Action ID for this transaction. Will be returned.\n";
10018
10019
10020
10021 static int manager_sip_show_peers(struct mansession *s, const struct message *m)
10022 {
10023 const char *id = astman_get_header(m,"ActionID");
10024 const char *a[] = {"sip", "show", "peers"};
10025 char idtext[256] = "";
10026 int total = 0;
10027
10028 if (!ast_strlen_zero(id))
10029 snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
10030
10031 astman_send_ack(s, m, "Peer status list will follow");
10032
10033 _sip_show_peers(-1, &total, s, m, 3, a);
10034
10035 astman_append(s,
10036 "Event: PeerlistComplete\r\n"
10037 "ListItems: %d\r\n"
10038 "%s"
10039 "\r\n", total, idtext);
10040 return 0;
10041 }
10042
10043
10044 static int sip_show_peers(int fd, int argc, char *argv[])
10045 {
10046 return _sip_show_peers(fd, NULL, NULL, NULL, argc, (const char **) argv);
10047 }
10048
10049
10050 static int _sip_show_peers(int fd, int *total, struct mansession *s, const struct message *m, int argc, const char *argv[])
10051 {
10052 regex_t regexbuf;
10053 int havepattern = FALSE;
10054
10055 #define FORMAT2 "%-25.25s %-15.15s %-3.3s %-3.3s %-3.3s %-8s %-10s %-10s\n"
10056 #define FORMAT "%-25.25s %-15.15s %-3.3s %-3.3s %-3.3s %-8d %-10s %-10s\n"
10057
10058 char name[256];
10059 int total_peers = 0;
10060 int peers_mon_online = 0;
10061 int peers_mon_offline = 0;
10062 int peers_unmon_offline = 0;
10063 int peers_unmon_online = 0;
10064 const char *id;
10065 char idtext[256] = "";
10066 int realtimepeers;
10067
10068 realtimepeers = ast_check_realtime("sippeers");
10069
10070 if (s) {
10071 id = astman_get_header(m,"ActionID");
10072 if (!ast_strlen_zero(id))
10073 snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
10074 }
10075
10076 switch (argc) {
10077 case 5:
10078 if (!strcasecmp(argv[3], "like")) {
10079 if (regcomp(®exbuf, argv[4], REG_EXTENDED | REG_NOSUB))
10080 return RESULT_SHOWUSAGE;
10081 havepattern = TRUE;
10082 } else
10083 return RESULT_SHOWUSAGE;
10084 case 3:
10085 break;
10086 default:
10087 return RESULT_SHOWUSAGE;
10088 }
10089
10090 if (!s)
10091 ast_cli(fd, FORMAT2, "Name/username", "Host", "Dyn", "Nat", "ACL", "Port", "Status", (realtimepeers ? "Realtime" : ""));
10092
10093 ASTOBJ_CONTAINER_TRAVERSE(&peerl, 1, do {
10094 char status[20] = "";
10095 char srch[2000];
10096 char pstatus;
10097
10098 ASTOBJ_RDLOCK(iterator);
10099
10100 if (havepattern && regexec(®exbuf, iterator->name, 0, NULL, 0)) {
10101 ASTOBJ_UNLOCK(iterator);
10102 continue;
10103 }
10104
10105 if (!ast_strlen_zero(iterator->username) && !s)
10106 snprintf(name, sizeof(name), "%s/%s", iterator->name, iterator->username);
10107 else
10108 ast_copy_string(name, iterator->name, sizeof(name));
10109
10110 pstatus = peer_status(iterator, status, sizeof(status));
10111 if (pstatus == 1)
10112 peers_mon_online++;
10113 else if (pstatus == 0)
10114 peers_mon_offline++;
10115 else {
10116 if (iterator->addr.sin_port == 0)
10117 peers_unmon_offline++;
10118 else
10119 peers_unmon_online++;
10120 }
10121
10122 snprintf(srch, sizeof(srch), FORMAT, name,
10123 iterator->addr.sin_addr.s_addr ? ast_inet_ntoa(iterator->addr.sin_addr) : "(Unspecified)",
10124 ast_test_flag(&iterator->flags[1], SIP_PAGE2_DYNAMIC) ? " D " : " ",
10125 ast_test_flag(&iterator->flags[0], SIP_NAT_ROUTE) ? " N " : " ",
10126 iterator->ha ? " A " : " ",
10127 ntohs(iterator->addr.sin_port), status,
10128 realtimepeers ? (ast_test_flag(&iterator->flags[0], SIP_REALTIME) ? "Cached RT":"") : "");
10129
10130 if (!s) {
10131 ast_cli(fd, FORMAT, name,
10132 iterator->addr.sin_addr.s_addr ? ast_inet_ntoa(iterator->addr.sin_addr) : "(Unspecified)",
10133 ast_test_flag(&iterator->flags[1], SIP_PAGE2_DYNAMIC) ? " D " : " ",
10134 ast_test_flag(&iterator->flags[0], SIP_NAT_ROUTE) ? " N " : " ",
10135 iterator->ha ? " A " : " ",
10136
10137 ntohs(iterator->addr.sin_port), status,
10138 realtimepeers ? (ast_test_flag(&iterator->flags[0], SIP_REALTIME) ? "Cached RT":"") : "");
10139 } else {
10140
10141 astman_append(s,
10142 "Event: PeerEntry\r\n%s"
10143 "Channeltype: SIP\r\n"
10144 "ObjectName: %s\r\n"
10145 "ChanObjectType: peer\r\n"
10146 "IPaddress: %s\r\n"
10147 "IPport: %d\r\n"
10148 "Dynamic: %s\r\n"
10149 "Natsupport: %s\r\n"
10150 "VideoSupport: %s\r\n"
10151 "ACL: %s\r\n"
10152 "Status: %s\r\n"
10153 "RealtimeDevice: %s\r\n\r\n",
10154 idtext,
10155 iterator->name,
10156 iterator->addr.sin_addr.s_addr ? ast_inet_ntoa(iterator->addr.sin_addr) : "-none-",
10157 ntohs(iterator->addr.sin_port),
10158 ast_test_flag(&iterator->flags[1], SIP_PAGE2_DYNAMIC) ? "yes" : "no",
10159 ast_test_flag(&iterator->flags[0], SIP_NAT_ROUTE) ? "yes" : "no",
10160 ast_test_flag(&iterator->flags[1], SIP_PAGE2_VIDEOSUPPORT) ? "yes" : "no",
10161 iterator->ha ? "yes" : "no",
10162 status,
10163 realtimepeers ? (ast_test_flag(&iterator->flags[0], SIP_REALTIME) ? "yes":"no") : "no");
10164 }
10165
10166 ASTOBJ_UNLOCK(iterator);
10167
10168 total_peers++;
10169 } while(0) );
10170
10171 if (!s)
10172 ast_cli(fd, "%d sip peers [Monitored: %d online, %d offline Unmonitored: %d online, %d offline]\n",
10173 total_peers, peers_mon_online, peers_mon_offline, peers_unmon_online, peers_unmon_offline);
10174
10175 if (havepattern)
10176 regfree(®exbuf);
10177
10178 if (total)
10179 *total = total_peers;
10180
10181
10182 return RESULT_SUCCESS;
10183 #undef FORMAT
10184 #undef FORMAT2
10185 }
10186
10187
10188 static int sip_show_objects(int fd, int argc, char *argv[])
10189 {
10190 char tmp[256];
10191 if (argc != 3)
10192 return RESULT_SHOWUSAGE;
10193 ast_cli(fd, "-= User objects: %d static, %d realtime =-\n\n", suserobjs, ruserobjs);
10194 ASTOBJ_CONTAINER_DUMP(fd, tmp, sizeof(tmp), &userl);
10195 ast_cli(fd, "-= Peer objects: %d static, %d realtime, %d autocreate =-\n\n", speerobjs, rpeerobjs, apeerobjs);
10196 ASTOBJ_CONTAINER_DUMP(fd, tmp, sizeof(tmp), &peerl);
10197 ast_cli(fd, "-= Registry objects: %d =-\n\n", regobjs);
10198 ASTOBJ_CONTAINER_DUMP(fd, tmp, sizeof(tmp), ®l);
10199 return RESULT_SUCCESS;
10200 }
10201
10202 static void print_group(int fd, ast_group_t group, int crlf)
10203 {
10204 char buf[256];
10205 ast_cli(fd, crlf ? "%s\r\n" : "%s\n", ast_print_group(buf, sizeof(buf), group) );
10206 }
10207
10208
10209 static const char *dtmfmode2str(int mode)
10210 {
10211 switch (mode) {
10212 case SIP_DTMF_RFC2833:
10213 return "rfc2833";
10214 case SIP_DTMF_INFO:
10215 return "info";
10216 case SIP_DTMF_INBAND:
10217 return "inband";
10218 case SIP_DTMF_AUTO:
10219 return "auto";
10220 }
10221 return "<error>";
10222 }
10223
10224
10225 static const char *insecure2str(int port, int invite)
10226 {
10227 if (port && invite)
10228 return "port,invite";
10229 else if (port)
10230 return "port";
10231 else if (invite)
10232 return "invite";
10233 else
10234 return "no";
10235 }
10236
10237
10238
10239
10240 static void cleanup_stale_contexts(char *new, char *old)
10241 {
10242 char *oldcontext, *newcontext, *stalecontext, *stringp, newlist[AST_MAX_CONTEXT];
10243
10244 while ((oldcontext = strsep(&old, "&"))) {
10245 stalecontext = '\0';
10246 ast_copy_string(newlist, new, sizeof(newlist));
10247 stringp = newlist;
10248 while ((newcontext = strsep(&stringp, "&"))) {
10249 if (strcmp(newcontext, oldcontext) == 0) {
10250
10251 stalecontext = '\0';
10252 break;
10253 } else if (strcmp(newcontext, oldcontext)) {
10254 stalecontext = oldcontext;
10255 }
10256
10257 }
10258 if (stalecontext)
10259 ast_context_destroy(ast_context_find(stalecontext), "SIP");
10260 }
10261 }
10262
10263
10264 static int sip_prune_realtime(int fd, int argc, char *argv[])
10265 {
10266 struct sip_peer *peer;
10267 struct sip_user *user;
10268 int pruneuser = FALSE;
10269 int prunepeer = FALSE;
10270 int multi = FALSE;
10271 char *name = NULL;
10272 regex_t regexbuf;
10273
10274 switch (argc) {
10275 case 4:
10276 if (!strcasecmp(argv[3], "user"))
10277 return RESULT_SHOWUSAGE;
10278 if (!strcasecmp(argv[3], "peer"))
10279 return RESULT_SHOWUSAGE;
10280 if (!strcasecmp(argv[3], "like"))
10281 return RESULT_SHOWUSAGE;
10282 if (!strcasecmp(argv[3], "all")) {
10283 multi = TRUE;
10284 pruneuser = prunepeer = TRUE;
10285 } else {
10286 pruneuser = prunepeer = TRUE;
10287 name = argv[3];
10288 }
10289 break;
10290 case 5:
10291 if (!strcasecmp(argv[4], "like"))
10292 return RESULT_SHOWUSAGE;
10293 if (!strcasecmp(argv[3], "all"))
10294 return RESULT_SHOWUSAGE;
10295 if (!strcasecmp(argv[3], "like")) {
10296 multi = TRUE;
10297 name = argv[4];
10298 pruneuser = prunepeer = TRUE;
10299 } else if (!strcasecmp(argv[3], "user")) {
10300 pruneuser = TRUE;
10301 if (!strcasecmp(argv[4], "all"))
10302 multi = TRUE;
10303 else
10304 name = argv[4];
10305 } else if (!strcasecmp(argv[3], "peer")) {
10306 prunepeer = TRUE;
10307 if (!strcasecmp(argv[4], "all"))
10308 multi = TRUE;
10309 else
10310 name = argv[4];
10311 } else
10312 return RESULT_SHOWUSAGE;
10313 break;
10314 case 6:
10315 if (strcasecmp(argv[4], "like"))
10316 return RESULT_SHOWUSAGE;
10317 if (!strcasecmp(argv[3], "user")) {
10318 pruneuser = TRUE;
10319 name = argv[5];
10320 } else if (!strcasecmp(argv[3], "peer")) {
10321 prunepeer = TRUE;
10322 name = argv[5];
10323 } else
10324 return RESULT_SHOWUSAGE;
10325 break;
10326 default:
10327 return RESULT_SHOWUSAGE;
10328 }
10329
10330 if (multi && name) {
10331 if (regcomp(®exbuf, name, REG_EXTENDED | REG_NOSUB))
10332 return RESULT_SHOWUSAGE;
10333 }
10334
10335 if (multi) {
10336 if (prunepeer) {
10337 int pruned = 0;
10338
10339 ASTOBJ_CONTAINER_WRLOCK(&peerl);
10340 ASTOBJ_CONTAINER_TRAVERSE(&peerl, 1, do {
10341 ASTOBJ_RDLOCK(iterator);
10342 if (name && regexec(®exbuf, iterator->name, 0, NULL, 0)) {
10343 ASTOBJ_UNLOCK(iterator);
10344 continue;
10345 };
10346 if (ast_test_flag(&iterator->flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
10347 ASTOBJ_MARK(iterator);
10348 pruned++;
10349 }
10350 ASTOBJ_UNLOCK(iterator);
10351 } while (0) );
10352 if (pruned) {
10353 ASTOBJ_CONTAINER_PRUNE_MARKED(&peerl, sip_destroy_peer);
10354 ast_cli(fd, "%d peers pruned.\n", pruned);
10355 } else
10356 ast_cli(fd, "No peers found to prune.\n");
10357 ASTOBJ_CONTAINER_UNLOCK(&peerl);
10358 }
10359 if (pruneuser) {
10360 int pruned = 0;
10361
10362 ASTOBJ_CONTAINER_WRLOCK(&userl);
10363 ASTOBJ_CONTAINER_TRAVERSE(&userl, 1, do {
10364 ASTOBJ_RDLOCK(iterator);
10365 if (name && regexec(®exbuf, iterator->name, 0, NULL, 0)) {
10366 ASTOBJ_UNLOCK(iterator);
10367 continue;
10368 };
10369 if (ast_test_flag(&iterator->flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
10370 ASTOBJ_MARK(iterator);
10371 pruned++;
10372 }
10373 ASTOBJ_UNLOCK(iterator);
10374 } while (0) );
10375 if (pruned) {
10376 ASTOBJ_CONTAINER_PRUNE_MARKED(&userl, sip_destroy_user);
10377 ast_cli(fd, "%d users pruned.\n", pruned);
10378 } else
10379 ast_cli(fd, "No users found to prune.\n");
10380 ASTOBJ_CONTAINER_UNLOCK(&userl);
10381 }
10382 } else {
10383 if (prunepeer) {
10384 if ((peer = ASTOBJ_CONTAINER_FIND_UNLINK(&peerl, name))) {
10385 if (!ast_test_flag(&peer->flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
10386 ast_cli(fd, "Peer '%s' is not a Realtime peer, cannot be pruned.\n", name);
10387 ASTOBJ_CONTAINER_LINK(&peerl, peer);
10388 } else
10389 ast_cli(fd, "Peer '%s' pruned.\n", name);
10390 ASTOBJ_UNREF(peer, sip_destroy_peer);
10391 } else
10392 ast_cli(fd, "Peer '%s' not found.\n", name);
10393 }
10394 if (pruneuser) {
10395 if ((user = ASTOBJ_CONTAINER_FIND_UNLINK(&userl, name))) {
10396 if (!ast_test_flag(&user->flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
10397 ast_cli(fd, "User '%s' is not a Realtime user, cannot be pruned.\n", name);
10398 ASTOBJ_CONTAINER_LINK(&userl, user);
10399 } else
10400 ast_cli(fd, "User '%s' pruned.\n", name);
10401 ASTOBJ_UNREF(user, sip_destroy_user);
10402 } else
10403 ast_cli(fd, "User '%s' not found.\n", name);
10404 }
10405 }
10406
10407 return RESULT_SUCCESS;
10408 }
10409
10410
10411 static void print_codec_to_cli(int fd, struct ast_codec_pref *pref)
10412 {
10413 int x, codec;
10414
10415 for(x = 0; x < 32 ; x++) {
10416 codec = ast_codec_pref_index(pref, x);
10417 if (!codec)
10418 break;
10419 ast_cli(fd, "%s", ast_getformatname(codec));
10420 ast_cli(fd, ":%d", pref->framing[x]);
10421 if (x < 31 && ast_codec_pref_index(pref, x + 1))
10422 ast_cli(fd, ",");
10423 }
10424 if (!x)
10425 ast_cli(fd, "none");
10426 }
10427
10428
10429 static const char *domain_mode_to_text(const enum domain_mode mode)
10430 {
10431 switch (mode) {
10432 case SIP_DOMAIN_AUTO:
10433 return "[Automatic]";
10434 case SIP_DOMAIN_CONFIG:
10435 return "[Configured]";
10436 }
10437
10438 return "";
10439 }
10440
10441
10442 static int sip_show_domains(int fd, int argc, char *argv[])
10443 {
10444 struct domain *d;
10445 #define FORMAT "%-40.40s %-20.20s %-16.16s\n"
10446
10447 if (AST_LIST_EMPTY(&domain_list)) {
10448 ast_cli(fd, "SIP Domain support not enabled.\n\n");
10449 return RESULT_SUCCESS;
10450 } else {
10451 ast_cli(fd, FORMAT, "Our local SIP domains:", "Context", "Set by");
10452 AST_LIST_LOCK(&domain_list);
10453 AST_LIST_TRAVERSE(&domain_list, d, list)
10454 ast_cli(fd, FORMAT, d->domain, S_OR(d->context, "(default)"),
10455 domain_mode_to_text(d->mode));
10456 AST_LIST_UNLOCK(&domain_list);
10457 ast_cli(fd, "\n");
10458 return RESULT_SUCCESS;
10459 }
10460 }
10461 #undef FORMAT
10462
10463 static char mandescr_show_peer[] =
10464 "Description: Show one SIP peer with details on current status.\n"
10465 "Variables: \n"
10466 " Peer: <name> The peer name you want to check.\n"
10467 " ActionID: <id> Optional action ID for this AMI transaction.\n";
10468
10469
10470 static int manager_sip_show_peer(struct mansession *s, const struct message *m)
10471 {
10472 const char *a[4];
10473 const char *peer;
10474 int ret;
10475
10476 peer = astman_get_header(m,"Peer");
10477 if (ast_strlen_zero(peer)) {
10478 astman_send_error(s, m, "Peer: <name> missing.\n");
10479 return 0;
10480 }
10481 a[0] = "sip";
10482 a[1] = "show";
10483 a[2] = "peer";
10484 a[3] = peer;
10485
10486 ret = _sip_show_peer(1, -1, s, m, 4, a);
10487 astman_append(s, "\r\n\r\n" );
10488 return ret;
10489 }
10490
10491
10492
10493
10494 static int sip_show_peer(int fd, int argc, char *argv[])
10495 {
10496 return _sip_show_peer(0, fd, NULL, NULL, argc, (const char **) argv);
10497 }
10498
10499
10500 static int _sip_show_peer(int type, int fd, struct mansession *s, const struct message *m, int argc, const char *argv[])
10501 {
10502 char status[30] = "";
10503 char cbuf[256];
10504 struct sip_peer *peer;
10505 char codec_buf[512];
10506 struct ast_codec_pref *pref;
10507 struct ast_variable *v;
10508 struct sip_auth *auth;
10509 int x = 0, codec = 0, load_realtime;
10510 int realtimepeers;
10511
10512 realtimepeers = ast_check_realtime("sippeers");
10513
10514 if (argc < 4)
10515 return RESULT_SHOWUSAGE;
10516
10517 load_realtime = (argc == 5 && !strcmp(argv[4], "load")) ? TRUE : FALSE;
10518 peer = find_peer(argv[3], NULL, load_realtime);
10519 if (s) {
10520 if (peer) {
10521 const char *id = astman_get_header(m,"ActionID");
10522
10523 astman_append(s, "Response: Success\r\n");
10524 if (!ast_strlen_zero(id))
10525 astman_append(s, "ActionID: %s\r\n",id);
10526 } else {
10527 snprintf (cbuf, sizeof(cbuf), "Peer %s not found.\n", argv[3]);
10528 astman_send_error(s, m, cbuf);
10529 return 0;
10530 }
10531 }
10532 if (peer && type==0 ) {
10533 ast_cli(fd,"\n\n");
10534 ast_cli(fd, " * Name : %s\n", peer->name);
10535 if (realtimepeers) {
10536 ast_cli(fd, " Realtime peer: %s\n", ast_test_flag(&peer->flags[0], SIP_REALTIME) ? "Yes, cached" : "No");
10537 }
10538 ast_cli(fd, " Secret : %s\n", ast_strlen_zero(peer->secret)?"<Not set>":"<Set>");
10539 ast_cli(fd, " MD5Secret : %s\n", ast_strlen_zero(peer->md5secret)?"<Not set>":"<Set>");
10540 for (auth = peer->auth; auth; auth = auth->next) {
10541 ast_cli(fd, " Realm-auth : Realm %-15.15s User %-10.20s ", auth->realm, auth->username);
10542 ast_cli(fd, "%s\n", !ast_strlen_zero(auth->secret)?"<Secret set>":(!ast_strlen_zero(auth->md5secret)?"<MD5secret set>" : "<Not set>"));
10543 }
10544 ast_cli(fd, " Context : %s\n", peer->context);
10545 ast_cli(fd, " Subscr.Cont. : %s\n", S_OR(peer->subscribecontext, "<Not set>") );
10546 ast_cli(fd, " Language : %s\n", peer->language);
10547 if (!ast_strlen_zero(peer->accountcode))
10548 ast_cli(fd, " Accountcode : %s\n", peer->accountcode);
10549 ast_cli(fd, " AMA flags : %s\n", ast_cdr_flags2str(peer->amaflags));
10550 ast_cli(fd, " Transfer mode: %s\n", transfermode2str(peer->allowtransfer));
10551 ast_cli(fd, " CallingPres : %s\n", ast_describe_caller_presentation(peer->callingpres));
10552 if (!ast_strlen_zero(peer->fromuser))
10553 ast_cli(fd, " FromUser : %s\n", peer->fromuser);
10554 if (!ast_strlen_zero(peer->fromdomain))
10555 ast_cli(fd, " FromDomain : %s\n", peer->fromdomain);
10556 ast_cli(fd, " Callgroup : ");
10557 print_group(fd, peer->callgroup, 0);
10558 ast_cli(fd, " Pickupgroup : ");
10559 print_group(fd, peer->pickupgroup, 0);
10560 ast_cli(fd, " Mailbox : %s\n", peer->mailbox);
10561 ast_cli(fd, " VM Extension : %s\n", peer->vmexten);
10562 ast_cli(fd, " LastMsgsSent : %d/%d\n", (peer->lastmsgssent & 0x7fff0000) >> 16, peer->lastmsgssent & 0xffff);
10563 ast_cli(fd, " Call limit : %d\n", peer->call_limit);
10564 ast_cli(fd, " Dynamic : %s\n", (ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC)?"Yes":"No"));
10565 ast_cli(fd, " Callerid : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
10566 ast_cli(fd, " MaxCallBR : %d kbps\n", peer->maxcallbitrate);
10567 ast_cli(fd, " Expire : %ld\n", ast_sched_when(sched, peer->expire));
10568 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)));
10569 ast_cli(fd, " Nat : %s\n", nat2str(ast_test_flag(&peer->flags[0], SIP_NAT)));
10570 ast_cli(fd, " ACL : %s\n", (peer->ha?"Yes":"No"));
10571 ast_cli(fd, " T38 pt UDPTL : %s\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_T38SUPPORT_UDPTL)?"Yes":"No");
10572 #ifdef WHEN_WE_HAVE_T38_FOR_OTHER_TRANSPORTS
10573 ast_cli(fd, " T38 pt RTP : %s\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_T38SUPPORT_RTP)?"Yes":"No");
10574 ast_cli(fd, " T38 pt TCP : %s\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_T38SUPPORT_TCP)?"Yes":"No");
10575 #endif
10576 ast_cli(fd, " CanReinvite : %s\n", ast_test_flag(&peer->flags[0], SIP_CAN_REINVITE)?"Yes":"No");
10577 ast_cli(fd, " PromiscRedir : %s\n", ast_test_flag(&peer->flags[0], SIP_PROMISCREDIR)?"Yes":"No");
10578 ast_cli(fd, " User=Phone : %s\n", ast_test_flag(&peer->flags[0], SIP_USEREQPHONE)?"Yes":"No");
10579 ast_cli(fd, " Video Support: %s\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_VIDEOSUPPORT)?"Yes":"No");
10580 ast_cli(fd, " Trust RPID : %s\n", ast_test_flag(&peer->flags[0], SIP_TRUSTRPID) ? "Yes" : "No");
10581 ast_cli(fd, " Send RPID : %s\n", ast_test_flag(&peer->flags[0], SIP_SENDRPID) ? "Yes" : "No");
10582 ast_cli(fd, " Subscriptions: %s\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_ALLOWSUBSCRIBE) ? "Yes" : "No");
10583 ast_cli(fd, " Overlap dial : %s\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_ALLOWOVERLAP) ? "Yes" : "No");
10584
10585
10586 ast_cli(fd, " DTMFmode : %s\n", dtmfmode2str(ast_test_flag(&peer->flags[0], SIP_DTMF)));
10587 ast_cli(fd, " LastMsg : %d\n", peer->lastmsg);
10588 ast_cli(fd, " ToHost : %s\n", peer->tohost);
10589 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));
10590 ast_cli(fd, " Defaddr->IP : %s Port %d\n", ast_inet_ntoa(peer->defaddr.sin_addr), ntohs(peer->defaddr.sin_port));
10591 if (!ast_strlen_zero(global_regcontext))
10592 ast_cli(fd, " Reg. exten : %s\n", peer->regexten);
10593 ast_cli(fd, " Def. Username: %s\n", peer->username);
10594 ast_cli(fd, " SIP Options : ");
10595 if (peer->sipoptions) {
10596 int lastoption = -1;
10597 for (x=0 ; (x < (sizeof(sip_options) / sizeof(sip_options[0]))); x++) {
10598 if (sip_options[x].id != lastoption) {
10599 if (peer->sipoptions & sip_options[x].id)
10600 ast_cli(fd, "%s ", sip_options[x].text);
10601 lastoption = x;
10602 }
10603 }
10604 } else
10605 ast_cli(fd, "(none)");
10606
10607 ast_cli(fd, "\n");
10608 ast_cli(fd, " Codecs : ");
10609 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
10610 ast_cli(fd, "%s\n", codec_buf);
10611 ast_cli(fd, " Codec Order : (");
10612 print_codec_to_cli(fd, &peer->prefs);
10613 ast_cli(fd, ")\n");
10614
10615 ast_cli(fd, " Auto-Framing: %s \n", peer->autoframing ? "Yes" : "No");
10616 ast_cli(fd, " Status : ");
10617 peer_status(peer, status, sizeof(status));
10618 ast_cli(fd, "%s\n",status);
10619 ast_cli(fd, " Useragent : %s\n", peer->useragent);
10620 ast_cli(fd, " Reg. Contact : %s\n", peer->fullcontact);
10621 if (peer->chanvars) {
10622 ast_cli(fd, " Variables :\n");
10623 for (v = peer->chanvars ; v ; v = v->next)
10624 ast_cli(fd, " %s = %s\n", v->name, v->value);
10625 }
10626 ast_cli(fd,"\n");
10627 ASTOBJ_UNREF(peer,sip_destroy_peer);
10628 } else if (peer && type == 1) {
10629 char buf[256];
10630 astman_append(s, "Channeltype: SIP\r\n");
10631 astman_append(s, "ObjectName: %s\r\n", peer->name);
10632 astman_append(s, "ChanObjectType: peer\r\n");
10633 astman_append(s, "SecretExist: %s\r\n", ast_strlen_zero(peer->secret)?"N":"Y");
10634 astman_append(s, "MD5SecretExist: %s\r\n", ast_strlen_zero(peer->md5secret)?"N":"Y");
10635 astman_append(s, "Context: %s\r\n", peer->context);
10636 astman_append(s, "Language: %s\r\n", peer->language);
10637 if (!ast_strlen_zero(peer->accountcode))
10638 astman_append(s, "Accountcode: %s\r\n", peer->accountcode);
10639 astman_append(s, "AMAflags: %s\r\n", ast_cdr_flags2str(peer->amaflags));
10640 astman_append(s, "CID-CallingPres: %s\r\n", ast_describe_caller_presentation(peer->callingpres));
10641 if (!ast_strlen_zero(peer->fromuser))
10642 astman_append(s, "SIP-FromUser: %s\r\n", peer->fromuser);
10643 if (!ast_strlen_zero(peer->fromdomain))
10644 astman_append(s, "SIP-FromDomain: %s\r\n", peer->fromdomain);
10645 astman_append(s, "Callgroup: ");
10646 astman_append(s, "%s\r\n", ast_print_group(buf, sizeof(buf), peer->callgroup));
10647 astman_append(s, "Pickupgroup: ");
10648 astman_append(s, "%s\r\n", ast_print_group(buf, sizeof(buf), peer->pickupgroup));
10649 astman_append(s, "VoiceMailbox: %s\r\n", peer->mailbox);
10650 astman_append(s, "TransferMode: %s\r\n", transfermode2str(peer->allowtransfer));
10651 astman_append(s, "LastMsgsSent: %d\r\n", peer->lastmsgssent);
10652 astman_append(s, "Call-limit: %d\r\n", peer->call_limit);
10653 astman_append(s, "MaxCallBR: %d kbps\r\n", peer->maxcallbitrate);
10654 astman_append(s, "Dynamic: %s\r\n", (ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC)?"Y":"N"));
10655 astman_append(s, "Callerid: %s\r\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, ""));
10656 astman_append(s, "RegExpire: %ld seconds\r\n", ast_sched_when(sched,peer->expire));
10657 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)));
10658 astman_append(s, "SIP-NatSupport: %s\r\n", nat2str(ast_test_flag(&peer->flags[0], SIP_NAT)));
10659 astman_append(s, "ACL: %s\r\n", (peer->ha?"Y":"N"));
10660 astman_append(s, "SIP-CanReinvite: %s\r\n", (ast_test_flag(&peer->flags[0], SIP_CAN_REINVITE)?"Y":"N"));
10661 astman_append(s, "SIP-PromiscRedir: %s\r\n", (ast_test_flag(&peer->flags[0], SIP_PROMISCREDIR)?"Y":"N"));
10662 astman_append(s, "SIP-UserPhone: %s\r\n", (ast_test_flag(&peer->flags[0], SIP_USEREQPHONE)?"Y":"N"));
10663 astman_append(s, "SIP-VideoSupport: %s\r\n", (ast_test_flag(&peer->flags[1], SIP_PAGE2_VIDEOSUPPORT)?"Y":"N"));
10664
10665
10666 astman_append(s, "SIP-DTMFmode: %s\r\n", dtmfmode2str(ast_test_flag(&peer->flags[0], SIP_DTMF)));
10667 astman_append(s, "SIPLastMsg: %d\r\n", peer->lastmsg);
10668 astman_append(s, "ToHost: %s\r\n", peer->tohost);
10669 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));
10670 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));
10671 astman_append(s, "Default-Username: %s\r\n", peer->username);
10672 if (!ast_strlen_zero(global_regcontext))
10673 astman_append(s, "RegExtension: %s\r\n", peer->regexten);
10674 astman_append(s, "Codecs: ");
10675 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
10676 astman_append(s, "%s\r\n", codec_buf);
10677 astman_append(s, "CodecOrder: ");
10678 pref = &peer->prefs;
10679 for(x = 0; x < 32 ; x++) {
10680 codec = ast_codec_pref_index(pref,x);
10681 if (!codec)
10682 break;
10683 astman_append(s, "%s", ast_getformatname(codec));
10684 if (x < 31 && ast_codec_pref_index(pref,x+1))
10685 astman_append(s, ",");
10686 }
10687
10688 astman_append(s, "\r\n");
10689 astman_append(s, "Status: ");
10690 peer_status(peer, status, sizeof(status));
10691 astman_append(s, "%s\r\n", status);
10692 astman_append(s, "SIP-Useragent: %s\r\n", peer->useragent);
10693 astman_append(s, "Reg-Contact : %s\r\n", peer->fullcontact);
10694 if (peer->chanvars) {
10695 for (v = peer->chanvars ; v ; v = v->next) {
10696 astman_append(s, "ChanVariable:\n");
10697 astman_append(s, " %s,%s\r\n", v->name, v->value);
10698 }
10699 }
10700
10701 ASTOBJ_UNREF(peer,sip_destroy_peer);
10702
10703 } else {
10704 ast_cli(fd,"Peer %s not found.\n", argv[3]);
10705 ast_cli(fd,"\n");
10706 }
10707
10708 return RESULT_SUCCESS;
10709 }
10710
10711
10712 static int sip_show_user(int fd, int argc, char *argv[])
10713 {
10714 char cbuf[256];
10715 struct sip_user *user;
10716 struct ast_variable *v;
10717 int load_realtime;
10718
10719 if (argc < 4)
10720 return RESULT_SHOWUSAGE;
10721
10722
10723 load_realtime = (argc == 5 && !strcmp(argv[4], "load")) ? TRUE : FALSE;
10724
10725 user = find_user(argv[3], load_realtime);
10726 if (user) {
10727 ast_cli(fd,"\n\n");
10728 ast_cli(fd, " * Name : %s\n", user->name);
10729 ast_cli(fd, " Secret : %s\n", ast_strlen_zero(user->secret)?"<Not set>":"<Set>");
10730 ast_cli(fd, " MD5Secret : %s\n", ast_strlen_zero(user->md5secret)?"<Not set>":"<Set>");
10731 ast_cli(fd, " Context : %s\n", user->context);
10732 ast_cli(fd, " Language : %s\n", user->language);
10733 if (!ast_strlen_zero(user->accountcode))
10734 ast_cli(fd, " Accountcode : %s\n", user->accountcode);
10735 ast_cli(fd, " AMA flags : %s\n", ast_cdr_flags2str(user->amaflags));
10736 ast_cli(fd, " Transfer mode: %s\n", transfermode2str(user->allowtransfer));
10737 ast_cli(fd, " MaxCallBR : %d kbps\n", user->maxcallbitrate);
10738 ast_cli(fd, " CallingPres : %s\n", ast_describe_caller_presentation(user->callingpres));
10739 ast_cli(fd, " Call limit : %d\n", user->call_limit);
10740 ast_cli(fd, " Callgroup : ");
10741 print_group(fd, user->callgroup, 0);
10742 ast_cli(fd, " Pickupgroup : ");
10743 print_group(fd, user->pickupgroup, 0);
10744 ast_cli(fd, " Callerid : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), user->cid_name, user->cid_num, "<unspecified>"));
10745 ast_cli(fd, " ACL : %s\n", (user->ha?"Yes":"No"));
10746 ast_cli(fd, " Codec Order : (");
10747 print_codec_to_cli(fd, &user->prefs);
10748 ast_cli(fd, ")\n");
10749
10750 ast_cli(fd, " Auto-Framing: %s \n", user->autoframing ? "Yes" : "No");
10751 if (user->chanvars) {
10752 ast_cli(fd, " Variables :\n");
10753 for (v = user->chanvars ; v ; v = v->next)
10754 ast_cli(fd, " %s = %s\n", v->name, v->value);
10755 }
10756 ast_cli(fd,"\n");
10757 ASTOBJ_UNREF(user,sip_destroy_user);
10758 } else {
10759 ast_cli(fd,"User %s not found.\n", argv[3]);
10760 ast_cli(fd,"\n");
10761 }
10762
10763 return RESULT_SUCCESS;
10764 }
10765
10766
10767 static int sip_show_registry(int fd, int argc, char *argv[])
10768 {
10769 #define FORMAT2 "%-30.30s %-12.12s %8.8s %-20.20s %-25.25s\n"
10770 #define FORMAT "%-30.30s %-12.12s %8d %-20.20s %-25.25s\n"
10771 char host[80];
10772 char tmpdat[256];
10773 struct tm tm;
10774
10775
10776 if (argc != 3)
10777 return RESULT_SHOWUSAGE;
10778 ast_cli(fd, FORMAT2, "Host", "Username", "Refresh", "State", "Reg.Time");
10779 ASTOBJ_CONTAINER_TRAVERSE(®l, 1, do {
10780 ASTOBJ_RDLOCK(iterator);
10781 snprintf(host, sizeof(host), "%s:%d", iterator->hostname, iterator->portno ? iterator->portno : STANDARD_SIP_PORT);
10782 if (iterator->regtime) {
10783 ast_localtime(&iterator->regtime, &tm, NULL);
10784 strftime(tmpdat, sizeof(tmpdat), "%a, %d %b %Y %T", &tm);
10785 } else {
10786 tmpdat[0] = 0;
10787 }
10788 ast_cli(fd, FORMAT, host, iterator->username, iterator->refresh, regstate2str(iterator->regstate), tmpdat);
10789 ASTOBJ_UNLOCK(iterator);
10790 } while(0));
10791 return RESULT_SUCCESS;
10792 #undef FORMAT
10793 #undef FORMAT2
10794 }
10795
10796
10797 static int sip_show_settings(int fd, int argc, char *argv[])
10798 {
10799 int realtimepeers;
10800 int realtimeusers;
10801 char codec_buf[SIPBUFSIZE];
10802
10803 realtimepeers = ast_check_realtime("sippeers");
10804 realtimeusers = ast_check_realtime("sipusers");
10805
10806 if (argc != 3)
10807 return RESULT_SHOWUSAGE;
10808 ast_cli(fd, "\n\nGlobal Settings:\n");
10809 ast_cli(fd, "----------------\n");
10810 ast_cli(fd, " SIP Port: %d\n", ntohs(bindaddr.sin_port));
10811 ast_cli(fd, " Bindaddress: %s\n", ast_inet_ntoa(bindaddr.sin_addr));
10812 ast_cli(fd, " Videosupport: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_VIDEOSUPPORT) ? "Yes" : "No");
10813 ast_cli(fd, " AutoCreatePeer: %s\n", autocreatepeer ? "Yes" : "No");
10814 ast_cli(fd, " Allow unknown access: %s\n", global_allowguest ? "Yes" : "No");
10815 ast_cli(fd, " Allow subscriptions: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_ALLOWSUBSCRIBE) ? "Yes" : "No");
10816 ast_cli(fd, " Allow overlap dialing: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_ALLOWOVERLAP) ? "Yes" : "No");
10817 ast_cli(fd, " Promsic. redir: %s\n", ast_test_flag(&global_flags[0], SIP_PROMISCREDIR) ? "Yes" : "No");
10818 ast_cli(fd, " SIP domain support: %s\n", AST_LIST_EMPTY(&domain_list) ? "No" : "Yes");
10819 ast_cli(fd, " Call to non-local dom.: %s\n", allow_external_domains ? "Yes" : "No");
10820 ast_cli(fd, " URI user is phone no: %s\n", ast_test_flag(&global_flags[0], SIP_USEREQPHONE) ? "Yes" : "No");
10821 ast_cli(fd, " Our auth realm %s\n", global_realm);
10822 ast_cli(fd, " Realm. auth: %s\n", authl ? "Yes": "No");
10823 ast_cli(fd, " Always auth rejects: %s\n", global_alwaysauthreject ? "Yes" : "No");
10824 ast_cli(fd, " Call limit peers only: %s\n", global_limitonpeers ? "Yes" : "No");
10825 ast_cli(fd, " Direct RTP setup: %s\n", global_directrtpsetup ? "Yes" : "No");
10826 ast_cli(fd, " User Agent: %s\n", global_useragent);
10827 ast_cli(fd, " MWI checking interval: %d secs\n", global_mwitime);
10828 ast_cli(fd, " Reg. context: %s\n", S_OR(global_regcontext, "(not set)"));
10829 ast_cli(fd, " Caller ID: %s\n", default_callerid);
10830 ast_cli(fd, " From: Domain: %s\n", default_fromdomain);
10831 ast_cli(fd, " Record SIP history: %s\n", recordhistory ? "On" : "Off");
10832 ast_cli(fd, " Call Events: %s\n", global_callevents ? "On" : "Off");
10833 ast_cli(fd, " IP ToS SIP: %s\n", ast_tos2str(global_tos_sip));
10834 ast_cli(fd, " IP ToS RTP audio: %s\n", ast_tos2str(global_tos_audio));
10835 ast_cli(fd, " IP ToS RTP video: %s\n", ast_tos2str(global_tos_video));
10836 ast_cli(fd, " T38 fax pt UDPTL: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_T38SUPPORT_UDPTL) ? "Yes" : "No");
10837 #ifdef WHEN_WE_HAVE_T38_FOR_OTHER_TRANSPORTS
10838 ast_cli(fd, " T38 fax pt RTP: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_T38SUPPORT_RTP) ? "Yes" : "No");
10839 ast_cli(fd, " T38 fax pt TCP: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_T38SUPPORT_TCP) ? "Yes" : "No");
10840 #endif
10841 ast_cli(fd, " RFC2833 Compensation: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_RFC2833_COMPENSATE) ? "Yes" : "No");
10842 if (!realtimepeers && !realtimeusers)
10843 ast_cli(fd, " SIP realtime: Disabled\n" );
10844 else
10845 ast_cli(fd, " SIP realtime: Enabled\n" );
10846
10847 ast_cli(fd, "\nGlobal Signalling Settings:\n");
10848 ast_cli(fd, "---------------------------\n");
10849 ast_cli(fd, " Codecs: ");
10850 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, global_capability);
10851 ast_cli(fd, "%s\n", codec_buf);
10852 ast_cli(fd, " Codec Order: ");
10853 print_codec_to_cli(fd, &default_prefs);
10854 ast_cli(fd, "\n");
10855 ast_cli(fd, " T1 minimum: %d\n", global_t1min);
10856 ast_cli(fd, " Relax DTMF: %s\n", global_relaxdtmf ? "Yes" : "No");
10857 ast_cli(fd, " Compact SIP headers: %s\n", compactheaders ? "Yes" : "No");
10858 ast_cli(fd, " RTP Keepalive: %d %s\n", global_rtpkeepalive, global_rtpkeepalive ? "" : "(Disabled)" );
10859 ast_cli(fd, " RTP Timeout: %d %s\n", global_rtptimeout, global_rtptimeout ? "" : "(Disabled)" );
10860 ast_cli(fd, " RTP Hold Timeout: %d %s\n", global_rtpholdtimeout, global_rtpholdtimeout ? "" : "(Disabled)");
10861 ast_cli(fd, " MWI NOTIFY mime type: %s\n", default_notifymime);
10862 ast_cli(fd, " DNS SRV lookup: %s\n", srvlookup ? "Yes" : "No");
10863 ast_cli(fd, " Pedantic SIP support: %s\n", pedanticsipchecking ? "Yes" : "No");
10864 ast_cli(fd, " Reg. min duration %d secs\n", min_expiry);
10865 ast_cli(fd, " Reg. max duration: %d secs\n", max_expiry);
10866 ast_cli(fd, " Reg. default duration: %d secs\n", default_expiry);
10867 ast_cli(fd, " Outbound reg. timeout: %d secs\n", global_reg_timeout);
10868 ast_cli(fd, " Outbound reg. attempts: %d\n", global_regattempts_max);
10869 ast_cli(fd, " Notify ringing state: %s\n", global_notifyringing ? "Yes" : "No");
10870 ast_cli(fd, " Notify hold state: %s\n", global_notifyhold ? "Yes" : "No");
10871 ast_cli(fd, " SIP Transfer mode: %s\n", transfermode2str(global_allowtransfer));
10872 ast_cli(fd, " Max Call Bitrate: %d kbps\r\n", default_maxcallbitrate);
10873 ast_cli(fd, " Auto-Framing: %s \r\n", global_autoframing ? "Yes" : "No");
10874 ast_cli(fd, "\nDefault Settings:\n");
10875 ast_cli(fd, "-----------------\n");
10876 ast_cli(fd, " Context: %s\n", default_context);
10877 ast_cli(fd, " Nat: %s\n", nat2str(ast_test_flag(&global_flags[0], SIP_NAT)));
10878 ast_cli(fd, " DTMF: %s\n", dtmfmode2str(ast_test_flag(&global_flags[0], SIP_DTMF)));
10879 ast_cli(fd, " Qualify: %d\n", default_qualify);
10880 ast_cli(fd, " Use ClientCode: %s\n", ast_test_flag(&global_flags[0], SIP_USECLIENTCODE) ? "Yes" : "No");
10881 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" );
10882 ast_cli(fd, " Language: %s\n", S_OR(default_language, "(Defaults to English)"));
10883 ast_cli(fd, " MOH Interpret: %s\n", default_mohinterpret);
10884 ast_cli(fd, " MOH Suggest: %s\n", default_mohsuggest);
10885 ast_cli(fd, " Voice Mail Extension: %s\n", default_vmexten);
10886
10887
10888 if (realtimepeers || realtimeusers) {
10889 ast_cli(fd, "\nRealtime SIP Settings:\n");
10890 ast_cli(fd, "----------------------\n");
10891 ast_cli(fd, " Realtime Peers: %s\n", realtimepeers ? "Yes" : "No");
10892 ast_cli(fd, " Realtime Users: %s\n", realtimeusers ? "Yes" : "No");
10893 ast_cli(fd, " Cache Friends: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS) ? "Yes" : "No");
10894 ast_cli(fd, " Update: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_RTUPDATE) ? "Yes" : "No");
10895 ast_cli(fd, " Ignore Reg. Expire: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_IGNOREREGEXPIRE) ? "Yes" : "No");
10896 ast_cli(fd, " Save sys. name: %s\n", ast_test_flag(&global_flags[1], SIP_PAGE2_RTSAVE_SYSNAME) ? "Yes" : "No");
10897 ast_cli(fd, " Auto Clear: %d\n", global_rtautoclear);
10898 }
10899 ast_cli(fd, "\n----\n");
10900 return RESULT_SUCCESS;
10901 }
10902
10903
10904 static const char *subscription_type2str(enum subscriptiontype subtype)
10905 {
10906 int i;
10907
10908 for (i = 1; (i < (sizeof(subscription_types) / sizeof(subscription_types[0]))); i++) {
10909 if (subscription_types[i].type == subtype) {
10910 return subscription_types[i].text;
10911 }
10912 }
10913 return subscription_types[0].text;
10914 }
10915
10916
10917 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype)
10918 {
10919 int i;
10920
10921 for (i = 1; (i < (sizeof(subscription_types) / sizeof(subscription_types[0]))); i++) {
10922 if (subscription_types[i].type == subtype) {
10923 return &subscription_types[i];
10924 }
10925 }
10926 return &subscription_types[0];
10927 }
10928
10929
10930 static int sip_show_channels(int fd, int argc, char *argv[])
10931 {
10932 return __sip_show_channels(fd, argc, argv, 0);
10933 }
10934
10935
10936 static int sip_show_subscriptions(int fd, int argc, char *argv[])
10937 {
10938 return __sip_show_channels(fd, argc, argv, 1);
10939 }
10940
10941
10942 static int __sip_show_channels(int fd, int argc, char *argv[], int subscriptions)
10943 {
10944 #define FORMAT3 "%-15.15s %-10.10s %-11.11s %-15.15s %-13.13s %-15.15s %-10.10s\n"
10945 #define FORMAT2 "%-15.15s %-10.10s %-11.11s %-11.11s %-15.15s %-7.7s %-15.15s\n"
10946 #define FORMAT "%-15.15s %-10.10s %-11.11s %5.5d/%5.5d %-15.15s %-3.3s %-3.3s %-15.15s %-10.10s\n"
10947 struct sip_pvt *cur;
10948 int numchans = 0;
10949 char *referstatus = NULL;
10950
10951 if (argc != 3)
10952 return RESULT_SHOWUSAGE;
10953 ast_mutex_lock(&iflock);
10954 cur = iflist;
10955 if (!subscriptions)
10956 ast_cli(fd, FORMAT2, "Peer", "User/ANR", "Call ID", "Seq (Tx/Rx)", "Format", "Hold", "Last Message");
10957 else
10958 ast_cli(fd, FORMAT3, "Peer", "User", "Call ID", "Extension", "Last state", "Type", "Mailbox");
10959 for (; cur; cur = cur->next) {
10960 referstatus = "";
10961 if (cur->refer) {
10962 referstatus = referstatus2str(cur->refer->status);
10963 }
10964 if (cur->subscribed == NONE && !subscriptions) {
10965 char formatbuf[SIPBUFSIZE/2];
10966 ast_cli(fd, FORMAT, ast_inet_ntoa(cur->sa.sin_addr),
10967 S_OR(cur->username, S_OR(cur->cid_num, "(None)")),
10968 cur->callid,
10969 cur->ocseq, cur->icseq,
10970 ast_getformatname_multiple(formatbuf, sizeof(formatbuf), cur->owner ? cur->owner->nativeformats : 0),
10971 ast_test_flag(&cur->flags[1], SIP_PAGE2_CALL_ONHOLD) ? "Yes" : "No",
10972 ast_test_flag(&cur->flags[0], SIP_NEEDDESTROY) ? "(d)" : "",
10973 cur->lastmsg ,
10974 referstatus
10975 );
10976 numchans++;
10977 }
10978 if (cur->subscribed != NONE && subscriptions) {
10979 ast_cli(fd, FORMAT3, ast_inet_ntoa(cur->sa.sin_addr),
10980 S_OR(cur->username, S_OR(cur->cid_num, "(None)")),
10981 cur->callid,
10982
10983 cur->subscribed == MWI_NOTIFICATION ? "--" : cur->subscribeuri,
10984 cur->subscribed == MWI_NOTIFICATION ? "<none>" : ast_extension_state2str(cur->laststate),
10985 subscription_type2str(cur->subscribed),
10986 cur->subscribed == MWI_NOTIFICATION ? (cur->relatedpeer ? cur->relatedpeer->mailbox : "<none>") : "<none>"
10987 );
10988 numchans++;
10989 }
10990 }
10991 ast_mutex_unlock(&iflock);
10992 if (!subscriptions)
10993 ast_cli(fd, "%d active SIP channel%s\n", numchans, (numchans != 1) ? "s" : "");
10994 else
10995 ast_cli(fd, "%d active SIP subscription%s\n", numchans, (numchans != 1) ? "s" : "");
10996 return RESULT_SUCCESS;
10997 #undef FORMAT
10998 #undef FORMAT2
10999 #undef FORMAT3
11000 }
11001
11002
11003 static char *complete_sipch(const char *line, const char *word, int pos, int state)
11004 {
11005 int which=0;
11006 struct sip_pvt *cur;
11007 char *c = NULL;
11008 int wordlen = strlen(word);
11009
11010 if (pos != 3) {
11011 return NULL;
11012 }
11013
11014 ast_mutex_lock(&iflock);
11015 for (cur = iflist; cur; cur = cur->next) {
11016 if (!strncasecmp(word, cur->callid, wordlen) && ++which > state) {
11017 c = ast_strdup(cur->callid);
11018 break;
11019 }
11020 }
11021 ast_mutex_unlock(&iflock);
11022 return c;
11023 }
11024
11025
11026 static char *complete_sip_peer(const char *word, int state, int flags2)
11027 {
11028 char *result = NULL;
11029 int wordlen = strlen(word);
11030 int which = 0;
11031
11032 ASTOBJ_CONTAINER_TRAVERSE(&peerl, !result, do {
11033
11034 if (!strncasecmp(word, iterator->name, wordlen) &&
11035 (!flags2 || ast_test_flag(&iterator->flags[1], flags2)) &&
11036 ++which > state)
11037 result = ast_strdup(iterator->name);
11038 } while(0) );
11039 return result;
11040 }
11041
11042
11043 static char *complete_sip_show_peer(const char *line, const char *word, int pos, int state)
11044 {
11045 if (pos == 3)
11046 return complete_sip_peer(word, state, 0);
11047
11048 return NULL;
11049 }
11050
11051
11052 static char *complete_sip_debug_peer(const char *line, const char *word, int pos, int state)
11053 {
11054 if (pos == 3)
11055 return complete_sip_peer(word, state, 0);
11056
11057 return NULL;
11058 }
11059
11060
11061 static char *complete_sip_user(const char *word, int state, int flags2)
11062 {
11063 char *result = NULL;
11064 int wordlen = strlen(word);
11065 int which = 0;
11066
11067 ASTOBJ_CONTAINER_TRAVERSE(&userl, !result, do {
11068
11069 if (!strncasecmp(word, iterator->name, wordlen)) {
11070 if (flags2 && !ast_test_flag(&iterator->flags[1], flags2))
11071 continue;
11072 if (++which > state) {
11073 result = ast_strdup(iterator->name);
11074 }
11075 }
11076 } while(0) );
11077 return result;
11078 }
11079
11080
11081 static char *complete_sip_show_user(const char *line, const char *word, int pos, int state)
11082 {
11083 if (pos == 3)
11084 return complete_sip_user(word, state, 0);
11085
11086 return NULL;
11087 }
11088
11089
11090 static char *complete_sipnotify(const char *line, const char *word, int pos, int state)
11091 {
11092 char *c = NULL;
11093
11094 if (pos == 2) {
11095 int which = 0;
11096 char *cat = NULL;
11097 int wordlen = strlen(word);
11098
11099
11100
11101 if (!notify_types)
11102 return NULL;
11103
11104 while ( (cat = ast_category_browse(notify_types, cat)) ) {
11105 if (!strncasecmp(word, cat, wordlen) && ++which > state) {
11106 c = ast_strdup(cat);
11107 break;
11108 }
11109 }
11110 return c;
11111 }
11112
11113 if (pos > 2)
11114 return complete_sip_peer(word, state, 0);
11115
11116 return NULL;
11117 }
11118
11119
11120 static char *complete_sip_prune_realtime_peer(const char *line, const char *word, int pos, int state)
11121 {
11122 if (pos == 4)
11123 return complete_sip_peer(word, state, SIP_PAGE2_RTCACHEFRIENDS);
11124 return NULL;
11125 }
11126
11127
11128 static char *complete_sip_prune_realtime_user(const char *line, const char *word, int pos, int state)
11129 {
11130 if (pos == 4)
11131 return complete_sip_user(word, state, SIP_PAGE2_RTCACHEFRIENDS);
11132
11133 return NULL;
11134 }
11135
11136
11137 static int sip_show_channel(int fd, int argc, char *argv[])
11138 {
11139 struct sip_pvt *cur;
11140 size_t len;
11141 int found = 0;
11142
11143 if (argc != 4)
11144 return RESULT_SHOWUSAGE;
11145 len = strlen(argv[3]);
11146 ast_mutex_lock(&iflock);
11147 for (cur = iflist; cur; cur = cur->next) {
11148 if (!strncasecmp(cur->callid, argv[3], len)) {
11149 char formatbuf[SIPBUFSIZE/2];
11150 ast_cli(fd,"\n");
11151 if (cur->subscribed != NONE)
11152 ast_cli(fd, " * Subscription (type: %s)\n", subscription_type2str(cur->subscribed));
11153 else
11154 ast_cli(fd, " * SIP Call\n");
11155 ast_cli(fd, " Curr. trans. direction: %s\n", ast_test_flag(&cur->flags[0], SIP_OUTGOING) ? "Outgoing" : "Incoming");
11156 ast_cli(fd, " Call-ID: %s\n", cur->callid);
11157 ast_cli(fd, " Owner channel ID: %s\n", cur->owner ? cur->owner->name : "<none>");
11158 ast_cli(fd, " Our Codec Capability: %d\n", cur->capability);
11159 ast_cli(fd, " Non-Codec Capability (DTMF): %d\n", cur->noncodeccapability);
11160 ast_cli(fd, " Their Codec Capability: %d\n", cur->peercapability);
11161 ast_cli(fd, " Joint Codec Capability: %d\n", cur->jointcapability);
11162 ast_cli(fd, " Format: %s\n", ast_getformatname_multiple(formatbuf, sizeof(formatbuf), cur->owner ? cur->owner->nativeformats : 0) );
11163 ast_cli(fd, " MaxCallBR: %d kbps\n", cur->maxcallbitrate);
11164 ast_cli(fd, " Theoretical Address: %s:%d\n", ast_inet_ntoa(cur->sa.sin_addr), ntohs(cur->sa.sin_port));
11165 ast_cli(fd, " Received Address: %s:%d\n", ast_inet_ntoa(cur->recv.sin_addr), ntohs(cur->recv.sin_port));
11166 ast_cli(fd, " SIP Transfer mode: %s\n", transfermode2str(cur->allowtransfer));
11167 ast_cli(fd, " NAT Support: %s\n", nat2str(ast_test_flag(&cur->flags[0], SIP_NAT)));
11168 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)" );
11169 ast_cli(fd, " Our Tag: %s\n", cur->tag);
11170 ast_cli(fd, " Their Tag: %s\n", cur->theirtag);
11171 ast_cli(fd, " SIP User agent: %s\n", cur->useragent);
11172 if (!ast_strlen_zero(cur->username))
11173 ast_cli(fd, " Username: %s\n", cur->username);
11174 if (!ast_strlen_zero(cur->peername))
11175 ast_cli(fd, " Peername: %s\n", cur->peername);
11176 if (!ast_strlen_zero(cur->uri))
11177 ast_cli(fd, " Original uri: %s\n", cur->uri);
11178 if (!ast_strlen_zero(cur->cid_num))
11179 ast_cli(fd, " Caller-ID: %s\n", cur->cid_num);
11180 ast_cli(fd, " Need Destroy: %d\n", ast_test_flag(&cur->flags[0], SIP_NEEDDESTROY));
11181 ast_cli(fd, " Last Message: %s\n", cur->lastmsg);
11182 ast_cli(fd, " Promiscuous Redir: %s\n", ast_test_flag(&cur->flags[0], SIP_PROMISCREDIR) ? "Yes" : "No");
11183 ast_cli(fd, " Route: %s\n", cur->route ? cur->route->hop : "N/A");
11184 ast_cli(fd, " DTMF Mode: %s\n", dtmfmode2str(ast_test_flag(&cur->flags[0], SIP_DTMF)));
11185 ast_cli(fd, " SIP Options: ");
11186 if (cur->sipoptions) {
11187 int x;
11188 for (x=0 ; (x < (sizeof(sip_options) / sizeof(sip_options[0]))); x++) {
11189 if (cur->sipoptions & sip_options[x].id)
11190 ast_cli(fd, "%s ", sip_options[x].text);
11191 }
11192 } else
11193 ast_cli(fd, "(none)\n");
11194 ast_cli(fd, "\n\n");
11195 found++;
11196 }
11197 }
11198 ast_mutex_unlock(&iflock);
11199 if (!found)
11200 ast_cli(fd, "No such SIP Call ID starting with '%s'\n", argv[3]);
11201 return RESULT_SUCCESS;
11202 }
11203
11204
11205 static int sip_show_history(int fd, int argc, char *argv[])
11206 {
11207 struct sip_pvt *cur;
11208 size_t len;
11209 int found = 0;
11210
11211 if (argc != 4)
11212 return RESULT_SHOWUSAGE;
11213 if (!recordhistory)
11214 ast_cli(fd, "\n***Note: History recording is currently DISABLED. Use 'sip history' to ENABLE.\n");
11215 len = strlen(argv[3]);
11216 ast_mutex_lock(&iflock);
11217 for (cur = iflist; cur; cur = cur->next) {
11218 if (!strncasecmp(cur->callid, argv[3], len)) {
11219 struct sip_history *hist;
11220 int x = 0;
11221
11222 ast_cli(fd,"\n");
11223 if (cur->subscribed != NONE)
11224 ast_cli(fd, " * Subscription\n");
11225 else
11226 ast_cli(fd, " * SIP Call\n");
11227 if (cur->history)
11228 AST_LIST_TRAVERSE(cur->history, hist, list)
11229 ast_cli(fd, "%d. %s\n", ++x, hist->event);
11230 if (x == 0)
11231 ast_cli(fd, "Call '%s' has no history\n", cur->callid);
11232 found++;
11233 }
11234 }
11235 ast_mutex_unlock(&iflock);
11236 if (!found)
11237 ast_cli(fd, "No such SIP Call ID starting with '%s'\n", argv[3]);
11238 return RESULT_SUCCESS;
11239 }
11240
11241
11242 static void sip_dump_history(struct sip_pvt *dialog)
11243 {
11244 int x = 0;
11245 struct sip_history *hist;
11246 static int errmsg = 0;
11247
11248 if (!dialog)
11249 return;
11250
11251 if (!option_debug && !sipdebug) {
11252 if (!errmsg) {
11253 ast_log(LOG_NOTICE, "You must have debugging enabled (SIP or Asterisk) in order to dump SIP history.\n");
11254 errmsg = 1;
11255 }
11256 return;
11257 }
11258
11259 ast_log(LOG_DEBUG, "\n---------- SIP HISTORY for '%s' \n", dialog->callid);
11260 if (dialog->subscribed)
11261 ast_log(LOG_DEBUG, " * Subscription\n");
11262 else
11263 ast_log(LOG_DEBUG, " * SIP Call\n");
11264 if (dialog->history)
11265 AST_LIST_TRAVERSE(dialog->history, hist, list)
11266 ast_log(LOG_DEBUG, " %-3.3d. %s\n", ++x, hist->event);
11267 if (!x)
11268 ast_log(LOG_DEBUG, "Call '%s' has no history\n", dialog->callid);
11269 ast_log(LOG_DEBUG, "\n---------- END SIP HISTORY for '%s' \n", dialog->callid);
11270 }
11271
11272
11273
11274
11275 static void handle_request_info(struct sip_pvt *p, struct sip_request *req)
11276 {
11277 char buf[1024];
11278 unsigned int event;
11279 const char *c = get_header(req, "Content-Type");
11280
11281
11282 if (!strcasecmp(c, "application/dtmf-relay") ||
11283 !strcasecmp(c, "application/vnd.nortelnetworks.digits")) {
11284 unsigned int duration = 0;
11285
11286
11287 if (ast_strlen_zero(c = get_body(req, "Signal")) && ast_strlen_zero(c = get_body(req, "d"))) {
11288 ast_log(LOG_WARNING, "Unable to retrieve DTMF signal from INFO message from %s\n", p->callid);
11289 transmit_response(p, "200 OK", req);
11290 return;
11291 } else {
11292 ast_copy_string(buf, c, sizeof(buf));
11293 }
11294
11295 if (!ast_strlen_zero((c = get_body(req, "Duration"))))
11296 duration = atoi(c);
11297 if (!duration)
11298 duration = 100;
11299
11300 if (!p->owner) {
11301 transmit_response(p, "481 Call leg/transaction does not exist", req);
11302 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
11303 return;
11304 }
11305
11306 if (ast_strlen_zero(buf)) {
11307 transmit_response(p, "200 OK", req);
11308 return;
11309 }
11310
11311 if (buf[0] == '*')
11312 event = 10;
11313 else if (buf[0] == '#')
11314 event = 11;
11315 else if ((buf[0] >= 'A') && (buf[0] <= 'D'))
11316 event = 12 + buf[0] - 'A';
11317 else
11318 event = atoi(buf);
11319 if (event == 16) {
11320
11321 struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_FLASH, };
11322 ast_queue_frame(p->owner, &f);
11323 if (sipdebug)
11324 ast_verbose("* DTMF-relay event received: FLASH\n");
11325 } else {
11326
11327 struct ast_frame f = { AST_FRAME_DTMF, };
11328 if (event < 10) {
11329 f.subclass = '0' + event;
11330 } else if (event < 11) {
11331 f.subclass = '*';
11332 } else if (event < 12) {
11333 f.subclass = '#';
11334 } else if (event < 16) {
11335 f.subclass = 'A' + (event - 12);
11336 }
11337 f.len = duration;
11338 ast_queue_frame(p->owner, &f);
11339 if (sipdebug)
11340 ast_verbose("* DTMF-relay event received: %c\n", f.subclass);
11341 }
11342 transmit_response(p, "200 OK", req);
11343 return;
11344 } else if (!strcasecmp(c, "application/media_control+xml")) {
11345
11346 if (p->owner)
11347 ast_queue_control(p->owner, AST_CONTROL_VIDUPDATE);
11348 transmit_response(p, "200 OK", req);
11349 return;
11350 } else if (!ast_strlen_zero(c = get_header(req, "X-ClientCode"))) {
11351
11352 if (ast_test_flag(&p->flags[0], SIP_USECLIENTCODE)) {
11353 if (p->owner && p->owner->cdr)
11354 ast_cdr_setuserfield(p->owner, c);
11355 if (p->owner && ast_bridged_channel(p->owner) && ast_bridged_channel(p->owner)->cdr)
11356 ast_cdr_setuserfield(ast_bridged_channel(p->owner), c);
11357 transmit_response(p, "200 OK", req);
11358 } else {
11359 transmit_response(p, "403 Unauthorized", req);
11360 }
11361 return;
11362 } else if (ast_strlen_zero(c = get_header(req, "Content-Length")) || !strcasecmp(c, "0")) {
11363
11364 transmit_response(p, "200 OK", req);
11365 return;
11366 }
11367
11368
11369
11370
11371 ast_log(LOG_WARNING, "Unable to parse INFO message from %s. Content %s\n", p->callid, buf);
11372 transmit_response(p, "415 Unsupported media type", req);
11373 return;
11374 }
11375
11376
11377 static int sip_do_debug_ip(int fd, int argc, char *argv[])
11378 {
11379 struct hostent *hp;
11380 struct ast_hostent ahp;
11381 int port = 0;
11382 char *p, *arg;
11383
11384
11385 if (argc != 5)
11386 return RESULT_SHOWUSAGE;
11387 p = arg = argv[4];
11388 strsep(&p, ":");
11389 if (p)
11390 port = atoi(p);
11391 hp = ast_gethostbyname(arg, &ahp);
11392 if (hp == NULL)
11393 return RESULT_SHOWUSAGE;
11394
11395 debugaddr.sin_family = AF_INET;
11396 memcpy(&debugaddr.sin_addr, hp->h_addr, sizeof(debugaddr.sin_addr));
11397 debugaddr.sin_port = htons(port);
11398 if (port == 0)
11399 ast_cli(fd, "SIP Debugging Enabled for IP: %s\n", ast_inet_ntoa(debugaddr.sin_addr));
11400 else
11401 ast_cli(fd, "SIP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(debugaddr.sin_addr), port);
11402
11403 ast_set_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
11404
11405 return RESULT_SUCCESS;
11406 }
11407
11408
11409 static int sip_do_debug_peer(int fd, int argc, char *argv[])
11410 {
11411 struct sip_peer *peer;
11412 if (argc != 5)
11413 return RESULT_SHOWUSAGE;
11414 peer = find_peer(argv[4], NULL, 1);
11415 if (peer) {
11416 if (peer->addr.sin_addr.s_addr) {
11417 debugaddr.sin_family = AF_INET;
11418 debugaddr.sin_addr = peer->addr.sin_addr;
11419 debugaddr.sin_port = peer->addr.sin_port;
11420 ast_cli(fd, "SIP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(debugaddr.sin_addr), ntohs(debugaddr.sin_port));
11421 ast_set_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
11422 } else
11423 ast_cli(fd, "Unable to get IP address of peer '%s'\n", argv[4]);
11424 ASTOBJ_UNREF(peer,sip_destroy_peer);
11425 } else
11426 ast_cli(fd, "No such peer '%s'\n", argv[4]);
11427 return RESULT_SUCCESS;
11428 }
11429
11430
11431 static int sip_do_debug(int fd, int argc, char *argv[])
11432 {
11433 int oldsipdebug = sipdebug_console;
11434 if (argc != 3) {
11435 if (argc != 5)
11436 return RESULT_SHOWUSAGE;
11437 else if (strcmp(argv[3], "ip") == 0)
11438 return sip_do_debug_ip(fd, argc, argv);
11439 else if (strcmp(argv[3], "peer") == 0)
11440 return sip_do_debug_peer(fd, argc, argv);
11441 else
11442 return RESULT_SHOWUSAGE;
11443 }
11444 ast_set_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
11445 memset(&debugaddr, 0, sizeof(debugaddr));
11446 ast_cli(fd, "SIP Debugging %senabled\n", oldsipdebug ? "re-" : "");
11447 return RESULT_SUCCESS;
11448 }
11449
11450 static int sip_do_debug_deprecated(int fd, int argc, char *argv[])
11451 {
11452 int oldsipdebug = sipdebug_console;
11453 char *newargv[6] = { "sip", "set", "debug", NULL };
11454 if (argc != 2) {
11455 if (argc != 4)
11456 return RESULT_SHOWUSAGE;
11457 else if (strcmp(argv[2], "ip") == 0) {
11458 newargv[3] = argv[2];
11459 newargv[4] = argv[3];
11460 return sip_do_debug_ip(fd, argc + 1, newargv);
11461 } else if (strcmp(argv[2], "peer") == 0) {
11462 newargv[3] = argv[2];
11463 newargv[4] = argv[3];
11464 return sip_do_debug_peer(fd, argc + 1, newargv);
11465 } else
11466 return RESULT_SHOWUSAGE;
11467 }
11468 ast_set_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
11469 memset(&debugaddr, 0, sizeof(debugaddr));
11470 ast_cli(fd, "SIP Debugging %senabled\n", oldsipdebug ? "re-" : "");
11471 return RESULT_SUCCESS;
11472 }
11473
11474
11475 static int sip_notify(int fd, int argc, char *argv[])
11476 {
11477 struct ast_variable *varlist;
11478 int i;
11479
11480 if (argc < 4)
11481 return RESULT_SHOWUSAGE;
11482
11483 if (!notify_types) {
11484 ast_cli(fd, "No %s file found, or no types listed there\n", notify_config);
11485 return RESULT_FAILURE;
11486 }
11487
11488 varlist = ast_variable_browse(notify_types, argv[2]);
11489
11490 if (!varlist) {
11491 ast_cli(fd, "Unable to find notify type '%s'\n", argv[2]);
11492 return RESULT_FAILURE;
11493 }
11494
11495 for (i = 3; i < argc; i++) {
11496 struct sip_pvt *p;
11497 struct sip_request req;
11498 struct ast_variable *var;
11499
11500 if (!(p = sip_alloc(NULL, NULL, 0, SIP_NOTIFY))) {
11501 ast_log(LOG_WARNING, "Unable to build sip pvt data for notify (memory/socket error)\n");
11502 return RESULT_FAILURE;
11503 }
11504
11505 if (create_addr(p, argv[i])) {
11506
11507 sip_destroy(p);
11508 ast_cli(fd, "Could not create address for '%s'\n", argv[i]);
11509 continue;
11510 }
11511
11512 initreqprep(&req, p, SIP_NOTIFY);
11513
11514 for (var = varlist; var; var = var->next)
11515 add_header(&req, var->name, ast_unescape_semicolon(var->value));
11516
11517
11518 if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
11519 p->ourip = __ourip;
11520 build_via(p);
11521 build_callid_pvt(p);
11522 ast_cli(fd, "Sending NOTIFY of type '%s' to '%s'\n", argv[2], argv[i]);
11523 transmit_sip_request(p, &req);
11524 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
11525 }
11526
11527 return RESULT_SUCCESS;
11528 }
11529
11530
11531 static int sip_no_debug(int fd, int argc, char *argv[])
11532 {
11533 if (argc != 4)
11534 return RESULT_SHOWUSAGE;
11535 ast_clear_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
11536 ast_cli(fd, "SIP Debugging Disabled\n");
11537 return RESULT_SUCCESS;
11538 }
11539
11540 static int sip_no_debug_deprecated(int fd, int argc, char *argv[])
11541 {
11542 if (argc != 3)
11543 return RESULT_SHOWUSAGE;
11544 ast_clear_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
11545 ast_cli(fd, "SIP Debugging Disabled\n");
11546 return RESULT_SUCCESS;
11547 }
11548
11549
11550 static int sip_do_history(int fd, int argc, char *argv[])
11551 {
11552 if (argc != 2) {
11553 return RESULT_SHOWUSAGE;
11554 }
11555 recordhistory = TRUE;
11556 ast_cli(fd, "SIP History Recording Enabled (use 'sip show history')\n");
11557 return RESULT_SUCCESS;
11558 }
11559
11560
11561 static int sip_no_history(int fd, int argc, char *argv[])
11562 {
11563 if (argc != 3) {
11564 return RESULT_SHOWUSAGE;
11565 }
11566 recordhistory = FALSE;
11567 ast_cli(fd, "SIP History Recording Disabled\n");
11568 return RESULT_SUCCESS;
11569 }
11570
11571
11572 static int do_register_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader)
11573 {
11574 char digest[1024];
11575 p->authtries++;
11576 memset(digest,0,sizeof(digest));
11577 if (reply_digest(p, req, header, SIP_REGISTER, digest, sizeof(digest))) {
11578
11579
11580 if (sip_debug_test_pvt(p) && p->registry)
11581 ast_verbose("No authentication challenge, sending blank registration to domain/host name %s\n", p->registry->hostname);
11582
11583 return -1;
11584 }
11585 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
11586 append_history(p, "RegistryAuth", "Try: %d", p->authtries);
11587 if (sip_debug_test_pvt(p) && p->registry)
11588 ast_verbose("Responding to challenge, registration to domain/host name %s\n", p->registry->hostname);
11589 return transmit_register(p->registry, SIP_REGISTER, digest, respheader);
11590 }
11591
11592
11593 static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, char *header, char *respheader, int sipmethod, int init)
11594 {
11595 char digest[1024];
11596
11597 if (!p->options && !(p->options = ast_calloc(1, sizeof(*p->options))))
11598 return -2;
11599
11600 p->authtries++;
11601 if (option_debug > 1)
11602 ast_log(LOG_DEBUG, "Auth attempt %d on %s\n", p->authtries, sip_methods[sipmethod].text);
11603 memset(digest, 0, sizeof(digest));
11604 if (reply_digest(p, req, header, sipmethod, digest, sizeof(digest) )) {
11605
11606 return -1;
11607 }
11608
11609 p->options->auth = digest;
11610 p->options->authheader = respheader;
11611 return transmit_invite(p, sipmethod, sipmethod == SIP_INVITE, init);
11612 }
11613
11614
11615
11616
11617
11618 static int reply_digest(struct sip_pvt *p, struct sip_request *req, char *header, int sipmethod, char *digest, int digest_len)
11619 {
11620 char tmp[512];
11621 char *c;
11622 char oldnonce[256];
11623
11624
11625 const struct x {
11626 const char *key;
11627 int field_index;
11628 } *i, keys[] = {
11629 { "realm=", ast_string_field_index(p, realm) },
11630 { "nonce=", ast_string_field_index(p, nonce) },
11631 { "opaque=", ast_string_field_index(p, opaque) },
11632 { "qop=", ast_string_field_index(p, qop) },
11633 { "domain=", ast_string_field_index(p, domain) },
11634 { NULL, 0 },
11635 };
11636
11637 ast_copy_string(tmp, get_header(req, header), sizeof(tmp));
11638 if (ast_strlen_zero(tmp))
11639 return -1;
11640 if (strncasecmp(tmp, "Digest ", strlen("Digest "))) {
11641 ast_log(LOG_WARNING, "missing Digest.\n");
11642 return -1;
11643 }
11644 c = tmp + strlen("Digest ");
11645 ast_copy_string(oldnonce, p->nonce, sizeof(oldnonce));
11646 while (c && *(c = ast_skip_blanks(c))) {
11647 for (i = keys; i->key != NULL; i++) {
11648 char *src, *separator;
11649 if (strncasecmp(c, i->key, strlen(i->key)) != 0)
11650 continue;
11651
11652 c += strlen(i->key);
11653 if (*c == '"') {
11654 src = ++c;
11655 separator = "\"";
11656 } else {
11657 src = c;
11658 separator = ",";
11659 }
11660 strsep(&c, separator);
11661 ast_string_field_index_set(p, i->field_index, src);
11662 break;
11663 }
11664 if (i->key == NULL)
11665 strsep(&c, ",");
11666 }
11667
11668 if (strcmp(p->nonce, oldnonce))
11669 p->noncecount = 0;
11670
11671
11672 if (p->registry) {
11673 struct sip_registry *r = p->registry;
11674
11675 if (strcmp(r->nonce, p->nonce)) {
11676 ast_string_field_set(r, realm, p->realm);
11677 ast_string_field_set(r, nonce, p->nonce);
11678 ast_string_field_set(r, domain, p->domain);
11679 ast_string_field_set(r, opaque, p->opaque);
11680 ast_string_field_set(r, qop, p->qop);
11681 r->noncecount = 0;
11682 }
11683 }
11684 return build_reply_digest(p, sipmethod, digest, digest_len);
11685 }
11686
11687
11688
11689
11690
11691
11692 static int build_reply_digest(struct sip_pvt *p, int method, char* digest, int digest_len)
11693 {
11694 char a1[256];
11695 char a2[256];
11696 char a1_hash[256];
11697 char a2_hash[256];
11698 char resp[256];
11699 char resp_hash[256];
11700 char uri[256];
11701 char opaque[256] = "";
11702 char cnonce[80];
11703 const char *username;
11704 const char *secret;
11705 const char *md5secret;
11706 struct sip_auth *auth = NULL;
11707
11708 if (!ast_strlen_zero(p->domain))
11709 ast_copy_string(uri, p->domain, sizeof(uri));
11710 else if (!ast_strlen_zero(p->uri))
11711 ast_copy_string(uri, p->uri, sizeof(uri));
11712 else
11713 snprintf(uri, sizeof(uri), "sip:%s@%s",p->username, ast_inet_ntoa(p->sa.sin_addr));
11714
11715 snprintf(cnonce, sizeof(cnonce), "%08lx", ast_random());
11716
11717
11718 if ((auth = find_realm_authentication(authl, p->realm))) {
11719 ast_log(LOG_WARNING, "use realm [%s] from peer [%s][%s]\n",
11720 auth->username, p->peername, p->username);
11721 username = auth->username;
11722 secret = auth->secret;
11723 md5secret = auth->md5secret;
11724 if (sipdebug)
11725 ast_log(LOG_DEBUG,"Using realm %s authentication for call %s\n", p->realm, p->callid);
11726 } else {
11727
11728 username = p->authname;
11729 secret = p->peersecret;
11730 md5secret = p->peermd5secret;
11731 }
11732 if (ast_strlen_zero(username))
11733 return -1;
11734
11735
11736 snprintf(a1,sizeof(a1),"%s:%s:%s", username, p->realm, secret);
11737 snprintf(a2,sizeof(a2),"%s:%s", sip_methods[method].text, uri);
11738 if (!ast_strlen_zero(md5secret))
11739 ast_copy_string(a1_hash, md5secret, sizeof(a1_hash));
11740 else
11741 ast_md5_hash(a1_hash,a1);
11742 ast_md5_hash(a2_hash,a2);
11743
11744 p->noncecount++;
11745 if (!ast_strlen_zero(p->qop))
11746 snprintf(resp,sizeof(resp),"%s:%s:%08x:%s:%s:%s", a1_hash, p->nonce, p->noncecount, cnonce, "auth", a2_hash);
11747 else
11748 snprintf(resp,sizeof(resp),"%s:%s:%s", a1_hash, p->nonce, a2_hash);
11749 ast_md5_hash(resp_hash, resp);
11750
11751
11752 if (!ast_strlen_zero(p->opaque)) {
11753 snprintf(opaque, sizeof(opaque), ", opaque=\"%s\"", p->opaque);
11754 }
11755
11756
11757 if (!ast_strlen_zero(p->qop))
11758 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);
11759 else
11760 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);
11761
11762 append_history(p, "AuthResp", "Auth response sent for %s in realm %s - nc %d", username, p->realm, p->noncecount);
11763
11764 return 0;
11765 }
11766
11767 static char show_domains_usage[] =
11768 "Usage: sip show domains\n"
11769 " Lists all configured SIP local domains.\n"
11770 " Asterisk only responds to SIP messages to local domains.\n";
11771
11772 static char notify_usage[] =
11773 "Usage: sip notify <type> <peer> [<peer>...]\n"
11774 " Send a NOTIFY message to a SIP peer or peers\n"
11775 " Message types are defined in sip_notify.conf\n";
11776
11777 static char show_users_usage[] =
11778 "Usage: sip show users [like <pattern>]\n"
11779 " Lists all known SIP users.\n"
11780 " Optional regular expression pattern is used to filter the user list.\n";
11781
11782 static char show_user_usage[] =
11783 "Usage: sip show user <name> [load]\n"
11784 " Shows all details on one SIP user and the current status.\n"
11785 " Option \"load\" forces lookup of peer in realtime storage.\n";
11786
11787 static char show_inuse_usage[] =
11788 "Usage: sip show inuse [all]\n"
11789 " List all SIP users and peers usage counters and limits.\n"
11790 " Add option \"all\" to show all devices, not only those with a limit.\n";
11791
11792 static char show_channels_usage[] =
11793 "Usage: sip show channels\n"
11794 " Lists all currently active SIP channels.\n";
11795
11796 static char show_channel_usage[] =
11797 "Usage: sip show channel <channel>\n"
11798 " Provides detailed status on a given SIP channel.\n";
11799
11800 static char show_history_usage[] =
11801 "Usage: sip show history <channel>\n"
11802 " Provides detailed dialog history on a given SIP channel.\n";
11803
11804 static char show_peers_usage[] =
11805 "Usage: sip show peers [like <pattern>]\n"
11806 " Lists all known SIP peers.\n"
11807 " Optional regular expression pattern is used to filter the peer list.\n";
11808
11809 static char show_peer_usage[] =
11810 "Usage: sip show peer <name> [load]\n"
11811 " Shows all details on one SIP peer and the current status.\n"
11812 " Option \"load\" forces lookup of peer in realtime storage.\n";
11813
11814 static char prune_realtime_usage[] =
11815 "Usage: sip prune realtime [peer|user] [<name>|all|like <pattern>]\n"
11816 " Prunes object(s) from the cache.\n"
11817 " Optional regular expression pattern is used to filter the objects.\n";
11818
11819 static char show_reg_usage[] =
11820 "Usage: sip show registry\n"
11821 " Lists all registration requests and status.\n";
11822
11823 static char debug_usage[] =
11824 "Usage: sip set debug\n"
11825 " Enables dumping of SIP packets for debugging purposes\n\n"
11826 " sip set debug ip <host[:PORT]>\n"
11827 " Enables dumping of SIP packets to and from host.\n\n"
11828 " sip set debug peer <peername>\n"
11829 " Enables dumping of SIP packets to and from host.\n"
11830 " Require peer to be registered.\n";
11831
11832 static char no_debug_usage[] =
11833 "Usage: sip set debug off\n"
11834 " Disables dumping of SIP packets for debugging purposes\n";
11835
11836 static char no_history_usage[] =
11837 "Usage: sip history off\n"
11838 " Disables recording of SIP dialog history for debugging purposes\n";
11839
11840 static char history_usage[] =
11841 "Usage: sip history\n"
11842 " Enables recording of SIP dialog history for debugging purposes.\n"
11843 "Use 'sip show history' to view the history of a call number.\n";
11844
11845 static char sip_reload_usage[] =
11846 "Usage: sip reload\n"
11847 " Reloads SIP configuration from sip.conf\n";
11848
11849 static char show_subscriptions_usage[] =
11850 "Usage: sip show subscriptions\n"
11851 " Lists active SIP subscriptions for extension states\n";
11852
11853 static char show_objects_usage[] =
11854 "Usage: sip show objects\n"
11855 " Lists status of known SIP objects\n";
11856
11857 static char show_settings_usage[] =
11858 "Usage: sip show settings\n"
11859 " Provides detailed list of the configuration of the SIP channel.\n";
11860
11861
11862 static int func_header_read(struct ast_channel *chan, char *function, char *data, char *buf, size_t len)
11863 {
11864 struct sip_pvt *p;
11865 const char *content = NULL;
11866 AST_DECLARE_APP_ARGS(args,
11867 AST_APP_ARG(header);
11868 AST_APP_ARG(number);
11869 );
11870 int i, number, start = 0;
11871
11872 if (ast_strlen_zero(data)) {
11873 ast_log(LOG_WARNING, "This function requires a header name.\n");
11874 return -1;
11875 }
11876
11877 ast_channel_lock(chan);
11878 if (chan->tech != &sip_tech && chan->tech != &sip_tech_info) {
11879 ast_log(LOG_WARNING, "This function can only be used on SIP channels.\n");
11880 ast_channel_unlock(chan);
11881 return -1;
11882 }
11883
11884 AST_STANDARD_APP_ARGS(args, data);
11885 if (!args.number) {
11886 number = 1;
11887 } else {
11888 sscanf(args.number, "%d", &number);
11889 if (number < 1)
11890 number = 1;
11891 }
11892
11893 p = chan->tech_pvt;
11894
11895
11896 if (!p) {
11897 ast_channel_unlock(chan);
11898 return -1;
11899 }
11900
11901 for (i = 0; i < number; i++)
11902 content = __get_header(&p->initreq, args.header, &start);
11903
11904 if (ast_strlen_zero(content)) {
11905 ast_channel_unlock(chan);
11906 return -1;
11907 }
11908
11909 ast_copy_string(buf, content, len);
11910 ast_channel_unlock(chan);
11911
11912 return 0;
11913 }
11914
11915 static struct ast_custom_function sip_header_function = {
11916 .name = "SIP_HEADER",
11917 .synopsis = "Gets the specified SIP header",
11918 .syntax = "SIP_HEADER(<name>[,<number>])",
11919 .desc = "Since there are several headers (such as Via) which can occur multiple\n"
11920 "times, SIP_HEADER takes an optional second argument to specify which header with\n"
11921 "that name to retrieve. Headers start at offset 1.\n",
11922 .read = func_header_read,
11923 };
11924
11925
11926 static int func_check_sipdomain(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
11927 {
11928 if (ast_strlen_zero(data)) {
11929 ast_log(LOG_WARNING, "CHECKSIPDOMAIN requires an argument - A domain name\n");
11930 return -1;
11931 }
11932 if (check_sip_domain(data, NULL, 0))
11933 ast_copy_string(buf, data, len);
11934 else
11935 buf[0] = '\0';
11936 return 0;
11937 }
11938
11939 static struct ast_custom_function checksipdomain_function = {
11940 .name = "CHECKSIPDOMAIN",
11941 .synopsis = "Checks if domain is a local domain",
11942 .syntax = "CHECKSIPDOMAIN(<domain|IP>)",
11943 .read = func_check_sipdomain,
11944 .desc = "This function checks if the domain in the argument is configured\n"
11945 "as a local SIP domain that this Asterisk server is configured to handle.\n"
11946 "Returns the domain name if it is locally handled, otherwise an empty string.\n"
11947 "Check the domain= configuration in sip.conf\n",
11948 };
11949
11950
11951 static int function_sippeer(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
11952 {
11953 struct sip_peer *peer;
11954 char *colname;
11955
11956 if ((colname = strchr(data, ':')))
11957 *colname++ = '\0';
11958 else if ((colname = strchr(data, '|')))
11959 *colname++ = '\0';
11960 else
11961 colname = "ip";
11962
11963 if (!(peer = find_peer(data, NULL, 1)))
11964 return -1;
11965
11966 if (!strcasecmp(colname, "ip")) {
11967 ast_copy_string(buf, peer->addr.sin_addr.s_addr ? ast_inet_ntoa(peer->addr.sin_addr) : "", len);
11968 } else if (!strcasecmp(colname, "status")) {
11969 peer_status(peer, buf, len);
11970 } else if (!strcasecmp(colname, "language")) {
11971 ast_copy_string(buf, peer->language, len);
11972 } else if (!strcasecmp(colname, "regexten")) {
11973 ast_copy_string(buf, peer->regexten, len);
11974 } else if (!strcasecmp(colname, "limit")) {
11975 snprintf(buf, len, "%d", peer->call_limit);
11976 } else if (!strcasecmp(colname, "curcalls")) {
11977 snprintf(buf, len, "%d", peer->inUse);
11978 } else if (!strcasecmp(colname, "accountcode")) {
11979 ast_copy_string(buf, peer->accountcode, len);
11980 } else if (!strcasecmp(colname, "useragent")) {
11981 ast_copy_string(buf, peer->useragent, len);
11982 } else if (!strcasecmp(colname, "mailbox")) {
11983 ast_copy_string(buf, peer->mailbox, len);
11984 } else if (!strcasecmp(colname, "context")) {
11985 ast_copy_string(buf, peer->context, len);
11986 } else if (!strcasecmp(colname, "expire")) {
11987 snprintf(buf, len, "%d", peer->expire);
11988 } else if (!strcasecmp(colname, "dynamic")) {
11989 ast_copy_string(buf, (ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC) ? "yes" : "no"), len);
11990 } else if (!strcasecmp(colname, "callerid_name")) {
11991 ast_copy_string(buf, peer->cid_name, len);
11992 } else if (!strcasecmp(colname, "callerid_num")) {
11993 ast_copy_string(buf, peer->cid_num, len);
11994 } else if (!strcasecmp(colname, "codecs")) {
11995 ast_getformatname_multiple(buf, len -1, peer->capability);
11996 } else if (!strncasecmp(colname, "codec[", 6)) {
11997 char *codecnum;
11998 int index = 0, codec = 0;
11999
12000 codecnum = colname + 6;
12001 codecnum = strsep(&codecnum, "]");
12002 index = atoi(codecnum);
12003 if((codec = ast_codec_pref_index(&peer->prefs, index))) {
12004 ast_copy_string(buf, ast_getformatname(codec), len);
12005 }
12006 }
12007
12008 ASTOBJ_UNREF(peer, sip_destroy_peer);
12009
12010 return 0;
12011 }
12012
12013
12014 struct ast_custom_function sippeer_function = {
12015 .name = "SIPPEER",
12016 .synopsis = "Gets SIP peer information",
12017 .syntax = "SIPPEER(<peername>[|item])",
12018 .read = function_sippeer,
12019 .desc = "Valid items are:\n"
12020 "- ip (default) The IP address.\n"
12021 "- mailbox The configured mailbox.\n"
12022 "- context The configured context.\n"
12023 "- expire The epoch time of the next expire.\n"
12024 "- dynamic Is it dynamic? (yes/no).\n"
12025 "- callerid_name The configured Caller ID name.\n"
12026 "- callerid_num The configured Caller ID number.\n"
12027 "- codecs The configured codecs.\n"
12028 "- status Status (if qualify=yes).\n"
12029 "- regexten Registration extension\n"
12030 "- limit Call limit (call-limit)\n"
12031 "- curcalls Current amount of calls \n"
12032 " Only available if call-limit is set\n"
12033 "- language Default language for peer\n"
12034 "- accountcode Account code for this peer\n"
12035 "- useragent Current user agent id for peer\n"
12036 "- codec[x] Preferred codec index number 'x' (beginning with zero).\n"
12037 "\n"
12038 };
12039
12040
12041 static int function_sipchaninfo_read(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
12042 {
12043 struct sip_pvt *p;
12044
12045 *buf = 0;
12046
12047 if (!data) {
12048 ast_log(LOG_WARNING, "This function requires a parameter name.\n");
12049 return -1;
12050 }
12051
12052 ast_channel_lock(chan);
12053 if (chan->tech != &sip_tech && chan->tech != &sip_tech_info) {
12054 ast_log(LOG_WARNING, "This function can only be used on SIP channels.\n");
12055 ast_channel_unlock(chan);
12056 return -1;
12057 }
12058
12059 p = chan->tech_pvt;
12060
12061
12062 if (!p) {
12063 ast_channel_unlock(chan);
12064 return -1;
12065 }
12066
12067 if (!strcasecmp(data, "peerip")) {
12068 ast_copy_string(buf, p->sa.sin_addr.s_addr ? ast_inet_ntoa(p->sa.sin_addr) : "", len);
12069 } else if (!strcasecmp(data, "recvip")) {
12070 ast_copy_string(buf, p->recv.sin_addr.s_addr ? ast_inet_ntoa(p->recv.sin_addr) : "", len);
12071 } else if (!strcasecmp(data, "from")) {
12072 ast_copy_string(buf, p->from, len);
12073 } else if (!strcasecmp(data, "uri")) {
12074 ast_copy_string(buf, p->uri, len);
12075 } else if (!strcasecmp(data, "useragent")) {
12076 ast_copy_string(buf, p->useragent, len);
12077 } else if (!strcasecmp(data, "peername")) {
12078 ast_copy_string(buf, p->peername, len);
12079 } else if (!strcasecmp(data, "t38passthrough")) {
12080 if (p->t38.state == T38_DISABLED)
12081 ast_copy_string(buf, "0", sizeof("0"));
12082 else
12083 ast_copy_string(buf, "1", sizeof("1"));
12084 } else {
12085 ast_channel_unlock(chan);
12086 return -1;
12087 }
12088 ast_channel_unlock(chan);
12089
12090 return 0;
12091 }
12092
12093
12094 static struct ast_custom_function sipchaninfo_function = {
12095 .name = "SIPCHANINFO",
12096 .synopsis = "Gets the specified SIP parameter from the current channel",
12097 .syntax = "SIPCHANINFO(item)",
12098 .read = function_sipchaninfo_read,
12099 .desc = "Valid items are:\n"
12100 "- peerip The IP address of the peer.\n"
12101 "- recvip The source IP address of the peer.\n"
12102 "- from The URI from the From: header.\n"
12103 "- uri The URI from the Contact: header.\n"
12104 "- useragent The useragent.\n"
12105 "- peername The name of the peer.\n"
12106 "- t38passthrough 1 if T38 is offered or enabled in this channel, otherwise 0\n"
12107 };
12108
12109
12110 static void parse_moved_contact(struct sip_pvt *p, struct sip_request *req)
12111 {
12112 char tmp[SIPBUFSIZE];
12113 char *s, *e, *uri, *t;
12114 char *domain;
12115
12116 ast_copy_string(tmp, get_header(req, "Contact"), sizeof(tmp));
12117 if ((t = strchr(tmp, ',')))
12118 *t = '\0';
12119 s = get_in_brackets(tmp);
12120 uri = ast_strdupa(s);
12121 if (ast_test_flag(&p->flags[0], SIP_PROMISCREDIR)) {
12122 if (!strncasecmp(s, "sip:", 4))
12123 s += 4;
12124 e = strchr(s, ';');
12125 if (e)
12126 *e = '\0';
12127 if (option_debug)
12128 ast_log(LOG_DEBUG, "Found promiscuous redirection to 'SIP/%s'\n", s);
12129 if (p->owner)
12130 ast_string_field_build(p->owner, call_forward, "SIP/%s", s);
12131 } else {
12132 e = strchr(tmp, '@');
12133 if (e) {
12134 *e++ = '\0';
12135 domain = e;
12136 } else {
12137
12138 domain = tmp;
12139 }
12140 e = strchr(s, ';');
12141 if (e)
12142 *e = '\0';
12143 e = strchr(domain, ';');
12144 if (e)
12145 *e = '\0';
12146
12147 if (!strncasecmp(s, "sip:", 4))
12148 s += 4;
12149 if (option_debug > 1)
12150 ast_log(LOG_DEBUG, "Received 302 Redirect to extension '%s' (domain %s)\n", s, domain);
12151 if (p->owner) {
12152 pbx_builtin_setvar_helper(p->owner, "SIPREDIRECTURI", uri);
12153 pbx_builtin_setvar_helper(p->owner, "SIPDOMAIN", domain);
12154 ast_string_field_set(p->owner, call_forward, s);
12155 }
12156 }
12157 }
12158
12159
12160 static void check_pendings(struct sip_pvt *p)
12161 {
12162 if (ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
12163
12164 if (p->invitestate == INV_PROCEEDING || p->invitestate == INV_EARLY_MEDIA)
12165 transmit_request(p, SIP_CANCEL, p->lastinvite, XMIT_RELIABLE, FALSE);
12166
12167
12168 else {
12169
12170
12171 if (p->pendinginvite)
12172 return;
12173
12174
12175 transmit_request_with_auth(p, SIP_BYE, 0, XMIT_RELIABLE, TRUE);
12176 }
12177 ast_clear_flag(&p->flags[0], SIP_PENDINGBYE);
12178 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
12179 } else if (ast_test_flag(&p->flags[0], SIP_NEEDREINVITE)) {
12180
12181 if (p->pendinginvite || p->invitestate == INV_CALLING || p->invitestate == INV_PROCEEDING || p->invitestate == INV_EARLY_MEDIA || p->waitid > 0) {
12182 if (option_debug)
12183 ast_log(LOG_DEBUG, "NOT Sending pending reinvite (yet) on '%s'\n", p->callid);
12184 } else {
12185 if (option_debug)
12186 ast_log(LOG_DEBUG, "Sending pending reinvite on '%s'\n", p->callid);
12187
12188 transmit_reinvite_with_sdp(p);
12189 ast_clear_flag(&p->flags[0], SIP_NEEDREINVITE);
12190 }
12191 }
12192 }
12193
12194
12195
12196
12197
12198 static int sip_reinvite_retry(const void *data)
12199 {
12200 struct sip_pvt *p = (struct sip_pvt *) data;
12201
12202 ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
12203 p->waitid = -1;
12204 return 0;
12205 }
12206
12207
12208
12209 static void handle_response_invite(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int seqno)
12210 {
12211 int outgoing = ast_test_flag(&p->flags[0], SIP_OUTGOING);
12212 int res = 0;
12213 int xmitres = 0;
12214 int reinvite = (p->owner && p->owner->_state == AST_STATE_UP);
12215 struct ast_channel *bridgepeer = NULL;
12216
12217 if (option_debug > 3) {
12218 if (reinvite)
12219 ast_log(LOG_DEBUG, "SIP response %d to RE-invite on %s call %s\n", resp, outgoing ? "outgoing" : "incoming", p->callid);
12220 else
12221 ast_log(LOG_DEBUG, "SIP response %d to standard invite\n", resp);
12222 }
12223
12224 if (ast_test_flag(&p->flags[0], SIP_ALREADYGONE)) {
12225 if (option_debug)
12226 ast_log(LOG_DEBUG, "Got response on call that is already terminated: %s (ignoring)\n", p->callid);
12227 return;
12228 }
12229
12230
12231
12232 AST_SCHED_DEL(sched, p->initid);
12233
12234
12235
12236
12237 if (resp > 100 && resp < 200 && resp!=101 && resp != 180 && resp != 182 && resp != 183)
12238 resp = 183;
12239
12240
12241 if (resp >= 100 && resp < 200 && p->invitestate == INV_CALLING)
12242 p->invitestate = INV_PROCEEDING;
12243
12244
12245 if (resp >= 300 && (p->invitestate == INV_CALLING || p->invitestate == INV_PROCEEDING || p->invitestate == INV_EARLY_MEDIA ))
12246 p->invitestate = INV_COMPLETED;
12247
12248
12249 switch (resp) {
12250 case 100:
12251 case 101:
12252 if (!ast_test_flag(req, SIP_PKT_IGNORE) && (p->invitestate != INV_CANCELLED) && sip_cancel_destroy(p))
12253 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
12254 check_pendings(p);
12255 break;
12256
12257 case 180:
12258 case 182:
12259 if (!ast_test_flag(req, SIP_PKT_IGNORE) && (p->invitestate != INV_CANCELLED) && sip_cancel_destroy(p))
12260 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
12261 if (!ast_test_flag(req, SIP_PKT_IGNORE) && p->owner) {
12262 ast_queue_control(p->owner, AST_CONTROL_RINGING);
12263 if (p->owner->_state != AST_STATE_UP) {
12264 ast_setstate(p->owner, AST_STATE_RINGING);
12265 }
12266 }
12267 if (find_sdp(req)) {
12268 if (p->invitestate != INV_CANCELLED)
12269 p->invitestate = INV_EARLY_MEDIA;
12270 res = process_sdp(p, req);
12271 if (!ast_test_flag(req, SIP_PKT_IGNORE) && p->owner) {
12272
12273 ast_queue_control(p->owner, AST_CONTROL_PROGRESS);
12274 }
12275 }
12276 check_pendings(p);
12277 break;
12278
12279 case 183:
12280 if (!ast_test_flag(req, SIP_PKT_IGNORE) && (p->invitestate != INV_CANCELLED) && sip_cancel_destroy(p))
12281 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
12282
12283 if (find_sdp(req)) {
12284 if (p->invitestate != INV_CANCELLED)
12285 p->invitestate = INV_EARLY_MEDIA;
12286 res = process_sdp(p, req);
12287 if (!ast_test_flag(req, SIP_PKT_IGNORE) && p->owner) {
12288
12289 ast_queue_control(p->owner, AST_CONTROL_PROGRESS);
12290 }
12291 }
12292 check_pendings(p);
12293 break;
12294
12295 case 200:
12296 if (!ast_test_flag(req, SIP_PKT_IGNORE) && (p->invitestate != INV_CANCELLED) && sip_cancel_destroy(p))
12297 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
12298 p->authtries = 0;
12299 if (find_sdp(req)) {
12300 if ((res = process_sdp(p, req)) && !ast_test_flag(req, SIP_PKT_IGNORE))
12301 if (!reinvite)
12302
12303
12304 ast_set_flag(&p->flags[0], SIP_PENDINGBYE);
12305 }
12306
12307
12308
12309
12310 if (outgoing) {
12311 update_call_counter(p, DEC_CALL_RINGING);
12312 parse_ok_contact(p, req);
12313 if(set_address_from_contact(p)) {
12314
12315
12316
12317
12318
12319
12320
12321 if (!ast_test_flag(req, SIP_PKT_IGNORE))
12322 ast_set_flag(&p->flags[0], SIP_PENDINGBYE);
12323 }
12324
12325
12326 if (!reinvite)
12327 build_route(p, req, 1);
12328 }
12329
12330 if (p->owner && (p->owner->_state == AST_STATE_UP) && (bridgepeer = ast_bridged_channel(p->owner))) {
12331 struct sip_pvt *bridgepvt = NULL;
12332
12333 if (!bridgepeer->tech) {
12334 ast_log(LOG_WARNING, "Ooooh.. no tech! That's REALLY bad\n");
12335 break;
12336 }
12337 if (bridgepeer->tech == &sip_tech || bridgepeer->tech == &sip_tech_info) {
12338 bridgepvt = (struct sip_pvt*)(bridgepeer->tech_pvt);
12339 if (bridgepvt->udptl) {
12340 if (p->t38.state == T38_PEER_REINVITE) {
12341 sip_handle_t38_reinvite(bridgepeer, p, 0);
12342 ast_rtp_set_rtptimers_onhold(p->rtp);
12343 if (p->vrtp)
12344 ast_rtp_set_rtptimers_onhold(p->vrtp);
12345 } else if (p->t38.state == T38_DISABLED && bridgepeer && (bridgepvt->t38.state == T38_ENABLED)) {
12346 ast_log(LOG_WARNING, "RTP re-invite after T38 session not handled yet !\n");
12347
12348
12349 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
12350 }
12351 } else {
12352 if (option_debug > 1)
12353 ast_log(LOG_DEBUG, "Strange... The other side of the bridge does not have a udptl struct\n");
12354 ast_mutex_lock(&bridgepvt->lock);
12355 bridgepvt->t38.state = T38_DISABLED;
12356 ast_mutex_unlock(&bridgepvt->lock);
12357 if (option_debug)
12358 ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", bridgepvt->t38.state, bridgepeer->tech->type);
12359 p->t38.state = T38_DISABLED;
12360 if (option_debug > 1)
12361 ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
12362 }
12363 } else {
12364
12365 if (option_debug > 1)
12366 ast_log(LOG_DEBUG, "Strange... The other side of the bridge is not a SIP channel\n");
12367 p->t38.state = T38_DISABLED;
12368 if (option_debug > 1)
12369 ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
12370 }
12371 }
12372 if ((p->t38.state == T38_LOCAL_REINVITE) || (p->t38.state == T38_LOCAL_DIRECT)) {
12373
12374 p->t38.state = T38_ENABLED;
12375 if (option_debug)
12376 ast_log(LOG_DEBUG, "T38 changed state to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
12377 }
12378
12379 if (!ast_test_flag(req, SIP_PKT_IGNORE) && p->owner) {
12380 if (!reinvite) {
12381 ast_queue_control(p->owner, AST_CONTROL_ANSWER);
12382 } else {
12383 ast_queue_frame(p->owner, &ast_null_frame);
12384 }
12385 } else {
12386
12387
12388
12389 if (!ast_test_flag(req, SIP_PKT_IGNORE))
12390 ast_set_flag(&p->flags[0], SIP_PENDINGBYE);
12391 }
12392
12393 p->invitestate = INV_TERMINATED;
12394 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, TRUE);
12395 check_pendings(p);
12396 break;
12397 case 407:
12398 case 401:
12399
12400 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
12401 if (p->options)
12402 p->options->auth_type = (resp == 401 ? WWW_AUTH : PROXY_AUTH);
12403
12404
12405 ast_string_field_free(p, theirtag);
12406 if (!ast_test_flag(req, SIP_PKT_IGNORE)) {
12407 char *authenticate = (resp == 401 ? "WWW-Authenticate" : "Proxy-Authenticate");
12408 char *authorization = (resp == 401 ? "Authorization" : "Proxy-Authorization");
12409 if (p->authtries < MAX_AUTHTRIES)
12410 p->invitestate = INV_CALLING;
12411 if ((p->authtries == MAX_AUTHTRIES) || do_proxy_auth(p, req, authenticate, authorization, SIP_INVITE, 1)) {
12412 ast_log(LOG_NOTICE, "Failed to authenticate on INVITE to '%s'\n", get_header(&p->initreq, "From"));
12413 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12414 sip_alreadygone(p);
12415 if (p->owner)
12416 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12417 }
12418 }
12419 break;
12420
12421 case 403:
12422
12423 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
12424 ast_log(LOG_WARNING, "Received response: \"Forbidden\" from '%s'\n", get_header(&p->initreq, "From"));
12425 if (!ast_test_flag(req, SIP_PKT_IGNORE) && p->owner)
12426 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12427 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12428 sip_alreadygone(p);
12429 break;
12430
12431 case 404:
12432 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
12433 if (p->owner && !ast_test_flag(req, SIP_PKT_IGNORE))
12434 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12435 sip_alreadygone(p);
12436 break;
12437
12438 case 408:
12439 case 481:
12440
12441 ast_log(LOG_WARNING, "Re-invite to non-existing call leg on other UA. SIP dialog '%s'. Giving up.\n", p->callid);
12442 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
12443 if (p->owner)
12444 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12445 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
12446 break;
12447 case 487:
12448
12449
12450
12451 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
12452 if (p->owner && !ast_test_flag(req, SIP_PKT_IGNORE)) {
12453 ast_queue_hangup(p->owner);
12454 append_history(p, "Hangup", "Got 487 on CANCEL request from us. Queued AST hangup request");
12455 } else if (!ast_test_flag(req, SIP_PKT_IGNORE)) {
12456 update_call_counter(p, DEC_CALL_LIMIT);
12457 append_history(p, "Hangup", "Got 487 on CANCEL request from us on call without owner. Killing this dialog.");
12458 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12459 sip_alreadygone(p);
12460 }
12461 break;
12462 case 488:
12463 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
12464 if (reinvite && p->udptl) {
12465
12466
12467
12468
12469
12470 p->t38.state = T38_DISABLED;
12471
12472 ast_rtp_set_rtptimers_onhold(p->rtp);
12473 ast_log(LOG_ERROR, "Got error on T.38 re-invite. Bad configuration. Peer needs to have T.38 disabled.\n");
12474
12475
12476
12477
12478
12479 if (p->owner && !ast_test_flag(req, SIP_PKT_IGNORE))
12480 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12481 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12482 } else if (p->udptl && p->t38.state == T38_LOCAL_DIRECT) {
12483
12484
12485
12486 p->t38.state = T38_DISABLED;
12487
12488 ast_rtp_set_rtptimers_onhold(p->rtp);
12489 ast_log(LOG_ERROR, "Got error on T.38 initial invite. Bailing out.\n");
12490
12491
12492 if (p->owner && !ast_test_flag(req, SIP_PKT_IGNORE))
12493 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12494 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12495 sip_alreadygone(p);
12496 } else {
12497
12498 if (p->owner && !ast_test_flag(req, SIP_PKT_IGNORE))
12499 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12500 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12501
12502 if (!reinvite)
12503 sip_alreadygone(p);
12504 }
12505 break;
12506 case 491:
12507
12508
12509
12510
12511 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
12512 if (p->owner && !ast_test_flag(req, SIP_PKT_IGNORE)) {
12513 if (p->owner->_state != AST_STATE_UP) {
12514 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12515 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12516 } else {
12517
12518
12519
12520 int wait = 3 + ast_random() % 5;
12521 p->waitid = ast_sched_add(sched, wait, sip_reinvite_retry, p);
12522 if (option_debug > 2)
12523 ast_log(LOG_DEBUG, "Reinvite race. Waiting %d secs before retry\n", wait);
12524 }
12525 }
12526 break;
12527
12528 case 501:
12529 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
12530 if (p->owner)
12531 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12532 break;
12533 }
12534 if (xmitres == XMIT_ERROR)
12535 ast_log(LOG_WARNING, "Could not transmit message in dialog %s\n", p->callid);
12536 }
12537
12538
12539
12540
12541 static void handle_response_refer(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int seqno)
12542 {
12543 char *auth = "Proxy-Authenticate";
12544 char *auth2 = "Proxy-Authorization";
12545
12546
12547 if (!p->refer)
12548 return;
12549
12550 switch (resp) {
12551 case 202:
12552
12553
12554 p->refer->status = REFER_ACCEPTED;
12555
12556 if (option_debug > 2)
12557 ast_log(LOG_DEBUG, "Got 202 accepted on transfer\n");
12558
12559 break;
12560
12561 case 401:
12562 case 407:
12563 if (ast_strlen_zero(p->authname)) {
12564 ast_log(LOG_WARNING, "Asked to authenticate REFER to %s:%d but we have no matching peer or realm auth!\n",
12565 ast_inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));
12566 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12567 }
12568 if (resp == 401) {
12569 auth = "WWW-Authenticate";
12570 auth2 = "Authorization";
12571 }
12572 if ((p->authtries > 1) || do_proxy_auth(p, req, auth, auth2, SIP_REFER, 0)) {
12573 ast_log(LOG_NOTICE, "Failed to authenticate on REFER to '%s'\n", get_header(&p->initreq, "From"));
12574 p->refer->status = REFER_NOAUTH;
12575 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12576 }
12577 break;
12578 case 481:
12579
12580
12581
12582
12583 ast_log(LOG_WARNING, "Remote host can't match REFER request to call '%s'. Giving up.\n", p->callid);
12584 if (p->owner)
12585 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12586 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12587 break;
12588
12589 case 500:
12590 case 501:
12591
12592
12593 ast_log(LOG_NOTICE, "SIP transfer to %s failed, call miserably fails. \n", p->refer->refer_to);
12594 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12595 p->refer->status = REFER_FAILED;
12596 break;
12597 case 603:
12598 ast_log(LOG_NOTICE, "SIP transfer to %s declined, call miserably fails. \n", p->refer->refer_to);
12599 p->refer->status = REFER_FAILED;
12600 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12601 break;
12602 }
12603 }
12604
12605
12606 static int handle_response_register(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int ignore, int seqno)
12607 {
12608 int expires, expires_ms;
12609 struct sip_registry *r;
12610 r=p->registry;
12611
12612 switch (resp) {
12613 case 401:
12614 if ((p->authtries == MAX_AUTHTRIES) || do_register_auth(p, req, "WWW-Authenticate", "Authorization")) {
12615 ast_log(LOG_NOTICE, "Failed to authenticate on REGISTER to '%s@%s' (Tries %d)\n", p->registry->username, p->registry->hostname, p->authtries);
12616 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12617 }
12618 break;
12619 case 403:
12620 ast_log(LOG_WARNING, "Forbidden - wrong password on authentication for REGISTER for '%s' to '%s'\n", p->registry->username, p->registry->hostname);
12621 if (global_regattempts_max)
12622 p->registry->regattempts = global_regattempts_max+1;
12623 AST_SCHED_DEL(sched, r->timeout);
12624 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12625 break;
12626 case 404:
12627 ast_log(LOG_WARNING, "Got 404 Not found on SIP register to service %s@%s, giving up\n", p->registry->username,p->registry->hostname);
12628 if (global_regattempts_max)
12629 p->registry->regattempts = global_regattempts_max+1;
12630 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12631 r->call = NULL;
12632 AST_SCHED_DEL(sched, r->timeout);
12633 break;
12634 case 407:
12635 if ((p->authtries == MAX_AUTHTRIES) || do_register_auth(p, req, "Proxy-Authenticate", "Proxy-Authorization")) {
12636 ast_log(LOG_NOTICE, "Failed to authenticate on REGISTER to '%s' (tries '%d')\n", get_header(&p->initreq, "From"), p->authtries);
12637 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12638 }
12639 break;
12640 case 408:
12641 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12642 r->call = NULL;
12643 AST_SCHED_DEL(sched, r->timeout);
12644 break;
12645 case 479:
12646 ast_log(LOG_WARNING, "Got error 479 on register to %s@%s, giving up (check config)\n", p->registry->username,p->registry->hostname);
12647 if (global_regattempts_max)
12648 p->registry->regattempts = global_regattempts_max+1;
12649 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12650 r->call = NULL;
12651 AST_SCHED_DEL(sched, r->timeout);
12652 break;
12653 case 200:
12654 if (!r) {
12655 ast_log(LOG_WARNING, "Got 200 OK on REGISTER that isn't a register\n");
12656 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12657 return 0;
12658 }
12659
12660 r->regstate = REG_STATE_REGISTERED;
12661 r->regtime = time(NULL);
12662 manager_event(EVENT_FLAG_SYSTEM, "Registry", "ChannelDriver: SIP\r\nDomain: %s\r\nStatus: %s\r\n", r->hostname, regstate2str(r->regstate));
12663 r->regattempts = 0;
12664 if (option_debug)
12665 ast_log(LOG_DEBUG, "Registration successful\n");
12666 if (r->timeout > -1) {
12667 if (option_debug)
12668 ast_log(LOG_DEBUG, "Cancelling timeout %d\n", r->timeout);
12669 }
12670 AST_SCHED_DEL(sched, r->timeout);
12671 r->call = NULL;
12672 p->registry = NULL;
12673
12674 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
12675
12676
12677
12678
12679 AST_SCHED_DEL(sched, r->expire);
12680
12681
12682 expires = 0;
12683
12684
12685 if (!ast_strlen_zero(get_header(req, "Contact"))) {
12686 const char *contact = NULL;
12687 const char *tmptmp = NULL;
12688 int start = 0;
12689 for(;;) {
12690 contact = __get_header(req, "Contact", &start);
12691
12692 if(!ast_strlen_zero(contact)) {
12693 if( (tmptmp=strstr(contact, p->our_contact))) {
12694 contact=tmptmp;
12695 break;
12696 }
12697 } else
12698 break;
12699 }
12700 tmptmp = strcasestr(contact, "expires=");
12701 if (tmptmp) {
12702 if (sscanf(tmptmp + 8, "%d;", &expires) != 1)
12703 expires = 0;
12704 }
12705
12706 }
12707 if (!expires)
12708 expires=atoi(get_header(req, "expires"));
12709 if (!expires)
12710 expires=default_expiry;
12711
12712 expires_ms = expires * 1000;
12713 if (expires <= EXPIRY_GUARD_LIMIT)
12714 expires_ms -= MAX((expires_ms * EXPIRY_GUARD_PCT),EXPIRY_GUARD_MIN);
12715 else
12716 expires_ms -= EXPIRY_GUARD_SECS * 1000;
12717 if (sipdebug)
12718 ast_log(LOG_NOTICE, "Outbound Registration: Expiry for %s is %d sec (Scheduling reregistration in %d s)\n", r->hostname, expires, expires_ms/1000);
12719
12720 r->refresh= (int) expires_ms / 1000;
12721
12722
12723 AST_SCHED_DEL(sched, r->expire);
12724 r->expire = ast_sched_add(sched, expires_ms, sip_reregister, r);
12725 ASTOBJ_UNREF(r, sip_registry_destroy);
12726 }
12727 return 1;
12728 }
12729
12730
12731 static void handle_response_peerpoke(struct sip_pvt *p, int resp, struct sip_request *req)
12732 {
12733 struct sip_peer *peer = p->relatedpeer;
12734 int statechanged, is_reachable, was_reachable;
12735 int pingtime = ast_tvdiff_ms(ast_tvnow(), peer->ps);
12736
12737
12738
12739
12740
12741
12742 if (pingtime < 1)
12743 pingtime = 1;
12744
12745
12746
12747
12748
12749 was_reachable = peer->lastms > 0 && peer->lastms <= peer->maxms;
12750 is_reachable = pingtime <= peer->maxms;
12751 statechanged = peer->lastms == 0
12752 || was_reachable != is_reachable;
12753
12754 peer->lastms = pingtime;
12755 peer->call = NULL;
12756 if (statechanged) {
12757 const char *s = is_reachable ? "Reachable" : "Lagged";
12758
12759 ast_log(LOG_NOTICE, "Peer '%s' is now %s. (%dms / %dms)\n",
12760 peer->name, s, pingtime, peer->maxms);
12761 ast_device_state_changed("SIP/%s", peer->name);
12762 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus",
12763 "Peer: SIP/%s\r\nPeerStatus: %s\r\nTime: %d\r\n",
12764 peer->name, s, pingtime);
12765 }
12766
12767 if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
12768 struct sip_peer *peer_ptr = peer;
12769 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
12770 }
12771
12772 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12773
12774
12775 peer->pokeexpire = ast_sched_add(sched,
12776 is_reachable ? DEFAULT_FREQ_OK : DEFAULT_FREQ_NOTOK,
12777 sip_poke_peer_s, ASTOBJ_REF(peer));
12778
12779 if (peer->pokeexpire == -1) {
12780 ASTOBJ_UNREF(peer, sip_destroy_peer);
12781 }
12782 }
12783
12784
12785 static void stop_media_flows(struct sip_pvt *p)
12786 {
12787
12788 if (p->rtp)
12789 ast_rtp_stop(p->rtp);
12790 if (p->vrtp)
12791 ast_rtp_stop(p->vrtp);
12792 if (p->udptl)
12793 ast_udptl_stop(p->udptl);
12794 }
12795
12796
12797
12798 static void handle_response(struct sip_pvt *p, int resp, char *rest, struct sip_request *req, int ignore, int seqno)
12799 {
12800 struct ast_channel *owner;
12801 int sipmethod;
12802 int res = 1;
12803 const char *c = get_header(req, "Cseq");
12804 const char *msg = strchr(c, ' ');
12805
12806 if (!msg)
12807 msg = "";
12808 else
12809 msg++;
12810 sipmethod = find_sip_method(msg);
12811
12812 owner = p->owner;
12813 if (owner)
12814 owner->hangupcause = hangup_sip2cause(resp);
12815
12816
12817 if ((resp >= 100) && (resp <= 199))
12818 __sip_semi_ack(p, seqno, 0, sipmethod);
12819 else
12820 __sip_ack(p, seqno, 0, sipmethod);
12821
12822
12823 if (!p->owner && sipmethod == SIP_NOTIFY && p->pendinginvite)
12824 p->pendinginvite = 0;
12825
12826
12827 if (ast_strlen_zero(p->theirtag) || (resp >= 200)) {
12828 char tag[128];
12829
12830 gettag(req, "To", tag, sizeof(tag));
12831 ast_string_field_set(p, theirtag, tag);
12832 }
12833 if (p->relatedpeer && p->method == SIP_OPTIONS) {
12834
12835
12836
12837 if (resp != 100)
12838 handle_response_peerpoke(p, resp, req);
12839 } else if (ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
12840 switch(resp) {
12841 case 100:
12842 case 101:
12843 if (sipmethod == SIP_INVITE)
12844 handle_response_invite(p, resp, rest, req, seqno);
12845 break;
12846 case 183:
12847 if (sipmethod == SIP_INVITE)
12848 handle_response_invite(p, resp, rest, req, seqno);
12849 break;
12850 case 180:
12851 if (sipmethod == SIP_INVITE)
12852 handle_response_invite(p, resp, rest, req, seqno);
12853 break;
12854 case 182:
12855 if (sipmethod == SIP_INVITE)
12856 handle_response_invite(p, resp, rest, req, seqno);
12857 break;
12858 case 200:
12859 p->authtries = 0;
12860 if (sipmethod == SIP_MESSAGE || sipmethod == SIP_INFO) {
12861
12862
12863
12864 } else if (sipmethod == SIP_INVITE) {
12865 handle_response_invite(p, resp, rest, req, seqno);
12866 } else if (sipmethod == SIP_NOTIFY) {
12867
12868 if (p->owner) {
12869 if (!p->refer) {
12870 ast_log(LOG_WARNING, "Notify answer on an owned channel? - %s\n", p->owner->name);
12871 ast_queue_hangup(p->owner);
12872 } else if (option_debug > 3)
12873 ast_log(LOG_DEBUG, "Got OK on REFER Notify message\n");
12874 } else {
12875 if (p->subscribed == NONE)
12876 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12877 if (ast_test_flag(&p->flags[1], SIP_PAGE2_STATECHANGEQUEUE)) {
12878
12879 ast_clear_flag(&p->flags[1], SIP_PAGE2_STATECHANGEQUEUE);
12880 cb_extensionstate((char *)p->context, (char *)p->exten, p->laststate, (void *) p, NULL, NULL);
12881 }
12882 }
12883 } else if (sipmethod == SIP_REGISTER)
12884 res = handle_response_register(p, resp, rest, req, ignore, seqno);
12885 else if (sipmethod == SIP_BYE)
12886 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12887 break;
12888 case 202:
12889 if (sipmethod == SIP_REFER)
12890 handle_response_refer(p, resp, rest, req, seqno);
12891 break;
12892 case 401:
12893 if (sipmethod == SIP_INVITE)
12894 handle_response_invite(p, resp, rest, req, seqno);
12895 else if (sipmethod == SIP_REFER)
12896 handle_response_refer(p, resp, rest, req, seqno);
12897 else if (p->registry && sipmethod == SIP_REGISTER)
12898 res = handle_response_register(p, resp, rest, req, ignore, seqno);
12899 else if (sipmethod == SIP_BYE) {
12900 if (ast_strlen_zero(p->authname)) {
12901 ast_log(LOG_WARNING, "Asked to authenticate %s, to %s:%d but we have no matching peer!\n",
12902 msg, ast_inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));
12903 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12904 } else if ((p->authtries == MAX_AUTHTRIES) || do_proxy_auth(p, req, "WWW-Authenticate", "Authorization", sipmethod, 0)) {
12905 ast_log(LOG_NOTICE, "Failed to authenticate on %s to '%s'\n", msg, get_header(&p->initreq, "From"));
12906 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12907
12908
12909 }
12910 } else {
12911 ast_log(LOG_WARNING, "Got authentication request (401) on unknown %s to '%s'\n", sip_methods[sipmethod].text, get_header(req, "To"));
12912 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12913 }
12914 break;
12915 case 403:
12916 if (sipmethod == SIP_INVITE)
12917 handle_response_invite(p, resp, rest, req, seqno);
12918 else if (p->registry && sipmethod == SIP_REGISTER)
12919 res = handle_response_register(p, resp, rest, req, ignore, seqno);
12920 else {
12921 ast_log(LOG_WARNING, "Forbidden - maybe wrong password on authentication for %s\n", msg);
12922 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12923 }
12924 break;
12925 case 404:
12926 if (p->registry && sipmethod == SIP_REGISTER)
12927 res = handle_response_register(p, resp, rest, req, ignore, seqno);
12928 else if (sipmethod == SIP_INVITE)
12929 handle_response_invite(p, resp, rest, req, seqno);
12930 else if (owner)
12931 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12932 break;
12933 case 407:
12934 if (sipmethod == SIP_INVITE)
12935 handle_response_invite(p, resp, rest, req, seqno);
12936 else if (sipmethod == SIP_REFER)
12937 handle_response_refer(p, resp, rest, req, seqno);
12938 else if (p->registry && sipmethod == SIP_REGISTER)
12939 res = handle_response_register(p, resp, rest, req, ignore, seqno);
12940 else if (sipmethod == SIP_BYE) {
12941 if (ast_strlen_zero(p->authname)) {
12942 ast_log(LOG_WARNING, "Asked to authenticate %s, to %s:%d but we have no matching peer!\n",
12943 msg, ast_inet_ntoa(p->recv.sin_addr), ntohs(p->recv.sin_port));
12944 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12945 } else if ((p->authtries == MAX_AUTHTRIES) || do_proxy_auth(p, req, "Proxy-Authenticate", "Proxy-Authorization", sipmethod, 0)) {
12946 ast_log(LOG_NOTICE, "Failed to authenticate on %s to '%s'\n", msg, get_header(&p->initreq, "From"));
12947 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12948 }
12949 } else
12950 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12951
12952 break;
12953 case 408:
12954 if (sipmethod == SIP_INVITE)
12955 handle_response_invite(p, resp, rest, req, seqno);
12956 else if (sipmethod == SIP_REGISTER)
12957 res = handle_response_register(p, resp, rest, req, ignore, seqno);
12958 else if (sipmethod == SIP_BYE) {
12959 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12960 if (option_debug)
12961 ast_log(LOG_DEBUG, "Got timeout on bye. Thanks for the answer. Now, kill this call\n");
12962 } else {
12963 if (owner)
12964 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
12965 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
12966 }
12967 break;
12968 case 481:
12969 if (sipmethod == SIP_INVITE) {
12970 handle_response_invite(p, resp, rest, req, seqno);
12971 } else if (sipmethod == SIP_REFER) {
12972 handle_response_refer(p, resp, rest, req, seqno);
12973 } else if (sipmethod == SIP_BYE) {
12974
12975
12976 ast_log(LOG_WARNING, "Remote host can't match request %s to call '%s'. Giving up.\n", sip_methods[sipmethod].text, p->callid);
12977 } else if (sipmethod == SIP_CANCEL) {
12978
12979
12980 ast_log(LOG_WARNING, "Remote host can't match request %s to call '%s'. Giving up.\n", sip_methods[sipmethod].text, p->callid);
12981 } else {
12982 ast_log(LOG_WARNING, "Remote host can't match request %s to call '%s'. Giving up.\n", sip_methods[sipmethod].text, p->callid);
12983
12984 }
12985 break;
12986 case 487:
12987 if (sipmethod == SIP_INVITE)
12988 handle_response_invite(p, resp, rest, req, seqno);
12989 break;
12990 case 488:
12991 if (sipmethod == SIP_INVITE)
12992 handle_response_invite(p, resp, rest, req, seqno);
12993 break;
12994 case 491:
12995 if (sipmethod == SIP_INVITE)
12996 handle_response_invite(p, resp, rest, req, seqno);
12997 else {
12998 if (option_debug)
12999 ast_log(LOG_DEBUG, "Got 491 on %s, unspported. Call ID %s\n", sip_methods[sipmethod].text, p->callid);
13000 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
13001 }
13002 break;
13003 case 501:
13004 if (sipmethod == SIP_INVITE)
13005 handle_response_invite(p, resp, rest, req, seqno);
13006 else if (sipmethod == SIP_REFER)
13007 handle_response_refer(p, resp, rest, req, seqno);
13008 else
13009 ast_log(LOG_WARNING, "Host '%s' does not implement '%s'\n", ast_inet_ntoa(p->sa.sin_addr), msg);
13010 break;
13011 case 603:
13012 if (sipmethod == SIP_REFER) {
13013 handle_response_refer(p, resp, rest, req, seqno);
13014 break;
13015 }
13016
13017 default:
13018 if ((resp >= 300) && (resp < 700)) {
13019
13020 if ((option_verbose > 2) && (resp != 487))
13021 ast_verbose(VERBOSE_PREFIX_3 "Got SIP response %d \"%s\" back from %s\n", resp, rest, ast_inet_ntoa(p->sa.sin_addr));
13022
13023 if (sipmethod == SIP_INVITE)
13024 stop_media_flows(p);
13025
13026
13027 switch(resp) {
13028 case 300:
13029 case 301:
13030 case 302:
13031 case 305:
13032 parse_moved_contact(p, req);
13033
13034 case 486:
13035 case 600:
13036 case 603:
13037 if (p->owner)
13038 ast_queue_control(p->owner, AST_CONTROL_BUSY);
13039 break;
13040 case 482:
13041
13042
13043
13044
13045 if (option_debug)
13046 ast_log(LOG_DEBUG, "Hairpin detected, setting up call forward for what it's worth\n");
13047 if (p->owner)
13048 ast_string_field_build(p->owner, call_forward,
13049 "Local/%s@%s", p->username, p->context);
13050
13051 case 480:
13052 case 404:
13053 case 410:
13054 case 400:
13055 case 500:
13056 if (sipmethod == SIP_REFER) {
13057 handle_response_refer(p, resp, rest, req, seqno);
13058 break;
13059 }
13060
13061 case 502:
13062 case 503:
13063 case 504:
13064 if (owner)
13065 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
13066 break;
13067 default:
13068
13069 if (owner && sipmethod != SIP_MESSAGE && sipmethod != SIP_INFO && sipmethod != SIP_BYE)
13070 ast_queue_hangup(p->owner);
13071 break;
13072 }
13073
13074 if (sipmethod == SIP_INVITE)
13075 transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
13076 if (sipmethod != SIP_MESSAGE && sipmethod != SIP_INFO)
13077 sip_alreadygone(p);
13078 if (!p->owner)
13079 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
13080 } else if ((resp >= 100) && (resp < 200)) {
13081 if (sipmethod == SIP_INVITE) {
13082 if (!ast_test_flag(req, SIP_PKT_IGNORE) && sip_cancel_destroy(p))
13083 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
13084 if (find_sdp(req))
13085 process_sdp(p, req);
13086 if (p->owner) {
13087
13088 ast_queue_control(p->owner, AST_CONTROL_PROGRESS);
13089 }
13090 }
13091 } else
13092 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));
13093 }
13094 } else {
13095
13096
13097 if (ast_test_flag(req, SIP_PKT_DEBUG))
13098 ast_verbose("SIP Response message for INCOMING dialog %s arrived\n", msg);
13099
13100 if (sipmethod == SIP_INVITE && resp == 200) {
13101
13102
13103 char tag[128];
13104
13105 gettag(req, "To", tag, sizeof(tag));
13106 ast_string_field_set(p, theirtag, tag);
13107 }
13108
13109 switch(resp) {
13110 case 200:
13111 if (sipmethod == SIP_INVITE) {
13112 handle_response_invite(p, resp, rest, req, seqno);
13113 } else if (sipmethod == SIP_CANCEL) {
13114 if (option_debug)
13115 ast_log(LOG_DEBUG, "Got 200 OK on CANCEL\n");
13116
13117
13118 } else if (sipmethod == SIP_NOTIFY) {
13119
13120 if (p->owner) {
13121 if (p->refer) {
13122 if (option_debug)
13123 ast_log(LOG_DEBUG, "Got 200 OK on NOTIFY for transfer\n");
13124 } else
13125 ast_log(LOG_WARNING, "Notify answer on an owned channel?\n");
13126
13127 } else {
13128 if (!p->subscribed && !p->refer)
13129 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
13130 if (ast_test_flag(&p->flags[1], SIP_PAGE2_STATECHANGEQUEUE)) {
13131
13132 ast_clear_flag(&p->flags[1], SIP_PAGE2_STATECHANGEQUEUE);
13133 cb_extensionstate((char *)p->context, (char *)p->exten, p->laststate, (void *) p, NULL, NULL);
13134 }
13135 }
13136 } else if (sipmethod == SIP_BYE)
13137 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
13138 else if (sipmethod == SIP_MESSAGE || sipmethod == SIP_INFO)
13139
13140
13141 ;
13142 else if (sipmethod == SIP_BYE)
13143
13144 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
13145 break;
13146 case 202:
13147 if (sipmethod == SIP_REFER)
13148 handle_response_refer(p, resp, rest, req, seqno);
13149 break;
13150 case 401:
13151 case 407:
13152 if (sipmethod == SIP_REFER)
13153 handle_response_refer(p, resp, rest, req, seqno);
13154 else if (sipmethod == SIP_INVITE)
13155 handle_response_invite(p, resp, rest, req, seqno);
13156 else if (sipmethod == SIP_BYE) {
13157 char *auth, *auth2;
13158
13159 auth = (resp == 407 ? "Proxy-Authenticate" : "WWW-Authenticate");
13160 auth2 = (resp == 407 ? "Proxy-Authorization" : "Authorization");
13161 if ((p->authtries == MAX_AUTHTRIES) || do_proxy_auth(p, req, auth, auth2, sipmethod, 0)) {
13162 ast_log(LOG_NOTICE, "Failed to authenticate on %s to '%s'\n", msg, get_header(&p->initreq, "From"));
13163 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
13164 }
13165 }
13166 break;
13167 case 481:
13168 if (sipmethod == SIP_INVITE) {
13169
13170 handle_response_invite(p, resp, rest, req, seqno);
13171 } else if (sipmethod == SIP_BYE) {
13172 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
13173 } else if (sipdebug) {
13174 ast_log (LOG_DEBUG, "Remote host can't match request %s to call '%s'. Giving up\n", sip_methods[sipmethod].text, p->callid);
13175 }
13176 break;
13177 case 501:
13178 if (sipmethod == SIP_INVITE)
13179 handle_response_invite(p, resp, rest, req, seqno);
13180 else if (sipmethod == SIP_REFER)
13181 handle_response_refer(p, resp, rest, req, seqno);
13182 break;
13183 case 603:
13184 if (sipmethod == SIP_REFER) {
13185 handle_response_refer(p, resp, rest, req, seqno);
13186 break;
13187 }
13188
13189 default:
13190 if ((resp >= 100) && (resp < 200)) {
13191 if (sipmethod == SIP_INVITE) {
13192 if (!ast_test_flag(req, SIP_PKT_IGNORE) && sip_cancel_destroy(p))
13193 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
13194 }
13195 }
13196 if ((resp >= 300) && (resp < 700)) {
13197 if ((option_verbose > 2) && (resp != 487))
13198 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));
13199 switch(resp) {
13200 case 488:
13201 case 603:
13202 case 500:
13203 case 502:
13204 case 503:
13205 case 504:
13206
13207
13208 if (sipmethod == SIP_INVITE && sip_cancel_destroy(p))
13209 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
13210 break;
13211 }
13212 }
13213 break;
13214 }
13215 }
13216 }
13217
13218
13219
13220
13221
13222
13223
13224 static void *sip_park_thread(void *stuff)
13225 {
13226 struct ast_channel *transferee, *transferer;
13227 struct sip_dual *d;
13228 struct sip_request req;
13229 int ext;
13230 int res;
13231
13232 d = stuff;
13233 transferee = d->chan1;
13234 transferer = d->chan2;
13235 copy_request(&req, &d->req);
13236 free(d);
13237
13238 if (!transferee || !transferer) {
13239 ast_log(LOG_ERROR, "Missing channels for parking! Transferer %s Transferee %s\n", transferer ? "<available>" : "<missing>", transferee ? "<available>" : "<missing>" );
13240 return NULL;
13241 }
13242 if (option_debug > 3)
13243 ast_log(LOG_DEBUG, "SIP Park: Transferer channel %s, Transferee %s\n", transferer->name, transferee->name);
13244
13245 ast_channel_lock(transferee);
13246 if (ast_do_masquerade(transferee)) {
13247 ast_log(LOG_WARNING, "Masquerade failed.\n");
13248 transmit_response(transferer->tech_pvt, "503 Internal error", &req);
13249 ast_channel_unlock(transferee);
13250 return NULL;
13251 }
13252 ast_channel_unlock(transferee);
13253
13254 res = ast_park_call(transferee, transferer, 0, &ext);
13255
13256
13257 #ifdef WHEN_WE_KNOW_THAT_THE_CLIENT_SUPPORTS_MESSAGE
13258 if (!res) {
13259 transmit_message_with_text(transferer->tech_pvt, "Unable to park call.\n");
13260 } else {
13261
13262 sprintf(buf, "Call parked on extension '%d'", ext);
13263 transmit_message_with_text(transferer->tech_pvt, buf);
13264 }
13265 #endif
13266
13267
13268
13269 transmit_response(transferer->tech_pvt, "202 Accepted", &req);
13270 if (!res) {
13271
13272 append_history(transferer->tech_pvt, "SIPpark","Parked call on %d", ext);
13273 transmit_notify_with_sipfrag(transferer->tech_pvt, d->seqno, "200 OK", TRUE);
13274 transferer->hangupcause = AST_CAUSE_NORMAL_CLEARING;
13275 ast_hangup(transferer);
13276 if (option_debug)
13277 ast_log(LOG_DEBUG, "SIP Call parked on extension '%d'\n", ext);
13278 } else {
13279 transmit_notify_with_sipfrag(transferer->tech_pvt, d->seqno, "503 Service Unavailable", TRUE);
13280 append_history(transferer->tech_pvt, "SIPpark","Parking failed\n");
13281 if (option_debug)
13282 ast_log(LOG_DEBUG, "SIP Call parked failed \n");
13283
13284 }
13285 return NULL;
13286 }
13287
13288
13289
13290
13291 static int sip_park(struct ast_channel *chan1, struct ast_channel *chan2, struct sip_request *req, int seqno)
13292 {
13293 struct sip_dual *d;
13294 struct ast_channel *transferee, *transferer;
13295
13296 pthread_t th;
13297
13298 transferee = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, chan1->accountcode, chan1->exten, chan1->context, chan1->amaflags, "Parking/%s", chan1->name);
13299 transferer = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, chan2->accountcode, chan2->exten, chan2->context, chan2->amaflags, "SIPPeer/%s", chan2->name);
13300 if ((!transferer) || (!transferee)) {
13301 if (transferee) {
13302 transferee->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
13303 ast_hangup(transferee);
13304 }
13305 if (transferer) {
13306 transferer->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
13307 ast_hangup(transferer);
13308 }
13309 return -1;
13310 }
13311
13312
13313 transferee->readformat = chan1->readformat;
13314 transferee->writeformat = chan1->writeformat;
13315
13316
13317 ast_channel_masquerade(transferee, chan1);
13318
13319
13320 ast_copy_string(transferee->context, chan1->context, sizeof(transferee->context));
13321 ast_copy_string(transferee->exten, chan1->exten, sizeof(transferee->exten));
13322 transferee->priority = chan1->priority;
13323
13324
13325
13326
13327
13328 transferer->readformat = chan2->readformat;
13329 transferer->writeformat = chan2->writeformat;
13330
13331
13332
13333
13334 while (ast_channel_trylock(chan2)) {
13335 struct sip_pvt *pvt = chan2->tech_pvt;
13336 DEADLOCK_AVOIDANCE(&pvt->lock);
13337 }
13338 ast_channel_masquerade(transferer, chan2);
13339 ast_channel_unlock(chan2);
13340
13341
13342 ast_copy_string(transferer->context, chan2->context, sizeof(transferer->context));
13343 ast_copy_string(transferer->exten, chan2->exten, sizeof(transferer->exten));
13344 transferer->priority = chan2->priority;
13345
13346 ast_channel_lock(transferer);
13347 if (ast_do_masquerade(transferer)) {
13348 ast_log(LOG_WARNING, "Masquerade failed :(\n");
13349 ast_channel_unlock(transferer);
13350 transferer->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
13351 ast_hangup(transferer);
13352 return -1;
13353 }
13354 ast_channel_unlock(transferer);
13355 if (!transferer || !transferee) {
13356 if (!transferer) {
13357 if (option_debug)
13358 ast_log(LOG_DEBUG, "No transferer channel, giving up parking\n");
13359 }
13360 if (!transferee) {
13361 if (option_debug)
13362 ast_log(LOG_DEBUG, "No transferee channel, giving up parking\n");
13363 }
13364 return -1;
13365 }
13366 if ((d = ast_calloc(1, sizeof(*d)))) {
13367 pthread_attr_t attr;
13368
13369 pthread_attr_init(&attr);
13370 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
13371
13372
13373 copy_request(&d->req, req);
13374 d->chan1 = transferee;
13375 d->chan2 = transferer;
13376 d->seqno = seqno;
13377 if (ast_pthread_create_background(&th, &attr, sip_park_thread, d) < 0) {
13378
13379 free(d);
13380
13381 pthread_attr_destroy(&attr);
13382 return 0;
13383 }
13384 pthread_attr_destroy(&attr);
13385 }
13386 return -1;
13387 }
13388
13389
13390
13391
13392 static void ast_quiet_chan(struct ast_channel *chan)
13393 {
13394 if (chan && chan->_state == AST_STATE_UP) {
13395 if (ast_test_flag(chan, AST_FLAG_MOH))
13396 ast_moh_stop(chan);
13397 else if (chan->generatordata)
13398 ast_deactivate_generator(chan);
13399 }
13400 }
13401
13402
13403
13404 static int attempt_transfer(struct sip_dual *transferer, struct sip_dual *target)
13405 {
13406 int res = 0;
13407 struct ast_channel *peera = NULL,
13408 *peerb = NULL,
13409 *peerc = NULL,
13410 *peerd = NULL;
13411
13412
13413
13414
13415 if (option_debug > 3) {
13416 ast_log(LOG_DEBUG, "Sip transfer:--------------------\n");
13417 if (transferer->chan1)
13418 ast_log(LOG_DEBUG, "-- Transferer to PBX channel: %s State %s\n", transferer->chan1->name, ast_state2str(transferer->chan1->_state));
13419 else
13420 ast_log(LOG_DEBUG, "-- No transferer first channel - odd??? \n");
13421 if (target->chan1)
13422 ast_log(LOG_DEBUG, "-- Transferer to PBX second channel (target): %s State %s\n", target->chan1->name, ast_state2str(target->chan1->_state));
13423 else
13424 ast_log(LOG_DEBUG, "-- No target first channel ---\n");
13425 if (transferer->chan2)
13426 ast_log(LOG_DEBUG, "-- Bridged call to transferee: %s State %s\n", transferer->chan2->name, ast_state2str(transferer->chan2->_state));
13427 else
13428 ast_log(LOG_DEBUG, "-- No bridged call to transferee\n");
13429 if (target->chan2)
13430 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)");
13431 else
13432 ast_log(LOG_DEBUG, "-- No target second channel ---\n");
13433 ast_log(LOG_DEBUG, "-- END Sip transfer:--------------------\n");
13434 }
13435 if (transferer->chan2) {
13436 peera = transferer->chan1;
13437 peerb = target->chan1;
13438 peerc = transferer->chan2;
13439 peerd = target->chan2;
13440 if (option_debug > 2)
13441 ast_log(LOG_DEBUG, "SIP transfer: Four channels to handle\n");
13442 } else if (target->chan2) {
13443 peera = target->chan1;
13444 peerb = transferer->chan1;
13445 peerc = target->chan2;
13446 peerd = transferer->chan2;
13447 if (option_debug > 2)
13448 ast_log(LOG_DEBUG, "SIP transfer: Three channels to handle\n");
13449 }
13450
13451 if (peera && peerb && peerc && (peerb != peerc)) {
13452 ast_quiet_chan(peera);
13453 ast_quiet_chan(peerb);
13454 ast_quiet_chan(peerc);
13455 if (peerd)
13456 ast_quiet_chan(peerd);
13457
13458
13459 if (peera->cdr && peerb->cdr)
13460 peerb->cdr = ast_cdr_append(peerb->cdr, peera->cdr);
13461 else if (peera->cdr)
13462 peerb->cdr = peera->cdr;
13463 peera->cdr = NULL;
13464
13465 if (peerb->cdr && peerc->cdr)
13466 peerb->cdr = ast_cdr_append(peerb->cdr, peerc->cdr);
13467 else if (peerc->cdr)
13468 peerb->cdr = peerc->cdr;
13469 peerc->cdr = NULL;
13470
13471 if (option_debug > 3)
13472 ast_log(LOG_DEBUG, "SIP transfer: trying to masquerade %s into %s\n", peerc->name, peerb->name);
13473 if (ast_channel_masquerade(peerb, peerc)) {
13474 ast_log(LOG_WARNING, "Failed to masquerade %s into %s\n", peerb->name, peerc->name);
13475 res = -1;
13476 } else
13477 ast_log(LOG_DEBUG, "SIP transfer: Succeeded to masquerade channels.\n");
13478 return res;
13479 } else {
13480 ast_log(LOG_NOTICE, "SIP Transfer attempted with no appropriate bridged calls to transfer\n");
13481 if (transferer->chan1)
13482 ast_softhangup_nolock(transferer->chan1, AST_SOFTHANGUP_DEV);
13483 if (target->chan1)
13484 ast_softhangup_nolock(target->chan1, AST_SOFTHANGUP_DEV);
13485 return -2;
13486 }
13487 return 0;
13488 }
13489
13490
13491
13492
13493
13494
13495 static const char *gettag(const struct sip_request *req, const char *header, char *tagbuf, int tagbufsize)
13496 {
13497 const char *thetag;
13498
13499 if (!tagbuf)
13500 return NULL;
13501 tagbuf[0] = '\0';
13502 thetag = get_header(req, header);
13503 thetag = strcasestr(thetag, ";tag=");
13504 if (thetag) {
13505 thetag += 5;
13506 ast_copy_string(tagbuf, thetag, tagbufsize);
13507 return strsep(&tagbuf, ";");
13508 }
13509 return NULL;
13510 }
13511
13512
13513 static int handle_request_notify(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int seqno, char *e)
13514 {
13515
13516
13517 int res = 0;
13518 const char *event = get_header(req, "Event");
13519 char *eventid = NULL;
13520 char *sep;
13521
13522 if( (sep = strchr(event, ';')) ) {
13523 *sep++ = '\0';
13524 eventid = sep;
13525 }
13526
13527 if (option_debug > 1 && sipdebug)
13528 ast_log(LOG_DEBUG, "Got NOTIFY Event: %s\n", event);
13529
13530 if (strcmp(event, "refer")) {
13531
13532
13533 transmit_response(p, "489 Bad event", req);
13534 res = -1;
13535 } else {
13536
13537
13538
13539
13540
13541 char buf[1024];
13542 char *cmd, *code;
13543 int respcode;
13544 int success = TRUE;
13545
13546
13547
13548
13549
13550
13551
13552
13553 if (strncasecmp(get_header(req, "Content-Type"), "message/sipfrag", strlen("message/sipfrag"))) {
13554
13555 transmit_response(p, "400 Bad request", req);
13556 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
13557 return -1;
13558 }
13559
13560
13561 if (get_msg_text(buf, sizeof(buf), req)) {
13562 ast_log(LOG_WARNING, "Unable to retrieve attachment from NOTIFY %s\n", p->callid);
13563 transmit_response(p, "400 Bad request", req);
13564 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
13565 return -1;
13566 }
13567
13568
13569
13570
13571
13572
13573
13574
13575
13576
13577
13578
13579
13580
13581
13582
13583
13584
13585
13586
13587
13588 if (option_debug > 2)
13589 ast_log(LOG_DEBUG, "* SIP Transfer NOTIFY Attachment: \n---%s\n---\n", buf);
13590 cmd = ast_skip_blanks(buf);
13591 code = cmd;
13592
13593 while(*code && (*code > 32)) {
13594 code++;
13595 }
13596 *code++ = '\0';
13597 code = ast_skip_blanks(code);
13598 sep = code;
13599 sep++;
13600 while(*sep && (*sep > 32)) {
13601 sep++;
13602 }
13603 *sep++ = '\0';
13604 respcode = atoi(code);
13605 switch (respcode) {
13606 case 100:
13607 case 101:
13608
13609 break;
13610 case 183:
13611
13612 break;
13613 case 200:
13614
13615 break;
13616 case 301:
13617 case 302:
13618
13619 success = FALSE;
13620 break;
13621 case 503:
13622
13623 success = FALSE;
13624 break;
13625 case 603:
13626
13627 success = FALSE;
13628 break;
13629 }
13630 if (!success) {
13631 ast_log(LOG_NOTICE, "Transfer failed. Sorry. Nothing further to do with this call\n");
13632 }
13633
13634
13635 transmit_response(p, "200 OK", req);
13636 };
13637
13638 if (!p->lastinvite)
13639 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
13640
13641 return res;
13642 }
13643
13644
13645 static int handle_request_options(struct sip_pvt *p, struct sip_request *req)
13646 {
13647 int res;
13648
13649 res = get_destination(p, req);
13650 build_contact(p);
13651
13652
13653
13654 if (ast_strlen_zero(p->context))
13655 ast_string_field_set(p, context, default_context);
13656
13657 if (ast_shutting_down())
13658 transmit_response_with_allow(p, "503 Unavailable", req, 0);
13659 else if (res < 0)
13660 transmit_response_with_allow(p, "404 Not Found", req, 0);
13661 else
13662 transmit_response_with_allow(p, "200 OK", req, 0);
13663
13664
13665
13666 if (!p->lastinvite)
13667 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
13668
13669 return res;
13670 }
13671
13672
13673
13674 static int handle_invite_replaces(struct sip_pvt *p, struct sip_request *req, int debug, int ignore, int seqno, struct sockaddr_in *sin)
13675 {
13676 struct ast_frame *f;
13677 int earlyreplace = 0;
13678 int oneleggedreplace = 0;
13679 struct ast_channel *c = p->owner;
13680 struct ast_channel *replacecall = p->refer->refer_call->owner;
13681 struct ast_channel *targetcall;
13682
13683
13684 if (replacecall->_state == AST_STATE_RING)
13685 earlyreplace = 1;
13686
13687
13688 if (!(targetcall = ast_bridged_channel(replacecall))) {
13689
13690 if (!earlyreplace) {
13691 if (option_debug > 1)
13692 ast_log(LOG_DEBUG, " Attended transfer attempted to replace call with no bridge (maybe ringing). Channel %s!\n", replacecall->name);
13693 oneleggedreplace = 1;
13694 }
13695 }
13696 if (option_debug > 3 && targetcall && targetcall->_state == AST_STATE_RINGING)
13697 ast_log(LOG_DEBUG, "SIP transfer: Target channel is in ringing state\n");
13698
13699 if (option_debug > 3) {
13700 if (targetcall)
13701 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);
13702 else
13703 ast_log(LOG_DEBUG, "SIP transfer: Invite Replace incoming channel should replace and hang up channel %s (one call leg)\n", replacecall->name);
13704 }
13705
13706 if (ignore) {
13707 ast_log(LOG_NOTICE, "Ignoring this INVITE with replaces in a stupid way.\n");
13708
13709
13710
13711 transmit_response_with_sdp(p, "200 OK", req, XMIT_RELIABLE);
13712
13713 ast_channel_unlock(c);
13714 ast_mutex_unlock(&p->refer->refer_call->lock);
13715 return 1;
13716 }
13717 if (!c) {
13718
13719 ast_log(LOG_ERROR, "Unable to create new channel. Invite/replace failed.\n");
13720 transmit_response_reliable(p, "503 Service Unavailable", req);
13721 append_history(p, "Xfer", "INVITE/Replace Failed. No new channel.");
13722 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
13723 ast_mutex_unlock(&p->refer->refer_call->lock);
13724 return 1;
13725 }
13726 append_history(p, "Xfer", "INVITE/Replace received");
13727
13728
13729
13730
13731
13732
13733
13734
13735
13736
13737
13738 transmit_response(p, "100 Trying", req);
13739 ast_setstate(c, AST_STATE_RING);
13740
13741
13742
13743
13744
13745 transmit_response_with_sdp(p, "200 OK", req, XMIT_RELIABLE);
13746
13747 ast_setstate(c, AST_STATE_UP);
13748
13749
13750 ast_quiet_chan(replacecall);
13751 ast_quiet_chan(targetcall);
13752 if (option_debug > 3)
13753 ast_log(LOG_DEBUG, "Invite/Replaces: preparing to masquerade %s into %s\n", c->name, replacecall->name);
13754
13755 if (!oneleggedreplace)
13756 ast_channel_unlock(c);
13757
13758
13759 ast_mutex_unlock(&p->refer->refer_call->lock);
13760
13761
13762 if (! earlyreplace && ! oneleggedreplace )
13763 ast_set_flag(&p->refer->refer_call->flags[0], SIP_DEFER_BYE_ON_TRANSFER);
13764
13765
13766 if(ast_channel_masquerade(replacecall, c))
13767 ast_log(LOG_ERROR, "Failed to masquerade C into Replacecall\n");
13768 else if (option_debug > 3)
13769 ast_log(LOG_DEBUG, "Invite/Replaces: Going to masquerade %s into %s\n", c->name, replacecall->name);
13770
13771
13772
13773
13774
13775 ast_channel_unlock(c);
13776
13777 if (earlyreplace || oneleggedreplace ) {
13778
13779 if ((f = ast_read(replacecall))) {
13780 ast_frfree(f);
13781 f = NULL;
13782 if (option_debug > 3)
13783 ast_log(LOG_DEBUG, "Invite/Replace: Could successfully read frame from RING channel!\n");
13784 } else {
13785 ast_log(LOG_WARNING, "Invite/Replace: Could not read frame from RING channel \n");
13786 }
13787 c->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
13788 if (!oneleggedreplace)
13789 ast_channel_unlock(replacecall);
13790 } else {
13791 if ((f = ast_read(replacecall))) {
13792
13793 ast_frfree(f);
13794 f = NULL;
13795 if (option_debug > 2)
13796 ast_log(LOG_DEBUG, "Invite/Replace: Could successfully read frame from channel! Masq done.\n");
13797 } else {
13798 ast_log(LOG_WARNING, "Invite/Replace: Could not read frame from channel. Transfer failed\n");
13799 }
13800 ast_channel_unlock(replacecall);
13801 }
13802 ast_mutex_unlock(&p->refer->refer_call->lock);
13803
13804 ast_setstate(c, AST_STATE_DOWN);
13805 if (option_debug > 3) {
13806 struct ast_channel *test;
13807 ast_log(LOG_DEBUG, "After transfer:----------------------------\n");
13808 ast_log(LOG_DEBUG, " -- C: %s State %s\n", c->name, ast_state2str(c->_state));
13809 if (replacecall)
13810 ast_log(LOG_DEBUG, " -- replacecall: %s State %s\n", replacecall->name, ast_state2str(replacecall->_state));
13811 if (p->owner) {
13812 ast_log(LOG_DEBUG, " -- P->owner: %s State %s\n", p->owner->name, ast_state2str(p->owner->_state));
13813 test = ast_bridged_channel(p->owner);
13814 if (test)
13815 ast_log(LOG_DEBUG, " -- Call bridged to P->owner: %s State %s\n", test->name, ast_state2str(test->_state));
13816 else
13817 ast_log(LOG_DEBUG, " -- No call bridged to C->owner \n");
13818 } else
13819 ast_log(LOG_DEBUG, " -- No channel yet \n");
13820 ast_log(LOG_DEBUG, "End After transfer:----------------------------\n");
13821 }
13822
13823 ast_channel_unlock(p->owner);
13824 if (!oneleggedreplace)
13825 ast_mutex_unlock(&p->lock);
13826
13827
13828 c->tech_pvt = NULL;
13829 ast_hangup(c);
13830 return 0;
13831 }
13832
13833
13834
13835
13836
13837
13838
13839
13840
13841
13842
13843
13844
13845
13846
13847
13848
13849 static int sip_uri_params_cmp(const char *input1, const char *input2)
13850 {
13851 char *params1 = NULL;
13852 char *params2 = NULL;
13853 char *pos1;
13854 char *pos2;
13855 int zerolength1 = 0;
13856 int zerolength2 = 0;
13857 int maddrmatch = 0;
13858 int ttlmatch = 0;
13859 int usermatch = 0;
13860 int methodmatch = 0;
13861
13862 if (ast_strlen_zero(input1)) {
13863 zerolength1 = 1;
13864 } else {
13865 params1 = ast_strdupa(input1);
13866 }
13867 if (ast_strlen_zero(input2)) {
13868 zerolength2 = 1;
13869 } else {
13870 params2 = ast_strdupa(input2);
13871 }
13872
13873
13874
13875
13876 if (zerolength1 && zerolength2) {
13877 return 0;
13878 }
13879
13880 pos1 = params1;
13881 while (!ast_strlen_zero(pos1)) {
13882 char *name1 = pos1;
13883 char *value1 = strchr(pos1, '=');
13884 char *semicolon1 = strchr(pos1, ';');
13885 int matched = 0;
13886 if (semicolon1) {
13887 *semicolon1++ = '\0';
13888 }
13889 if (!value1) {
13890 goto fail;
13891 }
13892 *value1++ = '\0';
13893
13894
13895
13896
13897
13898 pos2 = ast_strdupa(params2);
13899 while (!ast_strlen_zero(pos2)) {
13900 char *name2 = pos2;
13901 char *value2 = strchr(pos2, '=');
13902 char *semicolon2 = strchr(pos2, ';');
13903 if (semicolon2) {
13904 *semicolon2++ = '\0';
13905 }
13906 if (!value2) {
13907 goto fail;
13908 }
13909 if (!strcasecmp(name1, name2)) {
13910 if (strcasecmp(value1, value2)) {
13911 goto fail;
13912 } else {
13913 matched = 1;
13914 break;
13915 }
13916 }
13917 pos2 = semicolon2;
13918 }
13919
13920 if (!strcasecmp(name1, "maddr")) {
13921 if (matched) {
13922 maddrmatch = 1;
13923 } else {
13924 goto fail;
13925 }
13926 } else if (!strcasecmp(name1, "ttl")) {
13927 if (matched) {
13928 ttlmatch = 1;
13929 } else {
13930 goto fail;
13931 }
13932 } else if (!strcasecmp(name1, "user")) {
13933 if (matched) {
13934 usermatch = 1;
13935 } else {
13936 goto fail;
13937 }
13938 } else if (!strcasecmp(name1, "method")) {
13939 if (matched) {
13940 methodmatch = 1;
13941 } else {
13942 goto fail;
13943 }
13944 }
13945 pos1 = semicolon1;
13946 }
13947
13948
13949
13950
13951
13952 pos2 = params2;
13953 while (!ast_strlen_zero(pos2)) {
13954 char *name2 = pos2;
13955 char *value2 = strchr(pos2, '=');
13956 char *semicolon2 = strchr(pos2, ';');
13957 if (semicolon2) {
13958 *semicolon2++ = '\0';
13959 }
13960 if (!value2) {
13961 goto fail;
13962 }
13963 if ((!strcasecmp(name2, "maddr") && !maddrmatch) ||
13964 (!strcasecmp(name2, "ttl") && !ttlmatch) ||
13965 (!strcasecmp(name2, "user") && !usermatch) ||
13966 (!strcasecmp(name2, "method") && !methodmatch)) {
13967 goto fail;
13968 }
13969 }
13970 return 0;
13971
13972 fail:
13973 return 1;
13974 }
13975
13976
13977
13978
13979
13980
13981
13982
13983
13984
13985
13986
13987 static int sip_uri_headers_cmp(const char *input1, const char *input2)
13988 {
13989 char *headers1 = NULL;
13990 char *headers2 = NULL;
13991 int zerolength1 = 0;
13992 int zerolength2 = 0;
13993 int different = 0;
13994 char *header1;
13995
13996 if (ast_strlen_zero(input1)) {
13997 zerolength1 = 1;
13998 } else {
13999 headers1 = ast_strdupa(input1);
14000 }
14001
14002 if (ast_strlen_zero(input2)) {
14003 zerolength2 = 1;
14004 } else {
14005 headers2 = ast_strdupa(input2);
14006 }
14007
14008 if ((zerolength1 && !zerolength2) ||
14009 (zerolength2 && !zerolength1))
14010 return 1;
14011
14012 if (zerolength1 && zerolength2)
14013 return 0;
14014
14015
14016
14017
14018
14019 if (strlen(headers1) != strlen(headers2)) {
14020 return 1;
14021 }
14022
14023 for (header1 = strsep(&headers1, "&"); header1; header1 = strsep(&headers1, "&")) {
14024 if (!strcasestr(headers2, header1)) {
14025 different = 1;
14026 break;
14027 }
14028 }
14029
14030 return different;
14031 }
14032
14033 static int sip_uri_cmp(const char *input1, const char *input2)
14034 {
14035 char *uri1 = ast_strdupa(input1);
14036 char *uri2 = ast_strdupa(input2);
14037 char *host1;
14038 char *host2;
14039 char *params1;
14040 char *params2;
14041 char *headers1;
14042 char *headers2;
14043
14044
14045
14046
14047 strsep(&uri1, ":");
14048 strsep(&uri2, ":");
14049
14050 if ((host1 = strchr(uri1, '@'))) {
14051 *host1++ = '\0';
14052 }
14053 if ((host2 = strchr(uri2, '@'))) {
14054 *host2++ = '\0';
14055 }
14056
14057
14058
14059
14060 if ((host1 && !host2) ||
14061 (host2 && !host1) ||
14062 (host1 && host2 && strcmp(uri1, uri2))) {
14063 return 1;
14064 }
14065
14066 if (!host1)
14067 host1 = uri1;
14068 if (!host2)
14069 host2 = uri2;
14070
14071
14072
14073
14074
14075 if ((params1 = strchr(host1, ';'))) {
14076 *params1++ = '\0';
14077 }
14078 if ((params2 = strchr(host2, ';'))) {
14079 *params2++ = '\0';
14080 }
14081
14082
14083
14084
14085 if ((headers1 = strchr(S_OR(params1, host1), '?'))) {
14086 *headers1++ = '\0';
14087 }
14088 if ((headers2 = strchr(S_OR(params2, host2), '?'))) {
14089 *headers2++ = '\0';
14090 }
14091
14092
14093
14094
14095
14096
14097
14098
14099
14100
14101
14102 if (strcasecmp(host1, host2)) {
14103 return 1;
14104 }
14105
14106
14107 if (sip_uri_headers_cmp(headers1, headers2)) {
14108 return 1;
14109 }
14110
14111
14112 return sip_uri_params_cmp(params1, params2);
14113 }
14114
14115
14116
14117
14118
14119
14120
14121
14122 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)
14123 {
14124 int res = 1;
14125 int gotdest;
14126 const char *p_replaces;
14127 char *replace_id = NULL;
14128 const char *required;
14129 unsigned int required_profile = 0;
14130 struct ast_channel *c = NULL;
14131 int reinvite = 0;
14132
14133
14134 if (!p->sipoptions) {
14135 const char *supported = get_header(req, "Supported");
14136 if (!ast_strlen_zero(supported))
14137 parse_sip_options(p, supported);
14138 }
14139
14140
14141 required = get_header(req, "Require");
14142 if (!ast_strlen_zero(required)) {
14143 required_profile = parse_sip_options(NULL, required);
14144 if (required_profile && required_profile != SIP_OPT_REPLACES) {
14145
14146 transmit_response_with_unsupported(p, "420 Bad extension (unsupported)", req, required);
14147 ast_log(LOG_WARNING,"Received SIP INVITE with unsupported required extension: %s\n", required);
14148 p->invitestate = INV_COMPLETED;
14149 if (!p->lastinvite)
14150 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14151 return -1;
14152 }
14153 }
14154
14155
14156 if (ast_test_flag(&p->flags[0], SIP_OUTGOING) && p->owner && (p->owner->_state != AST_STATE_UP)) {
14157
14158
14159
14160
14161
14162 int different;
14163 if (pedanticsipchecking)
14164 different = sip_uri_cmp(p->initreq.rlPart2, req->rlPart2);
14165 else
14166 different = strcmp(p->initreq.rlPart2, req->rlPart2);
14167 if (!different) {
14168 transmit_response(p, "482 Loop Detected", req);
14169 p->invitestate = INV_COMPLETED;
14170 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14171 return 0;
14172 } else {
14173
14174
14175
14176
14177 char *uri = ast_strdupa(req->rlPart2);
14178 char *at = strchr(uri, '@');
14179 char *peerorhost;
14180 struct sip_pkt *pkt = NULL;
14181 if (option_debug > 2) {
14182 ast_log(LOG_DEBUG, "Potential spiral detected. Original RURI was %s, new RURI is %s\n", p->initreq.rlPart2, req->rlPart2);
14183 }
14184 if (at) {
14185 *at = '\0';
14186 }
14187
14188 if ((peerorhost = strchr(uri, ':'))) {
14189 *peerorhost++ = '\0';
14190 }
14191 create_addr(p, peerorhost);
14192 ast_string_field_free(p, theirtag);
14193 for (pkt = p->packets; pkt; pkt = pkt->next) {
14194 if (pkt->seqno == p->icseq && pkt->method == SIP_INVITE) {
14195 AST_SCHED_DEL(sched, pkt->retransid);
14196 }
14197 }
14198 return transmit_invite(p, SIP_INVITE, 1, 3);
14199 }
14200 }
14201
14202 if (!ast_test_flag(req, SIP_PKT_IGNORE) && p->pendinginvite) {
14203
14204 transmit_response(p, "491 Request Pending", req);
14205 if (option_debug)
14206 ast_log(LOG_DEBUG, "Got INVITE on call where we already have pending INVITE, deferring that - %s\n", p->callid);
14207
14208 return 0;
14209 }
14210
14211 p_replaces = get_header(req, "Replaces");
14212 if (!ast_strlen_zero(p_replaces)) {
14213
14214 char *ptr;
14215 char *fromtag = NULL;
14216 char *totag = NULL;
14217 char *start, *to;
14218 int error = 0;
14219
14220 if (p->owner) {
14221 if (option_debug > 2)
14222 ast_log(LOG_DEBUG, "INVITE w Replaces on existing call? Refusing action. [%s]\n", p->callid);
14223 transmit_response(p, "400 Bad request", req);
14224
14225 return -1;
14226 }
14227
14228 if (sipdebug && option_debug > 2)
14229 ast_log(LOG_DEBUG, "INVITE part of call transfer. Replaces [%s]\n", p_replaces);
14230
14231 replace_id = ast_strdupa(p_replaces);
14232 ast_uri_decode(replace_id);
14233
14234 if (!p->refer && !sip_refer_allocate(p)) {
14235 transmit_response(p, "500 Server Internal Error", req);
14236 append_history(p, "Xfer", "INVITE/Replace Failed. Out of memory.");
14237 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14238 p->invitestate = INV_COMPLETED;
14239 return -1;
14240 }
14241
14242
14243
14244
14245
14246
14247
14248
14249
14250
14251 replace_id = ast_skip_blanks(replace_id);
14252
14253 start = replace_id;
14254 while ( (ptr = strsep(&start, ";")) ) {
14255 ptr = ast_skip_blanks(ptr);
14256 if ( (to = strcasestr(ptr, "to-tag=") ) )
14257 totag = to + 7;
14258 else if ( (to = strcasestr(ptr, "from-tag=") ) ) {
14259 fromtag = to + 9;
14260 fromtag = strsep(&fromtag, "&");
14261 }
14262 }
14263
14264 if (sipdebug && option_debug > 3)
14265 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>");
14266
14267
14268
14269
14270
14271 if ((p->refer->refer_call = get_sip_pvt_byid_locked(replace_id, totag, fromtag)) == NULL) {
14272 ast_log(LOG_NOTICE, "Supervised transfer attempted to replace non-existent call id (%s)!\n", replace_id);
14273 transmit_response(p, "481 Call Leg Does Not Exist (Replaces)", req);
14274 error = 1;
14275 }
14276
14277
14278
14279
14280
14281
14282
14283 if (p->refer->refer_call == p) {
14284 ast_log(LOG_NOTICE, "INVITE with replaces into it's own call id (%s == %s)!\n", replace_id, p->callid);
14285 p->refer->refer_call = NULL;
14286 transmit_response(p, "400 Bad request", req);
14287 error = 1;
14288 }
14289
14290 if (!error && !p->refer->refer_call->owner) {
14291
14292 ast_log(LOG_NOTICE, "Supervised transfer attempted to replace non-existing call id (%s)!\n", replace_id);
14293
14294 transmit_response(p, "481 Call Leg Does Not Exist (Replace)", req);
14295 error = 1;
14296 }
14297
14298 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 ) {
14299 ast_log(LOG_NOTICE, "Supervised transfer attempted to replace non-ringing or active call id (%s)!\n", replace_id);
14300 transmit_response(p, "603 Declined (Replaces)", req);
14301 error = 1;
14302 }
14303
14304 if (error) {
14305 append_history(p, "Xfer", "INVITE/Replace Failed.");
14306 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14307 ast_mutex_unlock(&p->lock);
14308 if (p->refer->refer_call) {
14309 ast_mutex_unlock(&p->refer->refer_call->lock);
14310 ast_channel_unlock(p->refer->refer_call->owner);
14311 }
14312 p->invitestate = INV_COMPLETED;
14313 return -1;
14314 }
14315 }
14316
14317
14318
14319
14320
14321 if (!ast_test_flag(req, SIP_PKT_IGNORE)) {
14322 int newcall = (p->initreq.headers ? TRUE : FALSE);
14323
14324 if (sip_cancel_destroy(p))
14325 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
14326
14327 p->pendinginvite = seqno;
14328 check_via(p, req);
14329
14330 copy_request(&p->initreq, req);
14331 if (!p->owner) {
14332 if (debug)
14333 ast_verbose("Using INVITE request as basis request - %s\n", p->callid);
14334 if (newcall)
14335 append_history(p, "Invite", "New call: %s", p->callid);
14336 parse_ok_contact(p, req);
14337 } else {
14338 ast_clear_flag(&p->flags[0], SIP_OUTGOING);
14339
14340 if (find_sdp(req)) {
14341 if (process_sdp(p, req)) {
14342 transmit_response(p, "488 Not acceptable here", req);
14343 if (!p->lastinvite)
14344 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14345 return -1;
14346 }
14347 } else {
14348 p->jointcapability = p->capability;
14349 if (option_debug > 2)
14350 ast_log(LOG_DEBUG, "Hm.... No sdp for the moment\n");
14351
14352
14353
14354 if (ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD))
14355 change_hold_state(p, req, FALSE, 0);
14356 }
14357 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
14358 append_history(p, "ReInv", "Re-invite received");
14359 }
14360 } else if (debug)
14361 ast_verbose("Ignoring this INVITE request\n");
14362
14363
14364 if (!p->lastinvite && !ast_test_flag(req, SIP_PKT_IGNORE) && !p->owner) {
14365
14366
14367 res = check_user(p, req, SIP_INVITE, e, XMIT_RELIABLE, sin);
14368 if (res == AUTH_CHALLENGE_SENT) {
14369 p->invitestate = INV_COMPLETED;
14370 return 0;
14371 }
14372 if (res < 0) {
14373 if (res == AUTH_FAKE_AUTH) {
14374 ast_log(LOG_NOTICE, "Sending fake auth rejection for user %s\n", get_header(req, "From"));
14375 transmit_fake_auth_response(p, SIP_INVITE, req, XMIT_RELIABLE);
14376 } else {
14377 ast_log(LOG_NOTICE, "Failed to authenticate user %s\n", get_header(req, "From"));
14378 transmit_response_reliable(p, "403 Forbidden", req);
14379 }
14380 p->invitestate = INV_COMPLETED;
14381 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14382 ast_string_field_free(p, theirtag);
14383 return 0;
14384 }
14385
14386
14387 if (find_sdp(req)) {
14388 if (process_sdp(p, req)) {
14389
14390 transmit_response_reliable(p, "488 Not acceptable here", req);
14391 p->invitestate = INV_COMPLETED;
14392 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14393 if (option_debug)
14394 ast_log(LOG_DEBUG, "No compatible codecs for this SIP call.\n");
14395 return -1;
14396 }
14397 } else {
14398 p->jointcapability = p->capability;
14399 if (option_debug > 1)
14400 ast_log(LOG_DEBUG, "No SDP in Invite, third party call control\n");
14401 }
14402
14403
14404
14405 if (p->owner)
14406 ast_queue_frame(p->owner, &ast_null_frame);
14407
14408
14409
14410 if (ast_strlen_zero(p->context))
14411 ast_string_field_set(p, context, default_context);
14412
14413
14414
14415 if (option_debug)
14416 ast_log(LOG_DEBUG, "Checking SIP call limits for device %s\n", p->username);
14417 if ((res = update_call_counter(p, INC_CALL_LIMIT))) {
14418 if (res < 0) {
14419 ast_log(LOG_NOTICE, "Failed to place call for user %s, too many calls\n", p->username);
14420 transmit_response_reliable(p, "480 Temporarily Unavailable (Call limit) ", req);
14421 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14422 p->invitestate = INV_COMPLETED;
14423 }
14424 return 0;
14425 }
14426 gotdest = get_destination(p, NULL);
14427 get_rdnis(p, NULL);
14428 extract_uri(p, req);
14429 build_contact(p);
14430
14431 if (p->rtp) {
14432 ast_rtp_setdtmf(p->rtp, ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833);
14433 ast_rtp_setdtmfcompensate(p->rtp, ast_test_flag(&p->flags[1], SIP_PAGE2_RFC2833_COMPENSATE));
14434 }
14435
14436 if (!replace_id && gotdest) {
14437 if (gotdest == 1 && ast_test_flag(&p->flags[1], SIP_PAGE2_ALLOWOVERLAP))
14438 transmit_response_reliable(p, "484 Address Incomplete", req);
14439 else {
14440 transmit_response_reliable(p, "404 Not Found", req);
14441 ast_log(LOG_NOTICE, "Call from '%s' to extension"
14442 " '%s' rejected because extension not found.\n",
14443 S_OR(p->username, p->peername), p->exten);
14444 }
14445 p->invitestate = INV_COMPLETED;
14446 update_call_counter(p, DEC_CALL_LIMIT);
14447 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14448 return 0;
14449 } else {
14450
14451
14452 if (ast_strlen_zero(p->exten))
14453 ast_string_field_set(p, exten, "s");
14454
14455
14456 make_our_tag(p->tag, sizeof(p->tag));
14457
14458 c = sip_new(p, AST_STATE_DOWN, S_OR(p->username, NULL));
14459 *recount = 1;
14460
14461
14462 build_route(p, req, 0);
14463
14464 if (c) {
14465
14466 ast_channel_lock(c);
14467 }
14468 }
14469 } else {
14470 if (option_debug > 1 && sipdebug) {
14471 if (!ast_test_flag(req, SIP_PKT_IGNORE))
14472 ast_log(LOG_DEBUG, "Got a SIP re-invite for call %s\n", p->callid);
14473 else
14474 ast_log(LOG_DEBUG, "Got a SIP re-transmit of INVITE for call %s\n", p->callid);
14475 }
14476 reinvite = 1;
14477 c = p->owner;
14478 }
14479
14480 if (!ast_test_flag(req, SIP_PKT_IGNORE) && p)
14481 p->lastinvite = seqno;
14482
14483 if (replace_id) {
14484
14485 if (sipdebug && option_debug > 3)
14486 ast_log(LOG_DEBUG, "Sending this call to the invite/replcaes handler %s\n", p->callid);
14487 return handle_invite_replaces(p, req, debug, ast_test_flag(req, SIP_PKT_IGNORE), seqno, sin);
14488 }
14489
14490
14491 if (c) {
14492 switch(c->_state) {
14493 case AST_STATE_DOWN:
14494 if (option_debug > 1)
14495 ast_log(LOG_DEBUG, "%s: New call is still down.... Trying... \n", c->name);
14496 transmit_response(p, "100 Trying", req);
14497 p->invitestate = INV_PROCEEDING;
14498 ast_setstate(c, AST_STATE_RING);
14499 if (strcmp(p->exten, ast_pickup_ext())) {
14500 enum ast_pbx_result res;
14501
14502 res = ast_pbx_start(c);
14503
14504 switch(res) {
14505 case AST_PBX_FAILED:
14506 ast_log(LOG_WARNING, "Failed to start PBX :(\n");
14507 p->invitestate = INV_COMPLETED;
14508 if (ast_test_flag(req, SIP_PKT_IGNORE))
14509 transmit_response(p, "503 Unavailable", req);
14510 else
14511 transmit_response_reliable(p, "503 Unavailable", req);
14512 break;
14513 case AST_PBX_CALL_LIMIT:
14514 ast_log(LOG_WARNING, "Failed to start PBX (call limit reached) \n");
14515 p->invitestate = INV_COMPLETED;
14516 if (ast_test_flag(req, SIP_PKT_IGNORE))
14517 transmit_response(p, "480 Temporarily Unavailable", req);
14518 else
14519 transmit_response_reliable(p, "480 Temporarily Unavailable", req);
14520 break;
14521 case AST_PBX_SUCCESS:
14522
14523 break;
14524 }
14525
14526 if (res) {
14527
14528
14529 ast_mutex_unlock(&c->lock);
14530 ast_mutex_unlock(&p->lock);
14531 ast_hangup(c);
14532 ast_mutex_lock(&p->lock);
14533 c = NULL;
14534 }
14535 } else {
14536 ast_channel_unlock(c);
14537 *nounlock = 1;
14538 if (ast_pickup_call(c)) {
14539 ast_log(LOG_NOTICE, "Nothing to pick up for %s\n", p->callid);
14540 if (ast_test_flag(req, SIP_PKT_IGNORE))
14541 transmit_response(p, "503 Unavailable", req);
14542 else
14543 transmit_response_reliable(p, "503 Unavailable", req);
14544 sip_alreadygone(p);
14545
14546 ast_mutex_unlock(&p->lock);
14547 c->hangupcause = AST_CAUSE_CALL_REJECTED;
14548 } else {
14549 ast_mutex_unlock(&p->lock);
14550 ast_setstate(c, AST_STATE_DOWN);
14551 c->hangupcause = AST_CAUSE_NORMAL_CLEARING;
14552 }
14553 p->invitestate = INV_COMPLETED;
14554 ast_hangup(c);
14555 ast_mutex_lock(&p->lock);
14556 c = NULL;
14557 }
14558 break;
14559 case AST_STATE_RING:
14560 transmit_response(p, "100 Trying", req);
14561 p->invitestate = INV_PROCEEDING;
14562 break;
14563 case AST_STATE_RINGING:
14564 transmit_response(p, "180 Ringing", req);
14565 p->invitestate = INV_PROCEEDING;
14566 break;
14567 case AST_STATE_UP:
14568 if (option_debug > 1)
14569 ast_log(LOG_DEBUG, "%s: This call is UP.... \n", c->name);
14570
14571 transmit_response(p, "100 Trying", req);
14572
14573 if (p->t38.state == T38_PEER_REINVITE) {
14574 struct ast_channel *bridgepeer = NULL;
14575 struct sip_pvt *bridgepvt = NULL;
14576
14577 if ((bridgepeer = ast_bridged_channel(p->owner))) {
14578
14579
14580 if (bridgepeer->tech == &sip_tech || bridgepeer->tech == &sip_tech_info) {
14581 bridgepvt = (struct sip_pvt*)bridgepeer->tech_pvt;
14582 if (bridgepvt->t38.state == T38_DISABLED) {
14583 if (bridgepvt->udptl) {
14584
14585 sip_handle_t38_reinvite(bridgepeer, p, 1);
14586 } else {
14587 ast_log(LOG_WARNING, "Strange... The other side of the bridge don't have udptl struct\n");
14588 ast_mutex_lock(&bridgepvt->lock);
14589 bridgepvt->t38.state = T38_DISABLED;
14590 ast_mutex_unlock(&bridgepvt->lock);
14591 if (option_debug > 1)
14592 ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", bridgepvt->t38.state, bridgepeer->name);
14593 if (ast_test_flag(req, SIP_PKT_IGNORE))
14594 transmit_response(p, "488 Not acceptable here", req);
14595 else
14596 transmit_response_reliable(p, "488 Not acceptable here", req);
14597
14598 }
14599 } else {
14600
14601 transmit_response_with_t38_sdp(p, "200 OK", req, XMIT_CRITICAL);
14602 p->t38.state = T38_ENABLED;
14603 if (option_debug)
14604 ast_log(LOG_DEBUG, "T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
14605 }
14606 } else {
14607
14608 if (ast_test_flag(req, SIP_PKT_IGNORE))
14609 transmit_response(p, "488 Not acceptable here", req);
14610 else
14611 transmit_response_reliable(p, "488 Not acceptable here", req);
14612 p->t38.state = T38_DISABLED;
14613 if (option_debug > 1)
14614 ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
14615
14616 if (!p->lastinvite)
14617 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14618 }
14619 } else {
14620
14621 transmit_response_with_t38_sdp(p, "200 OK", req, XMIT_CRITICAL);
14622 p->t38.state = T38_ENABLED;
14623 if (option_debug)
14624 ast_log(LOG_DEBUG,"T38 state changed to %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
14625 }
14626 } else if (p->t38.state == T38_DISABLED) {
14627 int sendok = TRUE;
14628
14629
14630
14631 struct ast_channel *bridgepeer = NULL;
14632 struct sip_pvt *bridgepvt = NULL;
14633 if ((bridgepeer = ast_bridged_channel(p->owner))) {
14634 if ((bridgepeer->tech == &sip_tech || bridgepeer->tech == &sip_tech_info) && !ast_check_hangup(bridgepeer)) {
14635 bridgepvt = (struct sip_pvt*)bridgepeer->tech_pvt;
14636
14637 if (bridgepvt->t38.state == T38_ENABLED) {
14638 ast_log(LOG_WARNING, "RTP re-invite after T38 session not handled yet !\n");
14639
14640 if (ast_test_flag(req, SIP_PKT_IGNORE))
14641 transmit_response(p, "488 Not Acceptable Here (unsupported)", req);
14642 else
14643 transmit_response_reliable(p, "488 Not Acceptable Here (unsupported)", req);
14644 sendok = FALSE;
14645 }
14646
14647 }
14648 }
14649
14650 if (sendok)
14651
14652 transmit_response_with_sdp(p, "200 OK", req, (reinvite ? XMIT_RELIABLE : (ast_test_flag(req, SIP_PKT_IGNORE) ? XMIT_UNRELIABLE : XMIT_CRITICAL)));
14653 }
14654 p->invitestate = INV_TERMINATED;
14655 break;
14656 default:
14657 ast_log(LOG_WARNING, "Don't know how to handle INVITE in state %d\n", c->_state);
14658 transmit_response(p, "100 Trying", req);
14659 break;
14660 }
14661 } else {
14662 if (p && (p->autokillid == -1)) {
14663 const char *msg;
14664
14665 if (!p->jointcapability)
14666 msg = "488 Not Acceptable Here (codec error)";
14667 else {
14668 ast_log(LOG_NOTICE, "Unable to create/find SIP channel for this INVITE\n");
14669 msg = "503 Unavailable";
14670 }
14671 if (ast_test_flag(req, SIP_PKT_IGNORE))
14672 transmit_response(p, msg, req);
14673 else
14674 transmit_response_reliable(p, msg, req);
14675 p->invitestate = INV_COMPLETED;
14676 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14677 }
14678 }
14679 return res;
14680 }
14681
14682
14683
14684 static int local_attended_transfer(struct sip_pvt *transferer, struct sip_dual *current, struct sip_request *req, int seqno)
14685 {
14686 struct sip_dual target;
14687
14688 int res = 0;
14689 struct sip_pvt *targetcall_pvt;
14690
14691
14692 if (!(targetcall_pvt = get_sip_pvt_byid_locked(transferer->refer->replaces_callid, transferer->refer->replaces_callid_totag,
14693 transferer->refer->replaces_callid_fromtag))) {
14694 if (transferer->refer->localtransfer) {
14695
14696 transmit_response(transferer, "202 Accepted", req);
14697
14698
14699 transmit_notify_with_sipfrag(transferer, seqno, "481 Call leg/transaction does not exist", TRUE);
14700 append_history(transferer, "Xfer", "Refer failed");
14701 ast_clear_flag(&transferer->flags[0], SIP_GOTREFER);
14702 transferer->refer->status = REFER_FAILED;
14703 return -1;
14704 }
14705
14706 if (option_debug > 2)
14707 ast_log(LOG_DEBUG, "SIP attended transfer: Not our call - generating INVITE with replaces\n");
14708 return 0;
14709 }
14710
14711
14712 transmit_response(transferer, "202 Accepted", req);
14713 append_history(transferer, "Xfer", "Refer accepted");
14714 if (!targetcall_pvt->owner) {
14715 if (option_debug > 3)
14716 ast_log(LOG_DEBUG, "SIP attended transfer: Error: No owner of target call\n");
14717
14718 transmit_notify_with_sipfrag(transferer, seqno, "503 Service Unavailable", TRUE);
14719 append_history(transferer, "Xfer", "Refer failed");
14720 ast_clear_flag(&transferer->flags[0], SIP_GOTREFER);
14721 transferer->refer->status = REFER_FAILED;
14722 ast_mutex_unlock(&targetcall_pvt->lock);
14723 ast_channel_unlock(current->chan1);
14724 return -1;
14725 }
14726
14727
14728 target.chan1 = targetcall_pvt->owner;
14729 target.chan2 = ast_bridged_channel(targetcall_pvt->owner);
14730
14731 if (!target.chan2 || !(target.chan2->_state == AST_STATE_UP || target.chan2->_state == AST_STATE_RINGING) ) {
14732
14733 if (option_debug > 3) {
14734 if (target.chan2)
14735 ast_log(LOG_DEBUG, "SIP attended transfer: Error: Wrong state of target call: %s\n", ast_state2str(target.chan2->_state));
14736 else if (target.chan1->_state != AST_STATE_RING)
14737 ast_log(LOG_DEBUG, "SIP attended transfer: Error: No target channel\n");
14738 else
14739 ast_log(LOG_DEBUG, "SIP attended transfer: Attempting transfer in ringing state\n");
14740 }
14741 }
14742
14743
14744 if (option_debug > 3 && sipdebug) {
14745 if (current->chan2)
14746 ast_log(LOG_DEBUG, "SIP attended transfer: trying to bridge %s and %s\n", target.chan1->name, current->chan2->name);
14747 else
14748 ast_log(LOG_DEBUG, "SIP attended transfer: trying to make %s take over (masq) %s\n", target.chan1->name, current->chan1->name);
14749 }
14750
14751 ast_set_flag(&transferer->flags[0], SIP_DEFER_BYE_ON_TRANSFER);
14752
14753
14754 res = attempt_transfer(current, &target);
14755 ast_mutex_unlock(&targetcall_pvt->lock);
14756 if (res) {
14757
14758 transmit_notify_with_sipfrag(transferer, seqno, "486 Busy Here", TRUE);
14759 append_history(transferer, "Xfer", "Refer failed");
14760 transferer->refer->status = REFER_FAILED;
14761 if (targetcall_pvt->owner)
14762 ast_channel_unlock(targetcall_pvt->owner);
14763
14764 if (res != -2)
14765 ast_hangup(transferer->owner);
14766 else
14767 ast_clear_flag(&transferer->flags[0], SIP_DEFER_BYE_ON_TRANSFER);
14768 } else {
14769
14770
14771
14772 transmit_notify_with_sipfrag(transferer, seqno, "200 OK", TRUE);
14773 append_history(transferer, "Xfer", "Refer succeeded");
14774 transferer->refer->status = REFER_200OK;
14775 if (targetcall_pvt->owner) {
14776 if (option_debug)
14777 ast_log(LOG_DEBUG, "SIP attended transfer: Unlocking channel %s\n", targetcall_pvt->owner->name);
14778 ast_channel_unlock(targetcall_pvt->owner);
14779 }
14780 }
14781 return 1;
14782 }
14783
14784
14785
14786
14787
14788
14789
14790
14791
14792
14793
14794
14795
14796
14797
14798
14799
14800
14801
14802
14803
14804
14805
14806
14807
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 static int handle_request_refer(struct sip_pvt *p, struct sip_request *req, int debug, int ignore, int seqno, int *nounlock)
14849 {
14850 struct sip_dual current;
14851
14852
14853 int res = 0;
14854
14855 if (ast_test_flag(req, SIP_PKT_DEBUG))
14856 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");
14857
14858 if (!p->owner) {
14859
14860
14861 if (option_debug > 2)
14862 ast_log(LOG_DEBUG, "Call %s: Declined REFER, outside of dialog...\n", p->callid);
14863 transmit_response(p, "603 Declined (No dialog)", req);
14864 if (!ast_test_flag(req, SIP_PKT_IGNORE)) {
14865 append_history(p, "Xfer", "Refer failed. Outside of dialog.");
14866 sip_alreadygone(p);
14867 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
14868 }
14869 return 0;
14870 }
14871
14872
14873
14874 if (p->allowtransfer == TRANSFER_CLOSED ) {
14875
14876 transmit_response(p, "603 Declined (policy)", req);
14877 append_history(p, "Xfer", "Refer failed. Allowtransfer == closed.");
14878
14879 return 0;
14880 }
14881
14882 if(!ignore && ast_test_flag(&p->flags[0], SIP_GOTREFER)) {
14883
14884 transmit_response(p, "491 Request pending", req);
14885 append_history(p, "Xfer", "Refer failed. Request pending.");
14886 return 0;
14887 }
14888
14889
14890 if (!p->refer && !sip_refer_allocate(p)) {
14891 transmit_response(p, "500 Internal Server Error", req);
14892 append_history(p, "Xfer", "Refer failed. Memory allocation error.");
14893 return -3;
14894 }
14895
14896 res = get_refer_info(p, req);
14897
14898 p->refer->status = REFER_SENT;
14899
14900 if (res != 0) {
14901 switch (res) {
14902 case -2:
14903 transmit_response(p, "400 Bad Request (Refer-to missing)", req);
14904 append_history(p, "Xfer", "Refer failed. Refer-to missing.");
14905 if (ast_test_flag(req, SIP_PKT_DEBUG) && option_debug)
14906 ast_log(LOG_DEBUG, "SIP transfer to black hole can't be handled (no refer-to: )\n");
14907 break;
14908 case -3:
14909 transmit_response(p, "603 Declined (Non sip: uri)", req);
14910 append_history(p, "Xfer", "Refer failed. Non SIP uri");
14911 if (ast_test_flag(req, SIP_PKT_DEBUG) && option_debug)
14912 ast_log(LOG_DEBUG, "SIP transfer to non-SIP uri denied\n");
14913 break;
14914 default:
14915
14916 transmit_response(p, "202 Accepted", req);
14917 append_history(p, "Xfer", "Refer failed. Bad extension.");
14918 transmit_notify_with_sipfrag(p, seqno, "404 Not found", TRUE);
14919 ast_clear_flag(&p->flags[0], SIP_GOTREFER);
14920 if (ast_test_flag(req, SIP_PKT_DEBUG) && option_debug)
14921 ast_log(LOG_DEBUG, "SIP transfer to bad extension: %s\n", p->refer->refer_to);
14922 break;
14923 }
14924 return 0;
14925 }
14926 if (ast_strlen_zero(p->context))
14927 ast_string_field_set(p, context, default_context);
14928
14929
14930 if (allow_external_domains && check_sip_domain(p->refer->refer_to_domain, NULL, 0)) {
14931 p->refer->localtransfer = 1;
14932 if (sipdebug && option_debug > 2)
14933 ast_log(LOG_DEBUG, "This SIP transfer is local : %s\n", p->refer->refer_to_domain);
14934 } else if (AST_LIST_EMPTY(&domain_list) || check_sip_domain(p->refer->refer_to_domain, NULL, 0)) {
14935
14936 p->refer->localtransfer = 1;
14937 } else if (sipdebug && option_debug > 2)
14938 ast_log(LOG_DEBUG, "This SIP transfer is to a remote SIP extension (remote domain %s)\n", p->refer->refer_to_domain);
14939
14940
14941
14942 if (ignore)
14943 return res;
14944
14945
14946
14947
14948
14949
14950
14951
14952
14953
14954
14955
14956
14957
14958
14959
14960
14961
14962
14963
14964
14965
14966
14967
14968
14969
14970
14971 current.chan1 = p->owner;
14972
14973
14974 current.chan2 = ast_bridged_channel(current.chan1);
14975
14976 if (sipdebug && option_debug > 2)
14977 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>");
14978
14979 if (!current.chan2 && !p->refer->attendedtransfer) {
14980
14981
14982
14983 if (sipdebug && option_debug > 2)
14984 ast_log(LOG_DEBUG,"Refused SIP transfer on non-bridged channel.\n");
14985 p->refer->status = REFER_FAILED;
14986 append_history(p, "Xfer", "Refer failed. Non-bridged channel.");
14987 transmit_response(p, "603 Declined", req);
14988 return -1;
14989 }
14990
14991 if (current.chan2) {
14992 if (sipdebug && option_debug > 3)
14993 ast_log(LOG_DEBUG, "Got SIP transfer, applying to bridged peer '%s'\n", current.chan2->name);
14994
14995 ast_queue_control(current.chan1, AST_CONTROL_UNHOLD);
14996 }
14997
14998 ast_set_flag(&p->flags[0], SIP_GOTREFER);
14999
15000
15001 if (p->refer->attendedtransfer) {
15002 if ((res = local_attended_transfer(p, ¤t, req, seqno)))
15003 return res;
15004
15005 if (sipdebug && option_debug > 3)
15006 ast_log(LOG_DEBUG, "SIP attended transfer: Still not our call - generating INVITE with replaces\n");
15007
15008 }
15009
15010
15011
15012 if (p->refer->localtransfer && !strcmp(p->refer->refer_to, ast_parking_ext())) {
15013
15014 *nounlock = 1;
15015 ast_channel_unlock(current.chan1);
15016 copy_request(¤t.req, req);
15017 ast_clear_flag(&p->flags[0], SIP_GOTREFER);
15018 p->refer->status = REFER_200OK;
15019 append_history(p, "Xfer", "REFER to call parking.");
15020 if (sipdebug && option_debug > 3)
15021 ast_log(LOG_DEBUG, "SIP transfer to parking: trying to park %s. Parked by %s\n", current.chan2->name, current.chan1->name);
15022 sip_park(current.chan2, current.chan1, req, seqno);
15023 return res;
15024 }
15025
15026
15027 transmit_response(p, "202 Accepted", req);
15028
15029 if (current.chan1 && current.chan2) {
15030 if (option_debug > 2)
15031 ast_log(LOG_DEBUG, "chan1->name: %s\n", current.chan1->name);
15032 pbx_builtin_setvar_helper(current.chan1, "BLINDTRANSFER", current.chan2->name);
15033 }
15034 if (current.chan2) {
15035 pbx_builtin_setvar_helper(current.chan2, "BLINDTRANSFER", current.chan1->name);
15036 pbx_builtin_setvar_helper(current.chan2, "SIPDOMAIN", p->refer->refer_to_domain);
15037 pbx_builtin_setvar_helper(current.chan2, "SIPTRANSFER", "yes");
15038
15039 pbx_builtin_setvar_helper(current.chan2, "_SIPTRANSFER", "yes");
15040
15041 if (p->refer->referred_by)
15042 pbx_builtin_setvar_helper(current.chan2, "_SIPTRANSFER_REFERER", p->refer->referred_by);
15043 }
15044
15045 if (p->refer->replaces_callid && !ast_strlen_zero(p->refer->replaces_callid)) {
15046 char tempheader[SIPBUFSIZE];
15047 snprintf(tempheader, sizeof(tempheader), "%s%s%s%s%s", p->refer->replaces_callid,
15048 p->refer->replaces_callid_totag ? ";to-tag=" : "",
15049 p->refer->replaces_callid_totag,
15050 p->refer->replaces_callid_fromtag ? ";from-tag=" : "",
15051 p->refer->replaces_callid_fromtag);
15052 if (current.chan2)
15053 pbx_builtin_setvar_helper(current.chan2, "_SIPTRANSFER_REPLACES", tempheader);
15054 }
15055
15056
15057 *nounlock = 1;
15058 ast_channel_unlock(current.chan1);
15059
15060
15061
15062
15063 if (!p->refer->attendedtransfer)
15064 transmit_notify_with_sipfrag(p, seqno, "183 Ringing", FALSE);
15065
15066
15067
15068
15069
15070 if (!current.chan2) {
15071
15072
15073
15074
15075
15076
15077
15078 p->refer->status = REFER_FAILED;
15079 transmit_notify_with_sipfrag(p, seqno, "503 Service Unavailable (can't handle one-legged xfers)", TRUE);
15080 ast_clear_flag(&p->flags[0], SIP_GOTREFER);
15081 append_history(p, "Xfer", "Refer failed (only bridged calls).");
15082 return -1;
15083 }
15084 ast_set_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER);
15085
15086
15087
15088 res = ast_async_goto(current.chan2, p->refer->refer_to_context, p->refer->refer_to, 1);
15089
15090 if (!res) {
15091
15092 if (option_debug > 2)
15093 ast_log(LOG_DEBUG, "%s transfer succeeded. Telling transferer.\n", p->refer->attendedtransfer? "Attended" : "Blind");
15094 transmit_notify_with_sipfrag(p, seqno, "200 Ok", TRUE);
15095 if (p->refer->localtransfer)
15096 p->refer->status = REFER_200OK;
15097 if (p->owner)
15098 p->owner->hangupcause = AST_CAUSE_NORMAL_CLEARING;
15099 append_history(p, "Xfer", "Refer succeeded.");
15100 ast_clear_flag(&p->flags[0], SIP_GOTREFER);
15101
15102
15103 res = 0;
15104 } else {
15105 ast_clear_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER);
15106 if (option_debug > 2)
15107 ast_log(LOG_DEBUG, "%s transfer failed. Resuming original call.\n", p->refer->attendedtransfer? "Attended" : "Blind");
15108 append_history(p, "Xfer", "Refer failed.");
15109
15110 p->refer->status = REFER_FAILED;
15111 transmit_notify_with_sipfrag(p, seqno, "503 Service Unavailable", TRUE);
15112 ast_clear_flag(&p->flags[0], SIP_GOTREFER);
15113 res = -1;
15114 }
15115 return res;
15116 }
15117
15118
15119 static int handle_request_cancel(struct sip_pvt *p, struct sip_request *req)
15120 {
15121
15122 check_via(p, req);
15123 sip_alreadygone(p);
15124
15125
15126
15127
15128
15129
15130 if (p->invitestate == INV_TERMINATED)
15131 __sip_pretend_ack(p);
15132 else
15133 p->invitestate = INV_CANCELLED;
15134
15135 if (p->owner && p->owner->_state == AST_STATE_UP) {
15136
15137 transmit_response(p, "200 OK", req);
15138 if (option_debug)
15139 ast_log(LOG_DEBUG, "Got CANCEL on an answered call. Ignoring... \n");
15140 return 0;
15141 }
15142
15143 if (ast_test_flag(&p->flags[0], SIP_INC_COUNT) || ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD))
15144 update_call_counter(p, DEC_CALL_LIMIT);
15145
15146 stop_media_flows(p);
15147 if (p->owner)
15148 ast_queue_hangup(p->owner);
15149 else
15150 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
15151 if (p->initreq.len > 0) {
15152 transmit_response_reliable(p, "487 Request Terminated", &p->initreq);
15153 transmit_response(p, "200 OK", req);
15154 return 1;
15155 } else {
15156 transmit_response(p, "481 Call Leg Does Not Exist", req);
15157 return 0;
15158 }
15159 }
15160
15161 static int acf_channel_read(struct ast_channel *chan, char *funcname, char *preparse, char *buf, size_t buflen)
15162 {
15163 struct ast_rtp_quality qos;
15164 struct sip_pvt *p = chan->tech_pvt;
15165 char *all = "", *parse = ast_strdupa(preparse);
15166 AST_DECLARE_APP_ARGS(args,
15167 AST_APP_ARG(param);
15168 AST_APP_ARG(type);
15169 AST_APP_ARG(field);
15170 );
15171 AST_STANDARD_APP_ARGS(args, parse);
15172
15173
15174 if (chan->tech != &sip_tech && chan->tech != &sip_tech_info) {
15175 ast_log(LOG_ERROR, "Cannot call %s on a non-SIP channel\n", funcname);
15176 return 0;
15177 }
15178
15179 if (strcasecmp(args.param, "rtpqos"))
15180 return 0;
15181
15182
15183 if (ast_strlen_zero(args.type))
15184 args.type = "audio";
15185 if (ast_strlen_zero(args.field))
15186 args.field = "all";
15187
15188 memset(buf, 0, buflen);
15189 memset(&qos, 0, sizeof(qos));
15190
15191 if (strcasecmp(args.type, "AUDIO") == 0) {
15192 all = ast_rtp_get_quality(p->rtp, &qos);
15193 } else if (strcasecmp(args.type, "VIDEO") == 0) {
15194 all = ast_rtp_get_quality(p->vrtp, &qos);
15195 }
15196
15197 if (strcasecmp(args.field, "local_ssrc") == 0)
15198 snprintf(buf, buflen, "%u", qos.local_ssrc);
15199 else if (strcasecmp(args.field, "local_lostpackets") == 0)
15200 snprintf(buf, buflen, "%u", qos.local_lostpackets);
15201 else if (strcasecmp(args.field, "local_jitter") == 0)
15202 snprintf(buf, buflen, "%.0lf", qos.local_jitter * 1000.0);
15203 else if (strcasecmp(args.field, "local_count") == 0)
15204 snprintf(buf, buflen, "%u", qos.local_count);
15205 else if (strcasecmp(args.field, "remote_ssrc") == 0)
15206 snprintf(buf, buflen, "%u", qos.remote_ssrc);
15207 else if (strcasecmp(args.field, "remote_lostpackets") == 0)
15208 snprintf(buf, buflen, "%u", qos.remote_lostpackets);
15209 else if (strcasecmp(args.field, "remote_jitter") == 0)
15210 snprintf(buf, buflen, "%.0lf", qos.remote_jitter * 1000.0);
15211 else if (strcasecmp(args.field, "remote_count") == 0)
15212 snprintf(buf, buflen, "%u", qos.remote_count);
15213 else if (strcasecmp(args.field, "rtt") == 0)
15214 snprintf(buf, buflen, "%.0lf", qos.rtt * 1000.0);
15215 else if (strcasecmp(args.field, "all") == 0)
15216 ast_copy_string(buf, all, buflen);
15217 else {
15218 ast_log(LOG_WARNING, "Unrecognized argument '%s' to %s\n", preparse, funcname);
15219 return -1;
15220 }
15221 return 0;
15222 }
15223
15224
15225 static int handle_request_bye(struct sip_pvt *p, struct sip_request *req)
15226 {
15227 struct ast_channel *c=NULL;
15228 int res;
15229 struct ast_channel *bridged_to;
15230
15231
15232 if (p->pendinginvite && !ast_test_flag(&p->flags[0], SIP_OUTGOING) && !ast_test_flag(req, SIP_PKT_IGNORE) && !p->owner)
15233 transmit_response_reliable(p, "487 Request Terminated", &p->initreq);
15234
15235 p->invitestate = INV_TERMINATED;
15236
15237 copy_request(&p->initreq, req);
15238 check_via(p, req);
15239 sip_alreadygone(p);
15240
15241
15242 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY) || p->owner) {
15243 char *audioqos, *videoqos;
15244 if (p->rtp) {
15245 audioqos = ast_rtp_get_quality(p->rtp, NULL);
15246 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
15247 append_history(p, "RTCPaudio", "Quality:%s", audioqos);
15248 if (p->owner)
15249 pbx_builtin_setvar_helper(p->owner, "RTPAUDIOQOS", audioqos);
15250 }
15251 if (p->vrtp) {
15252 videoqos = ast_rtp_get_quality(p->vrtp, NULL);
15253 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
15254 append_history(p, "RTCPvideo", "Quality:%s", videoqos);
15255 if (p->owner)
15256 pbx_builtin_setvar_helper(p->owner, "RTPVIDEOQOS", videoqos);
15257 }
15258 }
15259
15260 stop_media_flows(p);
15261
15262 if (!ast_strlen_zero(get_header(req, "Also"))) {
15263 ast_log(LOG_NOTICE, "Client '%s' using deprecated BYE/Also transfer method. Ask vendor to support REFER instead\n",
15264 ast_inet_ntoa(p->recv.sin_addr));
15265 if (ast_strlen_zero(p->context))
15266 ast_string_field_set(p, context, default_context);
15267 res = get_also_info(p, req);
15268 if (!res) {
15269 c = p->owner;
15270 if (c) {
15271 bridged_to = ast_bridged_channel(c);
15272 if (bridged_to) {
15273
15274 ast_queue_control(c, AST_CONTROL_UNHOLD);
15275 ast_async_goto(bridged_to, p->context, p->refer->refer_to,1);
15276 } else
15277 ast_queue_hangup(p->owner);
15278 }
15279 } else {
15280 ast_log(LOG_WARNING, "Invalid transfer information from '%s'\n", ast_inet_ntoa(p->recv.sin_addr));
15281 if (p->owner)
15282 ast_queue_hangup(p->owner);
15283 }
15284 } else if (p->owner) {
15285 ast_queue_hangup(p->owner);
15286 if (option_debug > 2)
15287 ast_log(LOG_DEBUG, "Received bye, issuing owner hangup\n");
15288 } else {
15289 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
15290 if (option_debug > 2)
15291 ast_log(LOG_DEBUG, "Received bye, no owner, selfdestruct soon.\n");
15292 }
15293 transmit_response(p, "200 OK", req);
15294
15295 return 1;
15296 }
15297
15298
15299 static int handle_request_message(struct sip_pvt *p, struct sip_request *req)
15300 {
15301 if (!ast_test_flag(req, SIP_PKT_IGNORE)) {
15302 if (ast_test_flag(req, SIP_PKT_DEBUG))
15303 ast_verbose("Receiving message!\n");
15304 receive_message(p, req);
15305 } else
15306 transmit_response(p, "202 Accepted", req);
15307 return 1;
15308 }
15309
15310
15311 static int handle_request_subscribe(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int seqno, char *e)
15312 {
15313 int gotdest;
15314 int res = 0;
15315 int firststate = AST_EXTENSION_REMOVED;
15316 struct sip_peer *authpeer = NULL;
15317 const char *eventheader = get_header(req, "Event");
15318 const char *accept = get_header(req, "Accept");
15319 int resubscribe = (p->subscribed != NONE);
15320 char *temp, *event;
15321
15322 if (p->initreq.headers) {
15323
15324 if (p->initreq.method != SIP_SUBSCRIBE) {
15325
15326
15327 transmit_response(p, "403 Forbidden (within dialog)", req);
15328
15329 if (option_debug)
15330 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);
15331 return 0;
15332 } else if (ast_test_flag(req, SIP_PKT_DEBUG)) {
15333 if (option_debug) {
15334 if (resubscribe)
15335 ast_log(LOG_DEBUG, "Got a re-subscribe on existing subscription %s\n", p->callid);
15336 else
15337 ast_log(LOG_DEBUG, "Got a new subscription %s (possibly with auth)\n", p->callid);
15338 }
15339 }
15340 }
15341
15342
15343
15344
15345 if (!global_allowsubscribe) {
15346 transmit_response(p, "403 Forbidden (policy)", req);
15347 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15348 return 0;
15349 }
15350
15351 if (!ast_test_flag(req, SIP_PKT_IGNORE) && !resubscribe) {
15352 const char *to = get_header(req, "To");
15353 char totag[128];
15354
15355
15356 if (!ast_strlen_zero(to) && gettag(req, "To", totag, sizeof(totag))) {
15357 if (ast_test_flag(req, SIP_PKT_DEBUG))
15358 ast_verbose("Received resubscription for a dialog we no longer know about. Telling remote side to subscribe again.\n");
15359 transmit_response(p, "481 Subscription does not exist", req);
15360 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15361 return 0;
15362 }
15363
15364
15365 if (ast_test_flag(req, SIP_PKT_DEBUG))
15366 ast_verbose("Creating new subscription\n");
15367
15368 copy_request(&p->initreq, req);
15369 check_via(p, req);
15370 } else if (ast_test_flag(req, SIP_PKT_DEBUG) && ast_test_flag(req, SIP_PKT_IGNORE))
15371 ast_verbose("Ignoring this SUBSCRIBE request\n");
15372
15373
15374 if (ast_strlen_zero(eventheader)) {
15375 transmit_response(p, "489 Bad Event", req);
15376 if (option_debug > 1)
15377 ast_log(LOG_DEBUG, "Received SIP subscribe for unknown event package: <none>\n");
15378 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15379 return 0;
15380 }
15381
15382 if ( (strchr(eventheader, ';'))) {
15383 event = ast_strdupa(eventheader);
15384 temp = strchr(event, ';');
15385 *temp = '\0';
15386
15387 } else
15388 event = (char *) eventheader;
15389
15390
15391 res = check_user_full(p, req, SIP_SUBSCRIBE, e, 0, sin, &authpeer);
15392
15393 if (res == AUTH_CHALLENGE_SENT) {
15394 if (authpeer)
15395 ASTOBJ_UNREF(authpeer, sip_destroy_peer);
15396 return 0;
15397 }
15398 if (res < 0) {
15399 if (res == AUTH_FAKE_AUTH) {
15400 ast_log(LOG_NOTICE, "Sending fake auth rejection for user %s\n", get_header(req, "From"));
15401 transmit_fake_auth_response(p, SIP_SUBSCRIBE, req, XMIT_UNRELIABLE);
15402 } else {
15403 ast_log(LOG_NOTICE, "Failed to authenticate user %s for SUBSCRIBE\n", get_header(req, "From"));
15404 transmit_response_reliable(p, "403 Forbidden", req);
15405 }
15406 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15407 if (authpeer)
15408 ASTOBJ_UNREF(authpeer, sip_destroy_peer);
15409 return 0;
15410 }
15411
15412
15413 if (!ast_test_flag(&p->flags[1], SIP_PAGE2_ALLOWSUBSCRIBE)) {
15414 transmit_response(p, "403 Forbidden (policy)", req);
15415 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15416 if (authpeer)
15417 ASTOBJ_UNREF(authpeer, sip_destroy_peer);
15418 return 0;
15419 }
15420
15421
15422 gotdest = get_destination(p, NULL);
15423
15424
15425 parse_ok_contact(p, req);
15426
15427 build_contact(p);
15428 if (strcmp(event, "message-summary") && gotdest) {
15429 transmit_response(p, "404 Not Found", req);
15430 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15431 if (authpeer)
15432 ASTOBJ_UNREF(authpeer, sip_destroy_peer);
15433 return 0;
15434 }
15435
15436
15437 if (ast_strlen_zero(p->tag))
15438 make_our_tag(p->tag, sizeof(p->tag));
15439
15440 if (!strcmp(event, "presence") || !strcmp(event, "dialog")) {
15441 if (authpeer)
15442 ASTOBJ_UNREF(authpeer, sip_destroy_peer);
15443
15444
15445
15446
15447
15448 if (strstr(p->useragent, "Polycom")) {
15449 p->subscribed = XPIDF_XML;
15450 } else if (strstr(accept, "application/pidf+xml")) {
15451 p->subscribed = PIDF_XML;
15452 } else if (strstr(accept, "application/dialog-info+xml")) {
15453 p->subscribed = DIALOG_INFO_XML;
15454
15455 } else if (strstr(accept, "application/cpim-pidf+xml")) {
15456 p->subscribed = CPIM_PIDF_XML;
15457 } else if (strstr(accept, "application/xpidf+xml")) {
15458 p->subscribed = XPIDF_XML;
15459 } else if (ast_strlen_zero(accept)) {
15460 if (p->subscribed == NONE) {
15461 transmit_response(p, "489 Bad Event", req);
15462
15463 ast_log(LOG_WARNING,"SUBSCRIBE failure: no Accept header: pvt: stateid: %d, laststate: %d, dialogver: %d, subscribecont: '%s', subscribeuri: '%s'\n",
15464 p->stateid, p->laststate, p->dialogver, p->subscribecontext, p->subscribeuri);
15465 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15466 return 0;
15467 }
15468
15469
15470 } else {
15471
15472 char mybuf[200];
15473 snprintf(mybuf,sizeof(mybuf),"489 Bad Event (format %s)", accept);
15474 transmit_response(p, mybuf, req);
15475
15476 ast_log(LOG_WARNING,"SUBSCRIBE failure: unrecognized format: '%s' pvt: subscribed: %d, stateid: %d, laststate: %d, dialogver: %d, subscribecont: '%s', subscribeuri: '%s'\n",
15477 accept, (int)p->subscribed, p->stateid, p->laststate, p->dialogver, p->subscribecontext, p->subscribeuri);
15478 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15479 return 0;
15480 }
15481 } else if (!strcmp(event, "message-summary")) {
15482 if (!ast_strlen_zero(accept) && strcmp(accept, "application/simple-message-summary")) {
15483
15484 transmit_response(p, "406 Not Acceptable", req);
15485 if (option_debug > 1)
15486 ast_log(LOG_DEBUG, "Received SIP mailbox subscription for unknown format: %s\n", accept);
15487 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15488 if (authpeer)
15489 ASTOBJ_UNREF(authpeer, sip_destroy_peer);
15490 return 0;
15491 }
15492
15493
15494
15495
15496
15497 if (!authpeer || ast_strlen_zero(authpeer->mailbox)) {
15498 transmit_response(p, "404 Not found (no mailbox)", req);
15499 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15500 ast_log(LOG_NOTICE, "Received SIP subscribe for peer without mailbox: %s\n", authpeer->name);
15501 if (authpeer)
15502 ASTOBJ_UNREF(authpeer, sip_destroy_peer);
15503 return 0;
15504 }
15505
15506 p->subscribed = MWI_NOTIFICATION;
15507 if (authpeer->mwipvt && authpeer->mwipvt != p)
15508
15509 sip_destroy(authpeer->mwipvt);
15510 authpeer->mwipvt = p;
15511 p->relatedpeer = ASTOBJ_REF(authpeer);
15512 } else {
15513 transmit_response(p, "489 Bad Event", req);
15514 if (option_debug > 1)
15515 ast_log(LOG_DEBUG, "Received SIP subscribe for unknown event package: %s\n", event);
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 if (p->subscribed != MWI_NOTIFICATION && !resubscribe) {
15523 if (p->stateid > -1)
15524 ast_extension_state_del(p->stateid, cb_extensionstate);
15525 p->stateid = ast_extension_state_add(p->context, p->exten, cb_extensionstate, p);
15526 }
15527
15528 if (!ast_test_flag(req, SIP_PKT_IGNORE) && p)
15529 p->lastinvite = seqno;
15530 if (p && !ast_test_flag(&p->flags[0], SIP_NEEDDESTROY)) {
15531 p->expiry = atoi(get_header(req, "Expires"));
15532
15533
15534 if (p->expiry > max_expiry)
15535 p->expiry = max_expiry;
15536 if (p->expiry < min_expiry && p->expiry > 0)
15537 p->expiry = min_expiry;
15538
15539 if (sipdebug || option_debug > 1) {
15540 if (p->subscribed == MWI_NOTIFICATION && p->relatedpeer)
15541 ast_log(LOG_DEBUG, "Adding subscription for mailbox notification - peer %s Mailbox %s\n", p->relatedpeer->name, p->relatedpeer->mailbox);
15542 else
15543 ast_log(LOG_DEBUG, "Adding subscription for extension %s context %s for peer %s\n", p->exten, p->context, p->username);
15544 }
15545 if (p->autokillid > -1 && sip_cancel_destroy(p))
15546 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
15547 if (p->expiry > 0)
15548 sip_scheddestroy(p, (p->expiry + 10) * 1000);
15549
15550 if (p->subscribed == MWI_NOTIFICATION) {
15551 transmit_response(p, "200 OK", req);
15552 if (p->relatedpeer) {
15553 ASTOBJ_WRLOCK(p->relatedpeer);
15554 sip_send_mwi_to_peer(p->relatedpeer);
15555 ASTOBJ_UNLOCK(p->relatedpeer);
15556 }
15557 } else {
15558 struct sip_pvt *p_old;
15559
15560 if ((firststate = ast_extension_state(NULL, p->context, p->exten)) < 0) {
15561
15562 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));
15563 transmit_response(p, "404 Not found", req);
15564 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15565 return 0;
15566 }
15567
15568 transmit_response(p, "200 OK", req);
15569 transmit_state_notify(p, firststate, 1, FALSE);
15570 append_history(p, "Subscribestatus", "%s", ast_extension_state2str(firststate));
15571
15572 ast_string_field_build(p, subscribeuri, "%s@%s", p->exten, p->context);
15573
15574
15575
15576
15577
15578
15579 ast_mutex_lock(&iflock);
15580 for (p_old = iflist; p_old; p_old = p_old->next) {
15581 if (p_old == p)
15582 continue;
15583 if (p_old->initreq.method != SIP_SUBSCRIBE)
15584 continue;
15585 if (p_old->subscribed == NONE)
15586 continue;
15587 ast_mutex_lock(&p_old->lock);
15588 if (!strcmp(p_old->username, p->username)) {
15589 if (!strcmp(p_old->exten, p->exten) &&
15590 !strcmp(p_old->context, p->context)) {
15591 ast_set_flag(&p_old->flags[0], SIP_NEEDDESTROY);
15592 ast_mutex_unlock(&p_old->lock);
15593 break;
15594 }
15595 }
15596 ast_mutex_unlock(&p_old->lock);
15597 }
15598 ast_mutex_unlock(&iflock);
15599 }
15600 if (!p->expiry)
15601 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15602 }
15603 return 1;
15604 }
15605
15606
15607 static int handle_request_register(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, char *e)
15608 {
15609 enum check_auth_result res;
15610
15611
15612 if (ast_test_flag(req, SIP_PKT_DEBUG))
15613 ast_verbose("Using latest REGISTER request as basis request\n");
15614 copy_request(&p->initreq, req);
15615 check_via(p, req);
15616 if ((res = register_verify(p, sin, req, e)) < 0) {
15617 const char *reason;
15618
15619 switch (res) {
15620 case AUTH_SECRET_FAILED:
15621 reason = "Wrong password";
15622 break;
15623 case AUTH_USERNAME_MISMATCH:
15624 reason = "Username/auth name mismatch";
15625 break;
15626 case AUTH_NOT_FOUND:
15627 reason = "No matching peer found";
15628 break;
15629 case AUTH_UNKNOWN_DOMAIN:
15630 reason = "Not a local domain";
15631 break;
15632 case AUTH_PEER_NOT_DYNAMIC:
15633 reason = "Peer is not supposed to register";
15634 break;
15635 case AUTH_ACL_FAILED:
15636 reason = "Device does not match ACL";
15637 break;
15638 default:
15639 reason = "Unknown failure";
15640 break;
15641 }
15642 ast_log(LOG_NOTICE, "Registration from '%s' failed for '%s' - %s\n",
15643 get_header(req, "To"), ast_inet_ntoa(sin->sin_addr),
15644 reason);
15645 append_history(p, "RegRequest", "Failed : Account %s : %s", get_header(req, "To"), reason);
15646 } else
15647 append_history(p, "RegRequest", "Succeeded : Account %s", get_header(req, "To"));
15648
15649 if (res < 1) {
15650
15651
15652 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
15653 }
15654 return res;
15655 }
15656
15657
15658
15659
15660 static int handle_request(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int *recount, int *nounlock)
15661 {
15662
15663
15664 const char *cmd;
15665 const char *cseq;
15666 const char *useragent;
15667 int seqno;
15668 int len;
15669 int ignore = FALSE;
15670 int respid;
15671 int res = 0;
15672 int debug = sip_debug_test_pvt(p);
15673 char *e;
15674 int error = 0;
15675
15676
15677 cseq = get_header(req, "Cseq");
15678 cmd = req->header[0];
15679
15680
15681 if (ast_strlen_zero(cmd) || ast_strlen_zero(cseq)) {
15682 ast_log(LOG_ERROR, "Missing Cseq. Dropping this SIP message, it's incomplete.\n");
15683 error = 1;
15684 }
15685 if (!error && sscanf(cseq, "%d%n", &seqno, &len) != 1) {
15686 ast_log(LOG_ERROR, "No seqno in '%s'. Dropping incomplete message.\n", cmd);
15687 error = 1;
15688 }
15689 if (error) {
15690 if (!p->initreq.headers)
15691 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15692 return -1;
15693 }
15694
15695
15696 cmd = req->rlPart1;
15697 e = req->rlPart2;
15698
15699
15700 useragent = get_header(req, "User-Agent");
15701 if (!ast_strlen_zero(useragent))
15702 ast_string_field_set(p, useragent, useragent);
15703
15704
15705 if (req->method == SIP_RESPONSE) {
15706
15707 if (!p->initreq.headers) {
15708 if (option_debug)
15709 ast_log(LOG_DEBUG, "That's odd... Got a response on a call we dont know about. Cseq %d Cmd %s\n", seqno, cmd);
15710 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15711 return 0;
15712 } else if (p->ocseq && (p->ocseq < seqno) && (seqno != p->lastnoninvite)) {
15713 if (option_debug)
15714 ast_log(LOG_DEBUG, "Ignoring out of order response %d (expecting %d)\n", seqno, p->ocseq);
15715 return -1;
15716 } else if (p->ocseq && (p->ocseq != seqno) && (seqno != p->lastnoninvite)) {
15717
15718
15719 ignore = TRUE;
15720 ast_set_flag(req, SIP_PKT_IGNORE);
15721 ast_set_flag(req, SIP_PKT_IGNORE_RESP);
15722 append_history(p, "Ignore", "Ignoring this retransmit\n");
15723 } else if (e) {
15724 e = ast_skip_blanks(e);
15725 if (sscanf(e, "%d %n", &respid, &len) != 1) {
15726 ast_log(LOG_WARNING, "Invalid response: '%s'\n", e);
15727 } else {
15728 if (respid <= 0) {
15729 ast_log(LOG_WARNING, "Invalid SIP response code: '%d'\n", respid);
15730 return 0;
15731 }
15732
15733 if ((respid == 200) || ((respid >= 300) && (respid <= 399)))
15734 extract_uri(p, req);
15735 handle_response(p, respid, e + len, req, ignore, seqno);
15736 }
15737 }
15738 return 0;
15739 }
15740
15741
15742
15743
15744
15745 p->method = req->method;
15746 if (option_debug > 3)
15747 ast_log(LOG_DEBUG, "**** Received %s (%d) - Command in SIP %s\n", sip_methods[p->method].text, sip_methods[p->method].id, cmd);
15748
15749 if (p->icseq && (p->icseq > seqno) ) {
15750 if (p->pendinginvite && seqno == p->pendinginvite && (req->method == SIP_ACK || req->method == SIP_CANCEL)) {
15751 if (option_debug > 2)
15752 ast_log(LOG_DEBUG, "Got CANCEL or ACK on INVITE with transactions in between.\n");
15753 } else {
15754 if (option_debug)
15755 ast_log(LOG_DEBUG, "Ignoring too old SIP packet packet %d (expecting >= %d)\n", seqno, p->icseq);
15756 if (req->method != SIP_ACK)
15757 transmit_response(p, "503 Server error", req);
15758 return -1;
15759 }
15760 } else if (p->icseq &&
15761 p->icseq == seqno &&
15762 req->method != SIP_ACK &&
15763 (p->method != SIP_CANCEL || ast_test_flag(&p->flags[0], SIP_ALREADYGONE))) {
15764
15765
15766
15767 ignore = 2;
15768 ast_set_flag(req, SIP_PKT_IGNORE);
15769 ast_set_flag(req, SIP_PKT_IGNORE_REQ);
15770 if (option_debug > 2)
15771 ast_log(LOG_DEBUG, "Ignoring SIP message because of retransmit (%s Seqno %d, ours %d)\n", sip_methods[p->method].text, p->icseq, seqno);
15772 }
15773
15774 if (seqno >= p->icseq)
15775
15776
15777
15778 p->icseq = seqno;
15779
15780
15781 if (ast_strlen_zero(p->theirtag)) {
15782 char tag[128];
15783
15784 gettag(req, "From", tag, sizeof(tag));
15785 ast_string_field_set(p, theirtag, tag);
15786 }
15787 snprintf(p->lastmsg, sizeof(p->lastmsg), "Rx: %s", cmd);
15788
15789 if (pedanticsipchecking) {
15790
15791
15792
15793
15794 if (!p->initreq.headers && ast_test_flag(req, SIP_PKT_WITH_TOTAG)) {
15795
15796 if (!ast_test_flag(req, SIP_PKT_IGNORE) && req->method == SIP_INVITE) {
15797 transmit_response_reliable(p, "481 Call/Transaction Does Not Exist", req);
15798
15799 } else if (req->method != SIP_ACK) {
15800 transmit_response(p, "481 Call/Transaction Does Not Exist", req);
15801 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
15802 }
15803 return res;
15804 }
15805 }
15806
15807 if (!e && (p->method == SIP_INVITE || p->method == SIP_SUBSCRIBE || p->method == SIP_REGISTER || p->method == SIP_NOTIFY)) {
15808 transmit_response(p, "400 Bad request", req);
15809 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
15810 return -1;
15811 }
15812
15813
15814 switch (p->method) {
15815 case SIP_OPTIONS:
15816 res = handle_request_options(p, req);
15817 break;
15818 case SIP_INVITE:
15819 res = handle_request_invite(p, req, debug, seqno, sin, recount, e, nounlock);
15820 break;
15821 case SIP_REFER:
15822 res = handle_request_refer(p, req, debug, ignore, seqno, nounlock);
15823 break;
15824 case SIP_CANCEL:
15825 res = handle_request_cancel(p, req);
15826 break;
15827 case SIP_BYE:
15828 res = handle_request_bye(p, req);
15829 break;
15830 case SIP_MESSAGE:
15831 res = handle_request_message(p, req);
15832 break;
15833 case SIP_SUBSCRIBE:
15834 res = handle_request_subscribe(p, req, sin, seqno, e);
15835 break;
15836 case SIP_REGISTER:
15837 res = handle_request_register(p, req, sin, e);
15838 break;
15839 case SIP_INFO:
15840 if (ast_test_flag(req, SIP_PKT_DEBUG))
15841 ast_verbose("Receiving INFO!\n");
15842 if (!ignore)
15843 handle_request_info(p, req);
15844 else
15845 transmit_response(p, "200 OK", req);
15846 break;
15847 case SIP_NOTIFY:
15848 res = handle_request_notify(p, req, sin, seqno, e);
15849 break;
15850 case SIP_ACK:
15851
15852 if (seqno == p->pendinginvite) {
15853 p->invitestate = INV_TERMINATED;
15854 p->pendinginvite = 0;
15855 __sip_ack(p, seqno, FLAG_RESPONSE, 0);
15856 if (find_sdp(req)) {
15857 if (process_sdp(p, req))
15858 return -1;
15859 }
15860 check_pendings(p);
15861 }
15862
15863 if (!p->lastinvite && ast_strlen_zero(p->randdata))
15864 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15865 break;
15866 default:
15867 transmit_response_with_allow(p, "501 Method Not Implemented", req, 0);
15868 ast_log(LOG_NOTICE, "Unknown SIP command '%s' from '%s'\n",
15869 cmd, ast_inet_ntoa(p->sa.sin_addr));
15870
15871 if (!p->initreq.headers)
15872 ast_set_flag(&p->flags[0], SIP_NEEDDESTROY);
15873 break;
15874 }
15875 return res;
15876 }
15877
15878
15879
15880
15881
15882
15883 static int sipsock_read(int *id, int fd, short events, void *ignore)
15884 {
15885 struct sip_request req;
15886 struct sockaddr_in sin = { 0, };
15887 struct sip_pvt *p;
15888 int res;
15889 socklen_t len = sizeof(sin);
15890 int nounlock;
15891 int recount = 0;
15892 int lockretry;
15893
15894 memset(&req, 0, sizeof(req));
15895 res = recvfrom(sipsock, req.data, sizeof(req.data) - 1, 0, (struct sockaddr *)&sin, &len);
15896 if (res < 0) {
15897 #if !defined(__FreeBSD__)
15898 if (errno == EAGAIN)
15899 ast_log(LOG_NOTICE, "SIP: Received packet with bad UDP checksum\n");
15900 else
15901 #endif
15902 if (errno != ECONNREFUSED)
15903 ast_log(LOG_WARNING, "Recv error: %s\n", strerror(errno));
15904 return 1;
15905 }
15906 if (option_debug && res == sizeof(req.data) - 1)
15907 ast_log(LOG_DEBUG, "Received packet exceeds buffer. Data is possibly lost\n");
15908
15909 req.data[res] = '\0';
15910
15911 req.len = strlen(req.data);
15912 if(sip_debug_test_addr(&sin))
15913 ast_set_flag(&req, SIP_PKT_DEBUG);
15914 if (pedanticsipchecking)
15915 req.len = lws2sws(req.data, req.len);
15916 if (ast_test_flag(&req, SIP_PKT_DEBUG))
15917 ast_verbose("\n<--- SIP read from %s:%d --->\n%s\n<------------->\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), req.data);
15918
15919 if(parse_request(&req) == -1)
15920 return 1;
15921
15922 req.method = find_sip_method(req.rlPart1);
15923
15924 if (ast_test_flag(&req, SIP_PKT_DEBUG))
15925 ast_verbose("--- (%d headers %d lines)%s ---\n", req.headers, req.lines, (req.headers + req.lines == 0) ? " Nat keepalive" : "");
15926
15927 if (req.headers < 2)
15928 return 1;
15929
15930
15931 for (lockretry = 100; lockretry > 0; lockretry--) {
15932 ast_mutex_lock(&netlock);
15933
15934
15935 p = find_call(&req, &sin, req.method);
15936 if (p == NULL) {
15937 if (option_debug)
15938 ast_log(LOG_DEBUG, "Invalid SIP message - rejected , no callid, len %d\n", req.len);
15939 ast_mutex_unlock(&netlock);
15940 return 1;
15941 }
15942
15943
15944 if (!p->owner || !ast_channel_trylock(p->owner))
15945 break;
15946 if (option_debug)
15947 ast_log(LOG_DEBUG, "Failed to grab owner channel lock, trying again. (SIP call %s)\n", p->callid);
15948 ast_mutex_unlock(&p->lock);
15949 ast_mutex_unlock(&netlock);
15950
15951 usleep(1);
15952 }
15953 p->recv = sin;
15954
15955 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
15956 append_history(p, "Rx", "%s / %s / %s", req.data, get_header(&req, "CSeq"), req.rlPart2);
15957
15958 if (!lockretry) {
15959 if (p->owner)
15960 ast_log(LOG_ERROR, "We could NOT get the channel lock for %s! \n", S_OR(p->owner->name, "- no channel name ??? - "));
15961 ast_log(LOG_ERROR, "SIP transaction failed: %s \n", p->callid);
15962 if (req.method != SIP_ACK)
15963 transmit_response(p, "503 Server error", &req);
15964
15965 append_history(p, "LockFail", "Owner lock failed, transaction failed.");
15966 return 1;
15967 }
15968 nounlock = 0;
15969 if (handle_request(p, &req, &sin, &recount, &nounlock) == -1) {
15970
15971 if (option_debug)
15972 ast_log(LOG_DEBUG, "SIP message could not be handled, bad request: %-70.70s\n", p->callid[0] ? p->callid : "<no callid>");
15973 }
15974
15975 if (p->owner && !nounlock)
15976 ast_channel_unlock(p->owner);
15977 ast_mutex_unlock(&p->lock);
15978 ast_mutex_unlock(&netlock);
15979 if (recount)
15980 ast_update_use_count();
15981
15982 return 1;
15983 }
15984
15985
15986 static int sip_send_mwi_to_peer(struct sip_peer *peer)
15987 {
15988
15989 struct sip_pvt *p;
15990 int newmsgs, oldmsgs;
15991
15992
15993 if (!peer->addr.sin_addr.s_addr && !peer->defaddr.sin_addr.s_addr)
15994 return 0;
15995
15996
15997 ast_app_inboxcount(peer->mailbox, &newmsgs, &oldmsgs);
15998
15999 peer->lastmsgcheck = time(NULL);
16000
16001
16002 if (((newmsgs > 0x7fff ? 0x7fff0000 : (newmsgs << 16)) | (oldmsgs > 0xffff ? 0xffff : oldmsgs)) == peer->lastmsgssent) {
16003 return 0;
16004 }
16005
16006
16007 peer->lastmsgssent = ((newmsgs > 0x7fff ? 0x7fff0000 : (newmsgs << 16)) | (oldmsgs > 0xffff ? 0xffff : oldmsgs));
16008
16009 if (peer->mwipvt) {
16010
16011 p = peer->mwipvt;
16012 } else {
16013
16014 if (!(p = sip_alloc(NULL, NULL, 0, SIP_NOTIFY)))
16015 return -1;
16016 if (create_addr_from_peer(p, peer)) {
16017
16018 sip_destroy(p);
16019 return 0;
16020 }
16021
16022 if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
16023 p->ourip = __ourip;
16024 build_via(p);
16025 build_callid_pvt(p);
16026
16027 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
16028 }
16029
16030 ast_set_flag(&p->flags[0], SIP_OUTGOING);
16031 transmit_notify_with_mwi(p, newmsgs, oldmsgs, peer->vmexten);
16032 return 0;
16033 }
16034
16035
16036 static int does_peer_need_mwi(struct sip_peer *peer)
16037 {
16038 time_t t = time(NULL);
16039
16040 if (ast_test_flag(&peer->flags[1], SIP_PAGE2_SUBSCRIBEMWIONLY) &&
16041 !peer->mwipvt) {
16042 peer->lastmsgcheck = t;
16043 return FALSE;
16044 }
16045
16046 if (!ast_strlen_zero(peer->mailbox) && (t - peer->lastmsgcheck) > global_mwitime)
16047 return TRUE;
16048
16049 return FALSE;
16050 }
16051
16052
16053
16054
16055
16056
16057 static void *do_monitor(void *data)
16058 {
16059 int res;
16060 struct sip_pvt *sip;
16061 struct sip_peer *peer = NULL;
16062 time_t t;
16063 int fastrestart = FALSE;
16064 int lastpeernum = -1;
16065 int curpeernum;
16066 int reloading;
16067
16068
16069 if (sipsock > -1)
16070 sipsock_read_id = ast_io_add(io, sipsock, sipsock_read, AST_IO_IN, NULL);
16071
16072
16073 for(;;) {
16074
16075 ast_mutex_lock(&sip_reload_lock);
16076 reloading = sip_reloading;
16077 sip_reloading = FALSE;
16078 ast_mutex_unlock(&sip_reload_lock);
16079 if (reloading) {
16080 if (option_verbose > 0)
16081 ast_verbose(VERBOSE_PREFIX_1 "Reloading SIP\n");
16082 sip_do_reload(sip_reloadreason);
16083
16084
16085 if (sipsock > -1) {
16086 if (sipsock_read_id)
16087 sipsock_read_id = ast_io_change(io, sipsock_read_id, sipsock, NULL, 0, NULL);
16088 else
16089 sipsock_read_id = ast_io_add(io, sipsock, sipsock_read, AST_IO_IN, NULL);
16090 } else if (sipsock_read_id) {
16091 ast_io_remove(io, sipsock_read_id);
16092 sipsock_read_id = NULL;
16093 }
16094 }
16095 restartsearch:
16096
16097 ast_mutex_lock(&iflock);
16098 t = time(NULL);
16099
16100
16101
16102
16103 for (sip = iflist; !fastrestart && sip; sip = sip->next) {
16104
16105
16106
16107
16108
16109 if (ast_mutex_trylock(&sip->lock))
16110 continue;
16111
16112
16113 if (sip->rtp && sip->owner &&
16114 (sip->owner->_state == AST_STATE_UP) &&
16115 !sip->redirip.sin_addr.s_addr &&
16116 sip->t38.state != T38_ENABLED) {
16117 if (sip->lastrtptx &&
16118 ast_rtp_get_rtpkeepalive(sip->rtp) &&
16119 (t > sip->lastrtptx + ast_rtp_get_rtpkeepalive(sip->rtp))) {
16120
16121 sip->lastrtptx = time(NULL);
16122 ast_rtp_sendcng(sip->rtp, 0);
16123 }
16124 if (sip->lastrtprx &&
16125 (ast_rtp_get_rtptimeout(sip->rtp) || ast_rtp_get_rtpholdtimeout(sip->rtp)) &&
16126 (t > sip->lastrtprx + ast_rtp_get_rtptimeout(sip->rtp))) {
16127
16128 struct sockaddr_in sin;
16129 ast_rtp_get_peer(sip->rtp, &sin);
16130 if (sin.sin_addr.s_addr ||
16131 (ast_rtp_get_rtpholdtimeout(sip->rtp) &&
16132 (t > sip->lastrtprx + ast_rtp_get_rtpholdtimeout(sip->rtp)))) {
16133
16134 if (ast_rtp_get_rtptimeout(sip->rtp)) {
16135 while (sip->owner && ast_channel_trylock(sip->owner)) {
16136 DEADLOCK_AVOIDANCE(&sip->lock);
16137 }
16138 if (sip->owner) {
16139 ast_log(LOG_NOTICE,
16140 "Disconnecting call '%s' for lack of RTP activity in %ld seconds\n",
16141 sip->owner->name,
16142 (long) (t - sip->lastrtprx));
16143
16144 ast_softhangup_nolock(sip->owner, AST_SOFTHANGUP_DEV);
16145 ast_channel_unlock(sip->owner);
16146
16147
16148
16149
16150 ast_rtp_set_rtptimeout(sip->rtp, 0);
16151 ast_rtp_set_rtpholdtimeout(sip->rtp, 0);
16152 if (sip->vrtp) {
16153 ast_rtp_set_rtptimeout(sip->vrtp, 0);
16154 ast_rtp_set_rtpholdtimeout(sip->vrtp, 0);
16155 }
16156 }
16157 }
16158 }
16159 }
16160 }
16161
16162 if (ast_test_flag(&sip->flags[0], SIP_NEEDDESTROY) && !sip->packets &&
16163 !sip->owner) {
16164 ast_mutex_unlock(&sip->lock);
16165 __sip_destroy(sip, 1);
16166 ast_mutex_unlock(&iflock);
16167 usleep(1);
16168 goto restartsearch;
16169 }
16170 ast_mutex_unlock(&sip->lock);
16171 }
16172 ast_mutex_unlock(&iflock);
16173
16174 pthread_testcancel();
16175
16176 res = ast_sched_wait(sched);
16177 if ((res < 0) || (res > 1000))
16178 res = 1000;
16179
16180 if (fastrestart)
16181 res = 1;
16182 res = ast_io_wait(io, res);
16183 if (option_debug && res > 20)
16184 ast_log(LOG_DEBUG, "chan_sip: ast_io_wait ran %d all at once\n", res);
16185 ast_mutex_lock(&monlock);
16186 if (res >= 0) {
16187 res = ast_sched_runq(sched);
16188 if (option_debug && res >= 20)
16189 ast_log(LOG_DEBUG, "chan_sip: ast_sched_runq ran %d all at once\n", res);
16190 }
16191
16192
16193 t = time(NULL);
16194 fastrestart = FALSE;
16195 curpeernum = 0;
16196 peer = NULL;
16197
16198 ASTOBJ_CONTAINER_TRAVERSE(&peerl, !peer, do {
16199 if ((curpeernum > lastpeernum) && does_peer_need_mwi(iterator)) {
16200 fastrestart = TRUE;
16201 lastpeernum = curpeernum;
16202 peer = ASTOBJ_REF(iterator);
16203 };
16204 curpeernum++;
16205 } while (0)
16206 );
16207
16208 if (peer) {
16209 ASTOBJ_WRLOCK(peer);
16210 sip_send_mwi_to_peer(peer);
16211 ASTOBJ_UNLOCK(peer);
16212 ASTOBJ_UNREF(peer,sip_destroy_peer);
16213 } else {
16214
16215 lastpeernum = -1;
16216 }
16217 ast_mutex_unlock(&monlock);
16218 }
16219
16220 return NULL;
16221
16222 }
16223
16224
16225 static int restart_monitor(void)
16226 {
16227
16228 if (monitor_thread == AST_PTHREADT_STOP)
16229 return 0;
16230 ast_mutex_lock(&monlock);
16231 if (monitor_thread == pthread_self()) {
16232 ast_mutex_unlock(&monlock);
16233 ast_log(LOG_WARNING, "Cannot kill myself\n");
16234 return -1;
16235 }
16236 if (monitor_thread != AST_PTHREADT_NULL) {
16237
16238 pthread_kill(monitor_thread, SIGURG);
16239 } else {
16240
16241 if (ast_pthread_create_background(&monitor_thread, NULL, do_monitor, NULL) < 0) {
16242 ast_mutex_unlock(&monlock);
16243 ast_log(LOG_ERROR, "Unable to start monitor thread.\n");
16244 return -1;
16245 }
16246 }
16247 ast_mutex_unlock(&monlock);
16248 return 0;
16249 }
16250
16251
16252 static int sip_poke_noanswer(const void *data)
16253 {
16254 struct sip_peer *peer = (struct sip_peer *)data;
16255
16256 peer->pokeexpire = -1;
16257 if (peer->lastms > -1) {
16258 ast_log(LOG_NOTICE, "Peer '%s' is now UNREACHABLE! Last qualify: %d\n", peer->name, peer->lastms);
16259 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "Peer: SIP/%s\r\nPeerStatus: Unreachable\r\nTime: %d\r\n", peer->name, -1);
16260 }
16261 if (peer->call)
16262 sip_destroy(peer->call);
16263 peer->call = NULL;
16264 peer->lastms = -1;
16265 ast_device_state_changed("SIP/%s", peer->name);
16266
16267
16268 if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
16269 struct sip_peer *peer_ptr = peer;
16270 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
16271 }
16272
16273
16274
16275 peer->pokeexpire = ast_sched_add(sched, DEFAULT_FREQ_NOTOK, sip_poke_peer_s, peer);
16276 if (peer->pokeexpire == -1) {
16277 ASTOBJ_UNREF(peer, sip_destroy_peer);
16278 }
16279
16280 return 0;
16281 }
16282
16283
16284
16285
16286 static int sip_poke_peer(struct sip_peer *peer)
16287 {
16288 struct sip_pvt *p;
16289 int xmitres = 0;
16290
16291 if (!peer->maxms || !peer->addr.sin_addr.s_addr) {
16292
16293
16294 if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
16295 struct sip_peer *peer_ptr = peer;
16296 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
16297 }
16298 peer->lastms = 0;
16299 peer->call = NULL;
16300 return 0;
16301 }
16302 if (peer->call) {
16303 if (sipdebug)
16304 ast_log(LOG_NOTICE, "Still have a QUALIFY dialog active, deleting\n");
16305 sip_destroy(peer->call);
16306 }
16307 if (!(p = peer->call = sip_alloc(NULL, NULL, 0, SIP_OPTIONS)))
16308 return -1;
16309
16310 p->sa = peer->addr;
16311 p->recv = peer->addr;
16312 ast_copy_flags(&p->flags[0], &peer->flags[0], SIP_FLAGS_TO_COPY);
16313 ast_copy_flags(&p->flags[1], &peer->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
16314
16315
16316 if (!ast_strlen_zero(peer->fullcontact))
16317 ast_string_field_set(p, fullcontact, peer->fullcontact);
16318
16319 if (!ast_strlen_zero(peer->tohost))
16320 ast_string_field_set(p, tohost, peer->tohost);
16321 else
16322 ast_string_field_set(p, tohost, ast_inet_ntoa(peer->addr.sin_addr));
16323
16324
16325 if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
16326 p->ourip = __ourip;
16327 build_via(p);
16328 build_callid_pvt(p);
16329
16330 if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
16331 struct sip_peer *peer_ptr = peer;
16332 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
16333 }
16334
16335 p->relatedpeer = ASTOBJ_REF(peer);
16336 ast_set_flag(&p->flags[0], SIP_OUTGOING);
16337 #ifdef VOCAL_DATA_HACK
16338 ast_copy_string(p->username, "__VOCAL_DATA_SHOULD_READ_THE_SIP_SPEC__", sizeof(p->username));
16339 xmitres = transmit_invite(p, SIP_INVITE, 0, 2);
16340 #else
16341 xmitres = transmit_invite(p, SIP_OPTIONS, 0, 2);
16342 #endif
16343 gettimeofday(&peer->ps, NULL);
16344 if (xmitres == XMIT_ERROR) {
16345 sip_poke_noanswer(ASTOBJ_REF(peer));
16346 } else {
16347 if (!AST_SCHED_DEL(sched, peer->pokeexpire)) {
16348 struct sip_peer *peer_ptr = peer;
16349 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
16350 }
16351 peer->pokeexpire = ast_sched_add(sched, peer->maxms * 2, sip_poke_noanswer, ASTOBJ_REF(peer));
16352 if (peer->pokeexpire == -1) {
16353 struct sip_peer *peer_ptr = peer;
16354 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
16355 }
16356 }
16357
16358 return 0;
16359 }
16360
16361
16362
16363
16364
16365
16366
16367
16368
16369
16370
16371
16372
16373
16374
16375
16376
16377
16378
16379
16380
16381
16382
16383
16384
16385
16386
16387
16388
16389
16390
16391
16392
16393
16394 static int sip_devicestate(void *data)
16395 {
16396 char *host;
16397 char *tmp;
16398
16399 struct hostent *hp;
16400 struct ast_hostent ahp;
16401 struct sip_peer *p;
16402
16403 int res = AST_DEVICE_INVALID;
16404
16405
16406 host = ast_strdupa(data ? data : "");
16407 if ((tmp = strchr(host, '@')))
16408 host = tmp + 1;
16409
16410 if (option_debug > 2)
16411 ast_log(LOG_DEBUG, "Checking device state for peer %s\n", host);
16412
16413 if ((p = find_peer(host, NULL, 1))) {
16414 if (p->addr.sin_addr.s_addr || p->defaddr.sin_addr.s_addr) {
16415
16416
16417
16418
16419
16420
16421
16422
16423
16424
16425
16426 if (p->onHold)
16427
16428 res = AST_DEVICE_ONHOLD;
16429 else if (p->inRinging) {
16430 if (p->inRinging == p->inUse)
16431 res = AST_DEVICE_RINGING;
16432 else
16433 res = AST_DEVICE_RINGINUSE;
16434 } else if (p->call_limit && (p->inUse == p->call_limit))
16435
16436 res = AST_DEVICE_BUSY;
16437 else if (p->call_limit && p->inUse)
16438
16439 res = AST_DEVICE_INUSE;
16440 else if (p->maxms && ((p->lastms > p->maxms) || (p->lastms < 0)))
16441
16442 res = AST_DEVICE_UNAVAILABLE;
16443 else
16444 res = AST_DEVICE_NOT_INUSE;
16445 } else {
16446
16447 res = AST_DEVICE_UNAVAILABLE;
16448 }
16449 ASTOBJ_UNREF(p,sip_destroy_peer);
16450 } else {
16451 char *port = strchr(host, ':');
16452 if (port)
16453 *port = '\0';
16454 hp = ast_gethostbyname(host, &ahp);
16455 if (hp)
16456 res = AST_DEVICE_UNKNOWN;
16457 }
16458
16459 return res;
16460 }
16461
16462
16463
16464 static struct ast_channel *sip_request_call(const char *type, int format, void *data, int *cause)
16465 {
16466 int oldformat;
16467 struct sip_pvt *p;
16468 struct ast_channel *tmpc = NULL;
16469 char *ext, *host;
16470 char tmp[256];
16471 char *dest = data;
16472
16473 oldformat = format;
16474 if (!(format &= ((AST_FORMAT_MAX_AUDIO << 1) - 1))) {
16475 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));
16476 *cause = AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
16477 return NULL;
16478 }
16479 if (option_debug)
16480 ast_log(LOG_DEBUG, "Asked to create a SIP channel with formats: %s\n", ast_getformatname_multiple(tmp, sizeof(tmp), oldformat));
16481
16482 if (!(p = sip_alloc(NULL, NULL, 0, SIP_INVITE))) {
16483 ast_log(LOG_ERROR, "Unable to build sip pvt data for '%s' (Out of memory or socket error)\n", (char *)data);
16484 *cause = AST_CAUSE_SWITCH_CONGESTION;
16485 return NULL;
16486 }
16487
16488 ast_set_flag(&p->flags[1], SIP_PAGE2_OUTGOING_CALL);
16489
16490 if (!(p->options = ast_calloc(1, sizeof(*p->options)))) {
16491 sip_destroy(p);
16492 ast_log(LOG_ERROR, "Unable to build option SIP data structure - Out of memory\n");
16493 *cause = AST_CAUSE_SWITCH_CONGESTION;
16494 return NULL;
16495 }
16496
16497 ast_copy_string(tmp, dest, sizeof(tmp));
16498 host = strchr(tmp, '@');
16499 if (host) {
16500 *host++ = '\0';
16501 ext = tmp;
16502 } else {
16503 ext = strchr(tmp, '/');
16504 if (ext)
16505 *ext++ = '\0';
16506 host = tmp;
16507 }
16508
16509 if (create_addr(p, host)) {
16510 *cause = AST_CAUSE_UNREGISTERED;
16511 if (option_debug > 2)
16512 ast_log(LOG_DEBUG, "Cant create SIP call - target device not registred\n");
16513 sip_destroy(p);
16514 return NULL;
16515 }
16516 if (ast_strlen_zero(p->peername) && ext)
16517 ast_string_field_set(p, peername, ext);
16518
16519 if (ast_sip_ouraddrfor(&p->sa.sin_addr, &p->ourip))
16520 p->ourip = __ourip;
16521 build_via(p);
16522 build_callid_pvt(p);
16523
16524
16525
16526
16527
16528 if (ext) {
16529 ast_string_field_set(p, username, ext);
16530 ast_string_field_free(p, fullcontact);
16531 }
16532 #if 0
16533 printf("Setting up to call extension '%s' at '%s'\n", ext ? ext : "<none>", host);
16534 #endif
16535 p->prefcodec = oldformat;
16536 ast_mutex_lock(&p->lock);
16537 tmpc = sip_new(p, AST_STATE_DOWN, host);
16538 ast_mutex_unlock(&p->lock);
16539 if (!tmpc)
16540 sip_destroy(p);
16541 ast_update_use_count();
16542 restart_monitor();
16543 return tmpc;
16544 }
16545
16546
16547
16548
16549
16550
16551
16552 static void set_insecure_flags(struct ast_flags *flags, const char *value, int lineno)
16553 {
16554 static int dep_insecure_very = 0;
16555 static int dep_insecure_yes = 0;
16556
16557 if (ast_strlen_zero(value))
16558 return;
16559
16560 if (!strcasecmp(value, "very")) {
16561 ast_set_flag(flags, SIP_INSECURE_PORT | SIP_INSECURE_INVITE);
16562 if(!dep_insecure_very) {
16563 if(lineno != -1)
16564 ast_log(LOG_WARNING, "insecure=very at line %d is deprecated; use insecure=port,invite instead\n", lineno);
16565 else
16566 ast_log(LOG_WARNING, "insecure=very is deprecated; use insecure=port,invite instead\n");
16567 dep_insecure_very = 1;
16568 }
16569 }
16570 else if (ast_true(value)) {
16571 ast_set_flag(flags, SIP_INSECURE_PORT);
16572 if(!dep_insecure_yes) {
16573 if(lineno != -1)
16574 ast_log(LOG_WARNING, "insecure=%s at line %d is deprecated; use insecure=port instead\n", value, lineno);
16575 else
16576 ast_log(LOG_WARNING, "insecure=%s is deprecated; use insecure=port instead\n", value);
16577 dep_insecure_yes = 1;
16578 }
16579 }
16580 else if (!ast_false(value)) {
16581 char buf[64];
16582 char *word, *next;
16583 ast_copy_string(buf, value, sizeof(buf));
16584 next = buf;
16585 while ((word = strsep(&next, ","))) {
16586 if (!strcasecmp(word, "port"))
16587 ast_set_flag(flags, SIP_INSECURE_PORT);
16588 else if (!strcasecmp(word, "invite"))
16589 ast_set_flag(flags, SIP_INSECURE_INVITE);
16590 else
16591 ast_log(LOG_WARNING, "Unknown insecure mode '%s' on line %d\n", value, lineno);
16592 }
16593 }
16594 }
16595
16596
16597
16598
16599
16600
16601
16602
16603 static int handle_common_options(struct ast_flags *flags, struct ast_flags *mask, struct ast_variable *v)
16604 {
16605 int res = 1;
16606
16607 if (!strcasecmp(v->name, "trustrpid")) {
16608 ast_set_flag(&mask[0], SIP_TRUSTRPID);
16609 ast_set2_flag(&flags[0], ast_true(v->value), SIP_TRUSTRPID);
16610 } else if (!strcasecmp(v->name, "sendrpid")) {
16611 ast_set_flag(&mask[0], SIP_SENDRPID);
16612 ast_set2_flag(&flags[0], ast_true(v->value), SIP_SENDRPID);
16613 } else if (!strcasecmp(v->name, "g726nonstandard")) {
16614 ast_set_flag(&mask[0], SIP_G726_NONSTANDARD);
16615 ast_set2_flag(&flags[0], ast_true(v->value), SIP_G726_NONSTANDARD);
16616 } else if (!strcasecmp(v->name, "useclientcode")) {
16617 ast_set_flag(&mask[0], SIP_USECLIENTCODE);
16618 ast_set2_flag(&flags[0], ast_true(v->value), SIP_USECLIENTCODE);
16619 } else if (!strcasecmp(v->name, "dtmfmode")) {
16620 ast_set_flag(&mask[0], SIP_DTMF);
16621 ast_clear_flag(&flags[0], SIP_DTMF);
16622 if (!strcasecmp(v->value, "inband"))
16623 ast_set_flag(&flags[0], SIP_DTMF_INBAND);
16624 else if (!strcasecmp(v->value, "rfc2833"))
16625 ast_set_flag(&flags[0], SIP_DTMF_RFC2833);
16626 else if (!strcasecmp(v->value, "info"))
16627 ast_set_flag(&flags[0], SIP_DTMF_INFO);
16628 else if (!strcasecmp(v->value, "auto"))
16629 ast_set_flag(&flags[0], SIP_DTMF_AUTO);
16630 else {
16631 ast_log(LOG_WARNING, "Unknown dtmf mode '%s' on line %d, using rfc2833\n", v->value, v->lineno);
16632 ast_set_flag(&flags[0], SIP_DTMF_RFC2833);
16633 }
16634 } else if (!strcasecmp(v->name, "nat")) {
16635 ast_set_flag(&mask[0], SIP_NAT);
16636 ast_set_flag(&flags[0], SIP_NAT_ALWAYS);
16637 if (!strcasecmp(v->value, "never")) {
16638 ast_set_flags_to(&flags[0], SIP_NAT, SIP_NAT_NEVER);
16639 } else if (!strcasecmp(v->value, "route")) {
16640 ast_set_flags_to(&flags[0], SIP_NAT, SIP_NAT_ROUTE);
16641 } else if (ast_false(v->value)) {
16642 ast_set_flags_to(&flags[0], SIP_NAT, SIP_NAT_RFC3581);
16643 }
16644 } else if (!strcasecmp(v->name, "canreinvite")) {
16645 ast_set_flag(&mask[0], SIP_REINVITE);
16646 ast_clear_flag(&flags[0], SIP_REINVITE);
16647 if(ast_true(v->value)) {
16648 ast_set_flag(&flags[0], SIP_CAN_REINVITE | SIP_CAN_REINVITE_NAT);
16649 } else if (!ast_false(v->value)) {
16650 char buf[64];
16651 char *word, *next = buf;
16652
16653 ast_copy_string(buf, v->value, sizeof(buf));
16654 while ((word = strsep(&next, ","))) {
16655 if(!strcasecmp(word, "update")) {
16656 ast_set_flag(&flags[0], SIP_REINVITE_UPDATE | SIP_CAN_REINVITE);
16657 } else if(!strcasecmp(word, "nonat")) {
16658 ast_set_flag(&flags[0], SIP_CAN_REINVITE);
16659 ast_clear_flag(&flags[0], SIP_CAN_REINVITE_NAT);
16660 } else {
16661 ast_log(LOG_WARNING, "Unknown canreinvite mode '%s' on line %d\n", v->value, v->lineno);
16662 }
16663 }
16664 }
16665 } else if (!strcasecmp(v->name, "insecure")) {
16666 ast_set_flag(&mask[0], SIP_INSECURE_PORT | SIP_INSECURE_INVITE);
16667 ast_clear_flag(&flags[0], SIP_INSECURE_PORT | SIP_INSECURE_INVITE);
16668 set_insecure_flags(flags, v->value, v->lineno);
16669 } else if (!strcasecmp(v->name, "progressinband")) {
16670 ast_set_flag(&mask[0], SIP_PROG_INBAND);
16671 ast_clear_flag(&flags[0], SIP_PROG_INBAND);
16672 if (ast_true(v->value))
16673 ast_set_flag(&flags[0], SIP_PROG_INBAND_YES);
16674 else if (strcasecmp(v->value, "never"))
16675 ast_set_flag(&flags[0], SIP_PROG_INBAND_NO);
16676 } else if (!strcasecmp(v->name, "promiscredir")) {
16677 ast_set_flag(&mask[0], SIP_PROMISCREDIR);
16678 ast_set2_flag(&flags[0], ast_true(v->value), SIP_PROMISCREDIR);
16679 } else if (!strcasecmp(v->name, "videosupport")) {
16680 ast_set_flag(&mask[1], SIP_PAGE2_VIDEOSUPPORT);
16681 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_VIDEOSUPPORT);
16682 } else if (!strcasecmp(v->name, "allowoverlap")) {
16683 ast_set_flag(&mask[1], SIP_PAGE2_ALLOWOVERLAP);
16684 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_ALLOWOVERLAP);
16685 } else if (!strcasecmp(v->name, "allowsubscribe")) {
16686 ast_set_flag(&mask[1], SIP_PAGE2_ALLOWSUBSCRIBE);
16687 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_ALLOWSUBSCRIBE);
16688 } else if (!strcasecmp(v->name, "t38pt_udptl")) {
16689 ast_set_flag(&mask[1], SIP_PAGE2_T38SUPPORT_UDPTL);
16690 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_T38SUPPORT_UDPTL);
16691 #ifdef WHEN_WE_HAVE_T38_FOR_OTHER_TRANSPORTS
16692 } else if (!strcasecmp(v->name, "t38pt_rtp")) {
16693 ast_set_flag(&mask[1], SIP_PAGE2_T38SUPPORT_RTP);
16694 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_T38SUPPORT_RTP);
16695 } else if (!strcasecmp(v->name, "t38pt_tcp")) {
16696 ast_set_flag(&mask[1], SIP_PAGE2_T38SUPPORT_TCP);
16697 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_T38SUPPORT_TCP);
16698 #endif
16699 } else if (!strcasecmp(v->name, "rfc2833compensate")) {
16700 ast_set_flag(&mask[1], SIP_PAGE2_RFC2833_COMPENSATE);
16701 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_RFC2833_COMPENSATE);
16702 } else if (!strcasecmp(v->name, "buggymwi")) {
16703 ast_set_flag(&mask[1], SIP_PAGE2_BUGGY_MWI);
16704 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_BUGGY_MWI);
16705 } else if (!strcasecmp(v->name, "t38pt_usertpsource")) {
16706 ast_set_flag(&mask[1], SIP_PAGE2_UDPTL_DESTINATION);
16707 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_UDPTL_DESTINATION);
16708 } else
16709 res = 0;
16710
16711 return res;
16712 }
16713
16714
16715 static int add_sip_domain(const char *domain, const enum domain_mode mode, const char *context)
16716 {
16717 struct domain *d;
16718
16719 if (ast_strlen_zero(domain)) {
16720 ast_log(LOG_WARNING, "Zero length domain.\n");
16721 return 1;
16722 }
16723
16724 if (!(d = ast_calloc(1, sizeof(*d))))
16725 return 0;
16726
16727 ast_copy_string(d->domain, domain, sizeof(d->domain));
16728
16729 if (!ast_strlen_zero(context))
16730 ast_copy_string(d->context, context, sizeof(d->context));
16731
16732 d->mode = mode;
16733
16734 AST_LIST_LOCK(&domain_list);
16735 AST_LIST_INSERT_TAIL(&domain_list, d, list);
16736 AST_LIST_UNLOCK(&domain_list);
16737
16738 if (sipdebug)
16739 ast_log(LOG_DEBUG, "Added local SIP domain '%s'\n", domain);
16740
16741 return 1;
16742 }
16743
16744
16745 static int check_sip_domain(const char *domain, char *context, size_t len)
16746 {
16747 struct domain *d;
16748 int result = 0;
16749
16750 AST_LIST_LOCK(&domain_list);
16751 AST_LIST_TRAVERSE(&domain_list, d, list) {
16752 if (strcasecmp(d->domain, domain))
16753 continue;
16754
16755 if (len && !ast_strlen_zero(d->context))
16756 ast_copy_string(context, d->context, len);
16757
16758 result = 1;
16759 break;
16760 }
16761 AST_LIST_UNLOCK(&domain_list);
16762
16763 return result;
16764 }
16765
16766
16767 static void clear_sip_domains(void)
16768 {
16769 struct domain *d;
16770
16771 AST_LIST_LOCK(&domain_list);
16772 while ((d = AST_LIST_REMOVE_HEAD(&domain_list, list)))
16773 free(d);
16774 AST_LIST_UNLOCK(&domain_list);
16775 }
16776
16777
16778
16779 static struct sip_auth *add_realm_authentication(struct sip_auth *authlist, char *configuration, int lineno)
16780 {
16781 char authcopy[256];
16782 char *username=NULL, *realm=NULL, *secret=NULL, *md5secret=NULL;
16783 char *stringp;
16784 struct sip_auth *a, *b, *auth;
16785
16786 if (ast_strlen_zero(configuration))
16787 return authlist;
16788
16789 if (option_debug)
16790 ast_log(LOG_DEBUG, "Auth config :: %s\n", configuration);
16791
16792 ast_copy_string(authcopy, configuration, sizeof(authcopy));
16793 stringp = authcopy;
16794
16795 username = stringp;
16796 realm = strrchr(stringp, '@');
16797 if (realm)
16798 *realm++ = '\0';
16799 if (ast_strlen_zero(username) || ast_strlen_zero(realm)) {
16800 ast_log(LOG_WARNING, "Format for authentication entry is user[:secret]@realm at line %d\n", lineno);
16801 return authlist;
16802 }
16803 stringp = username;
16804 username = strsep(&stringp, ":");
16805 if (username) {
16806 secret = strsep(&stringp, ":");
16807 if (!secret) {
16808 stringp = username;
16809 md5secret = strsep(&stringp,"#");
16810 }
16811 }
16812 if (!(auth = ast_calloc(1, sizeof(*auth))))
16813 return authlist;
16814
16815 ast_copy_string(auth->realm, realm, sizeof(auth->realm));
16816 ast_copy_string(auth->username, username, sizeof(auth->username));
16817 if (secret)
16818 ast_copy_string(auth->secret, secret, sizeof(auth->secret));
16819 if (md5secret)
16820 ast_copy_string(auth->md5secret, md5secret, sizeof(auth->md5secret));
16821
16822
16823 for (b = NULL, a = authlist; a ; b = a, a = a->next)
16824 ;
16825 if (b)
16826 b->next = auth;
16827 else
16828 authlist = auth;
16829
16830 if (option_verbose > 2)
16831 ast_verbose("Added authentication for realm %s\n", realm);
16832
16833 return authlist;
16834
16835 }
16836
16837
16838 static int clear_realm_authentication(struct sip_auth *authlist)
16839 {
16840 struct sip_auth *a = authlist;
16841 struct sip_auth *b;
16842
16843 while (a) {
16844 b = a;
16845 a = a->next;
16846 free(b);
16847 }
16848
16849 return 1;
16850 }
16851
16852
16853 static struct sip_auth *find_realm_authentication(struct sip_auth *authlist, const char *realm)
16854 {
16855 struct sip_auth *a;
16856
16857 for (a = authlist; a; a = a->next) {
16858 if (!strcasecmp(a->realm, realm))
16859 break;
16860 }
16861
16862 return a;
16863 }
16864
16865
16866 static struct sip_user *build_user(const char *name, struct ast_variable *v, struct ast_variable *alt, int realtime)
16867 {
16868 struct sip_user *user;
16869 int format;
16870 struct ast_ha *oldha = NULL;
16871 char *varname = NULL, *varval = NULL;
16872 struct ast_variable *tmpvar = NULL;
16873 struct ast_flags userflags[2] = {{(0)}};
16874 struct ast_flags mask[2] = {{(0)}};
16875
16876
16877 if (!(user = ast_calloc(1, sizeof(*user))))
16878 return NULL;
16879
16880 suserobjs++;
16881 ASTOBJ_INIT(user);
16882 ast_copy_string(user->name, name, sizeof(user->name));
16883 oldha = user->ha;
16884 user->ha = NULL;
16885 ast_copy_flags(&user->flags[0], &global_flags[0], SIP_FLAGS_TO_COPY);
16886 ast_copy_flags(&user->flags[1], &global_flags[1], SIP_PAGE2_FLAGS_TO_COPY);
16887 user->capability = global_capability;
16888 user->allowtransfer = global_allowtransfer;
16889 user->maxcallbitrate = default_maxcallbitrate;
16890 user->autoframing = global_autoframing;
16891 user->prefs = default_prefs;
16892
16893 strcpy(user->context, default_context);
16894 strcpy(user->language, default_language);
16895 strcpy(user->mohinterpret, default_mohinterpret);
16896 strcpy(user->mohsuggest, default_mohsuggest);
16897
16898 for (; v || ((v = alt) && !(alt=NULL)); v = v->next) {
16899 if (handle_common_options(&userflags[0], &mask[0], v))
16900 continue;
16901
16902 if (!strcasecmp(v->name, "context")) {
16903 ast_copy_string(user->context, v->value, sizeof(user->context));
16904 } else if (!strcasecmp(v->name, "subscribecontext")) {
16905 ast_copy_string(user->subscribecontext, v->value, sizeof(user->subscribecontext));
16906 } else if (!strcasecmp(v->name, "setvar")) {
16907 varname = ast_strdupa(v->value);
16908 if ((varval = strchr(varname,'='))) {
16909 *varval++ = '\0';
16910 if ((tmpvar = ast_variable_new(varname, varval))) {
16911 tmpvar->next = user->chanvars;
16912 user->chanvars = tmpvar;
16913 }
16914 }
16915 } else if (!strcasecmp(v->name, "permit") ||
16916 !strcasecmp(v->name, "deny")) {
16917 user->ha = ast_append_ha(v->name, v->value, user->ha);
16918 } else if (!strcasecmp(v->name, "allowtransfer")) {
16919 user->allowtransfer = ast_true(v->value) ? TRANSFER_OPENFORALL : TRANSFER_CLOSED;
16920 } else if (!strcasecmp(v->name, "secret")) {
16921 ast_copy_string(user->secret, v->value, sizeof(user->secret));
16922 } else if (!strcasecmp(v->name, "md5secret")) {
16923 ast_copy_string(user->md5secret, v->value, sizeof(user->md5secret));
16924 } else if (!strcasecmp(v->name, "callerid")) {
16925 ast_callerid_split(v->value, user->cid_name, sizeof(user->cid_name), user->cid_num, sizeof(user->cid_num));
16926 } else if (!strcasecmp(v->name, "fullname")) {
16927 ast_copy_string(user->cid_name, v->value, sizeof(user->cid_name));
16928 } else if (!strcasecmp(v->name, "cid_number")) {
16929 ast_copy_string(user->cid_num, v->value, sizeof(user->cid_num));
16930 } else if (!strcasecmp(v->name, "callgroup")) {
16931 user->callgroup = ast_get_group(v->value);
16932 } else if (!strcasecmp(v->name, "pickupgroup")) {
16933 user->pickupgroup = ast_get_group(v->value);
16934 } else if (!strcasecmp(v->name, "language")) {
16935 ast_copy_string(user->language, v->value, sizeof(user->language));
16936 } else if (!strcasecmp(v->name, "mohinterpret")
16937 || !strcasecmp(v->name, "musicclass") || !strcasecmp(v->name, "musiconhold")) {
16938 ast_copy_string(user->mohinterpret, v->value, sizeof(user->mohinterpret));
16939 } else if (!strcasecmp(v->name, "mohsuggest")) {
16940 ast_copy_string(user->mohsuggest, v->value, sizeof(user->mohsuggest));
16941 } else if (!strcasecmp(v->name, "accountcode")) {
16942 ast_copy_string(user->accountcode, v->value, sizeof(user->accountcode));
16943 } else if (!strcasecmp(v->name, "call-limit")) {
16944 user->call_limit = atoi(v->value);
16945 if (user->call_limit < 0)
16946 user->call_limit = 0;
16947 } else if (!strcasecmp(v->name, "amaflags")) {
16948 format = ast_cdr_amaflags2int(v->value);
16949 if (format < 0) {
16950 ast_log(LOG_WARNING, "Invalid AMA Flags: %s at line %d\n", v->value, v->lineno);
16951 } else {
16952 user->amaflags = format;
16953 }
16954 } else if (!strcasecmp(v->name, "allow")) {
16955 ast_parse_allow_disallow(&user->prefs, &user->capability, v->value, 1);
16956 } else if (!strcasecmp(v->name, "disallow")) {
16957 ast_parse_allow_disallow(&user->prefs, &user->capability, v->value, 0);
16958 } else if (!strcasecmp(v->name, "autoframing")) {
16959 user->autoframing = ast_true(v->value);
16960 } else if (!strcasecmp(v->name, "callingpres")) {
16961 user->callingpres = ast_parse_caller_presentation(v->value);
16962 if (user->callingpres == -1)
16963 user->callingpres = atoi(v->value);
16964 } else if (!strcasecmp(v->name, "maxcallbitrate")) {
16965 user->maxcallbitrate = atoi(v->value);
16966 if (user->maxcallbitrate < 0)
16967 user->maxcallbitrate = default_maxcallbitrate;
16968 }
16969
16970
16971
16972 }
16973 ast_copy_flags(&user->flags[0], &userflags[0], mask[0].flags);
16974 ast_copy_flags(&user->flags[1], &userflags[1], mask[1].flags);
16975 if (ast_test_flag(&user->flags[1], SIP_PAGE2_ALLOWSUBSCRIBE))
16976 global_allowsubscribe = TRUE;
16977 ast_free_ha(oldha);
16978 return user;
16979 }
16980
16981
16982 static void set_peer_defaults(struct sip_peer *peer)
16983 {
16984 if (peer->expire == 0) {
16985
16986
16987
16988 peer->expire = -1;
16989 peer->pokeexpire = -1;
16990 peer->addr.sin_port = htons(STANDARD_SIP_PORT);
16991 }
16992 ast_copy_flags(&peer->flags[0], &global_flags[0], SIP_FLAGS_TO_COPY);
16993 ast_copy_flags(&peer->flags[1], &global_flags[1], SIP_PAGE2_FLAGS_TO_COPY);
16994 strcpy(peer->context, default_context);
16995 strcpy(peer->subscribecontext, default_subscribecontext);
16996 strcpy(peer->language, default_language);
16997 strcpy(peer->mohinterpret, default_mohinterpret);
16998 strcpy(peer->mohsuggest, default_mohsuggest);
16999 peer->addr.sin_family = AF_INET;
17000 peer->defaddr.sin_family = AF_INET;
17001 peer->capability = global_capability;
17002 peer->maxcallbitrate = default_maxcallbitrate;
17003 peer->rtptimeout = global_rtptimeout;
17004 peer->rtpholdtimeout = global_rtpholdtimeout;
17005 peer->rtpkeepalive = global_rtpkeepalive;
17006 peer->allowtransfer = global_allowtransfer;
17007 peer->autoframing = global_autoframing;
17008 strcpy(peer->vmexten, default_vmexten);
17009 peer->secret[0] = '\0';
17010 peer->md5secret[0] = '\0';
17011 peer->cid_num[0] = '\0';
17012 peer->cid_name[0] = '\0';
17013 peer->fromdomain[0] = '\0';
17014 peer->fromuser[0] = '\0';
17015 peer->regexten[0] = '\0';
17016 peer->mailbox[0] = '\0';
17017 peer->callgroup = 0;
17018 peer->pickupgroup = 0;
17019 peer->maxms = default_qualify;
17020 peer->prefs = default_prefs;
17021 }
17022
17023
17024 static struct sip_peer *temp_peer(const char *name)
17025 {
17026 struct sip_peer *peer;
17027
17028 if (!(peer = ast_calloc(1, sizeof(*peer))))
17029 return NULL;
17030
17031 apeerobjs++;
17032 ASTOBJ_INIT(peer);
17033 set_peer_defaults(peer);
17034
17035 ast_copy_string(peer->name, name, sizeof(peer->name));
17036
17037 ast_set_flag(&peer->flags[1], SIP_PAGE2_SELFDESTRUCT);
17038 ast_set_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC);
17039 peer->prefs = default_prefs;
17040 reg_source_db(peer);
17041
17042 return peer;
17043 }
17044
17045
17046 static struct sip_peer *build_peer(const char *name, struct ast_variable *v, struct ast_variable *alt, int realtime)
17047 {
17048 struct sip_peer *peer = NULL;
17049 struct ast_ha *oldha = NULL;
17050 int obproxyfound=0;
17051 int found=0;
17052 int firstpass=1;
17053 int format=0;
17054 time_t regseconds = 0;
17055 char *varname = NULL, *varval = NULL;
17056 struct ast_variable *tmpvar = NULL;
17057 struct ast_flags peerflags[2] = {{(0)}};
17058 struct ast_flags mask[2] = {{(0)}};
17059 char fullcontact[sizeof(peer->fullcontact)] = "";
17060
17061 if (!realtime || ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS))
17062
17063
17064
17065
17066
17067 peer = ASTOBJ_CONTAINER_FIND_UNLINK_FULL(&peerl, name, name, 0, 0, strcmp);
17068
17069 if (peer) {
17070
17071 found = 1;
17072 if (!(peer->objflags & ASTOBJ_FLAG_MARKED))
17073 firstpass = 0;
17074 } else {
17075 if (!(peer = ast_calloc(1, sizeof(*peer))))
17076 return NULL;
17077
17078 if (realtime && !ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS))
17079 rpeerobjs++;
17080 else
17081 speerobjs++;
17082 ASTOBJ_INIT(peer);
17083 }
17084
17085 if (firstpass) {
17086 peer->lastmsgssent = -1;
17087 oldha = peer->ha;
17088 peer->ha = NULL;
17089 set_peer_defaults(peer);
17090 }
17091 if (!found && name)
17092 ast_copy_string(peer->name, name, sizeof(peer->name));
17093
17094
17095 if (peer->chanvars) {
17096 ast_variables_destroy(peer->chanvars);
17097 peer->chanvars = NULL;
17098
17099 }
17100
17101
17102 clear_realm_authentication(peer->auth);
17103 peer->auth = NULL;
17104
17105 for (; v || ((v = alt) && !(alt=NULL)); v = v->next) {
17106 if (handle_common_options(&peerflags[0], &mask[0], v))
17107 continue;
17108 if (realtime && !strcasecmp(v->name, "regseconds")) {
17109 ast_get_time_t(v->value, ®seconds, 0, NULL);
17110 } else if (realtime && !strcasecmp(v->name, "ipaddr") && !ast_strlen_zero(v->value) ) {
17111 inet_aton(v->value, &(peer->addr.sin_addr));
17112 } else if (realtime && !strcasecmp(v->name, "name"))
17113 ast_copy_string(peer->name, v->value, sizeof(peer->name));
17114 else if (realtime && !strcasecmp(v->name, "fullcontact")) {
17115
17116 if (!ast_strlen_zero(fullcontact)) {
17117 strncat(fullcontact, ";", sizeof(fullcontact) - strlen(fullcontact) - 1);
17118 strncat(fullcontact, v->value, sizeof(fullcontact) - strlen(fullcontact) - 1);
17119 } else {
17120 ast_copy_string(fullcontact, v->value, sizeof(fullcontact));
17121 ast_set_flag(&peer->flags[1], SIP_PAGE2_RT_FROMCONTACT);
17122 }
17123 } else if (!strcasecmp(v->name, "secret"))
17124 ast_copy_string(peer->secret, v->value, sizeof(peer->secret));
17125 else if (!strcasecmp(v->name, "md5secret"))
17126 ast_copy_string(peer->md5secret, v->value, sizeof(peer->md5secret));
17127 else if (!strcasecmp(v->name, "auth"))
17128 peer->auth = add_realm_authentication(peer->auth, v->value, v->lineno);
17129 else if (!strcasecmp(v->name, "callerid")) {
17130 ast_callerid_split(v->value, peer->cid_name, sizeof(peer->cid_name), peer->cid_num, sizeof(peer->cid_num));
17131 } else if (!strcasecmp(v->name, "fullname")) {
17132 ast_copy_string(peer->cid_name, v->value, sizeof(peer->cid_name));
17133 } else if (!strcasecmp(v->name, "cid_number")) {
17134 ast_copy_string(peer->cid_num, v->value, sizeof(peer->cid_num));
17135 } else if (!strcasecmp(v->name, "context")) {
17136 ast_copy_string(peer->context, v->value, sizeof(peer->context));
17137 } else if (!strcasecmp(v->name, "subscribecontext")) {
17138 ast_copy_string(peer->subscribecontext, v->value, sizeof(peer->subscribecontext));
17139 } else if (!strcasecmp(v->name, "fromdomain")) {
17140 ast_copy_string(peer->fromdomain, v->value, sizeof(peer->fromdomain));
17141 } else if (!strcasecmp(v->name, "usereqphone")) {
17142 ast_set2_flag(&peer->flags[0], ast_true(v->value), SIP_USEREQPHONE);
17143 } else if (!strcasecmp(v->name, "fromuser")) {
17144 ast_copy_string(peer->fromuser, v->value, sizeof(peer->fromuser));
17145 } else if (!strcasecmp(v->name, "host") || !strcasecmp(v->name, "outboundproxy")) {
17146 if (!strcasecmp(v->value, "dynamic")) {
17147 if (!strcasecmp(v->name, "outboundproxy") || obproxyfound) {
17148 ast_log(LOG_WARNING, "You can't have a dynamic outbound proxy, you big silly head at line %d.\n", v->lineno);
17149 } else {
17150
17151 if (!found || !ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC)) {
17152
17153
17154 memset(&peer->addr.sin_addr, 0, 4);
17155 if (peer->addr.sin_port) {
17156
17157 peer->defaddr.sin_port = peer->addr.sin_port;
17158 peer->addr.sin_port = 0;
17159 }
17160 }
17161 ast_set_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC);
17162 }
17163 } else {
17164
17165 if (!AST_SCHED_DEL(sched, peer->expire)) {
17166 struct sip_peer *peer_ptr = peer;
17167 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
17168 }
17169 ast_clear_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC);
17170 if (!obproxyfound || !strcasecmp(v->name, "outboundproxy")) {
17171 if (ast_get_ip_or_srv(&peer->addr, v->value, srvlookup ? "_sip._udp" : NULL)) {
17172 ASTOBJ_UNREF(peer, sip_destroy_peer);
17173 return NULL;
17174 }
17175 }
17176 if (!strcasecmp(v->name, "outboundproxy"))
17177 obproxyfound=1;
17178 else {
17179 ast_copy_string(peer->tohost, v->value, sizeof(peer->tohost));
17180 if (!peer->addr.sin_port)
17181 peer->addr.sin_port = htons(STANDARD_SIP_PORT);
17182 }
17183 }
17184 } else if (!strcasecmp(v->name, "defaultip")) {
17185 if (ast_get_ip(&peer->defaddr, v->value)) {
17186 ASTOBJ_UNREF(peer, sip_destroy_peer);
17187 return NULL;
17188 }
17189 } else if (!strcasecmp(v->name, "permit") || !strcasecmp(v->name, "deny")) {
17190 peer->ha = ast_append_ha(v->name, v->value, peer->ha);
17191 } else if (!strcasecmp(v->name, "port")) {
17192 if (!realtime && ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC))
17193 peer->defaddr.sin_port = htons(atoi(v->value));
17194 else
17195 peer->addr.sin_port = htons(atoi(v->value));
17196 } else if (!strcasecmp(v->name, "callingpres")) {
17197 peer->callingpres = ast_parse_caller_presentation(v->value);
17198 if (peer->callingpres == -1)
17199 peer->callingpres = atoi(v->value);
17200 } else if (!strcasecmp(v->name, "username")) {
17201 ast_copy_string(peer->username, v->value, sizeof(peer->username));
17202 } else if (!strcasecmp(v->name, "language")) {
17203 ast_copy_string(peer->language, v->value, sizeof(peer->language));
17204 } else if (!strcasecmp(v->name, "regexten")) {
17205 ast_copy_string(peer->regexten, v->value, sizeof(peer->regexten));
17206 } else if (!strcasecmp(v->name, "call-limit") || !strcasecmp(v->name, "incominglimit")) {
17207 peer->call_limit = atoi(v->value);
17208 if (peer->call_limit < 0)
17209 peer->call_limit = 0;
17210 } else if (!strcasecmp(v->name, "amaflags")) {
17211 format = ast_cdr_amaflags2int(v->value);
17212 if (format < 0) {
17213 ast_log(LOG_WARNING, "Invalid AMA Flags for peer: %s at line %d\n", v->value, v->lineno);
17214 } else {
17215 peer->amaflags = format;
17216 }
17217 } else if (!strcasecmp(v->name, "accountcode")) {
17218 ast_copy_string(peer->accountcode, v->value, sizeof(peer->accountcode));
17219 } else if (!strcasecmp(v->name, "mohinterpret")
17220 || !strcasecmp(v->name, "musicclass") || !strcasecmp(v->name, "musiconhold")) {
17221 ast_copy_string(peer->mohinterpret, v->value, sizeof(peer->mohinterpret));
17222 } else if (!strcasecmp(v->name, "mohsuggest")) {
17223 ast_copy_string(peer->mohsuggest, v->value, sizeof(peer->mohsuggest));
17224 } else if (!strcasecmp(v->name, "mailbox")) {
17225 ast_copy_string(peer->mailbox, v->value, sizeof(peer->mailbox));
17226 } else if (!strcasecmp(v->name, "subscribemwi")) {
17227 ast_set2_flag(&peer->flags[1], ast_true(v->value), SIP_PAGE2_SUBSCRIBEMWIONLY);
17228 } else if (!strcasecmp(v->name, "vmexten")) {
17229 ast_copy_string(peer->vmexten, v->value, sizeof(peer->vmexten));
17230 } else if (!strcasecmp(v->name, "callgroup")) {
17231 peer->callgroup = ast_get_group(v->value);
17232 } else if (!strcasecmp(v->name, "allowtransfer")) {
17233 peer->allowtransfer = ast_true(v->value) ? TRANSFER_OPENFORALL : TRANSFER_CLOSED;
17234 } else if (!strcasecmp(v->name, "pickupgroup")) {
17235 peer->pickupgroup = ast_get_group(v->value);
17236 } else if (!strcasecmp(v->name, "allow")) {
17237 ast_parse_allow_disallow(&peer->prefs, &peer->capability, v->value, 1);
17238 } else if (!strcasecmp(v->name, "disallow")) {
17239 ast_parse_allow_disallow(&peer->prefs, &peer->capability, v->value, 0);
17240 } else if (!strcasecmp(v->name, "autoframing")) {
17241 peer->autoframing = ast_true(v->value);
17242 } else if (!strcasecmp(v->name, "rtptimeout")) {
17243 if ((sscanf(v->value, "%d", &peer->rtptimeout) != 1) || (peer->rtptimeout < 0)) {
17244 ast_log(LOG_WARNING, "'%s' is not a valid RTP hold time at line %d. Using default.\n", v->value, v->lineno);
17245 peer->rtptimeout = global_rtptimeout;
17246 }
17247 } else if (!strcasecmp(v->name, "rtpholdtimeout")) {
17248 if ((sscanf(v->value, "%d", &peer->rtpholdtimeout) != 1) || (peer->rtpholdtimeout < 0)) {
17249 ast_log(LOG_WARNING, "'%s' is not a valid RTP hold time at line %d. Using default.\n", v->value, v->lineno);
17250 peer->rtpholdtimeout = global_rtpholdtimeout;
17251 }
17252 } else if (!strcasecmp(v->name, "rtpkeepalive")) {
17253 if ((sscanf(v->value, "%d", &peer->rtpkeepalive) != 1) || (peer->rtpkeepalive < 0)) {
17254 ast_log(LOG_WARNING, "'%s' is not a valid RTP keepalive time at line %d. Using default.\n", v->value, v->lineno);
17255 peer->rtpkeepalive = global_rtpkeepalive;
17256 }
17257 } else if (!strcasecmp(v->name, "setvar")) {
17258
17259 varname = ast_strdupa(v->value);
17260 if ((varval = strchr(varname, '='))) {
17261 *varval++ = '\0';
17262 if ((tmpvar = ast_variable_new(varname, varval))) {
17263 tmpvar->next = peer->chanvars;
17264 peer->chanvars = tmpvar;
17265 }
17266 }
17267 } else if (!strcasecmp(v->name, "qualify")) {
17268 if (!strcasecmp(v->value, "no")) {
17269 peer->maxms = 0;
17270 } else if (!strcasecmp(v->value, "yes")) {
17271 peer->maxms = default_qualify ? default_qualify : DEFAULT_MAXMS;
17272 } else if (sscanf(v->value, "%d", &peer->maxms) != 1) {
17273 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);
17274 peer->maxms = 0;
17275 }
17276 } else if (!strcasecmp(v->name, "maxcallbitrate")) {
17277 peer->maxcallbitrate = atoi(v->value);
17278 if (peer->maxcallbitrate < 0)
17279 peer->maxcallbitrate = default_maxcallbitrate;
17280 }
17281 }
17282 if (!ast_strlen_zero(fullcontact)) {
17283 ast_copy_string(peer->fullcontact, fullcontact, sizeof(peer->fullcontact));
17284 }
17285
17286 if (!ast_test_flag(&global_flags[1], SIP_PAGE2_IGNOREREGEXPIRE) && ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC) && realtime) {
17287 time_t nowtime = time(NULL);
17288
17289 if ((nowtime - regseconds) > 0) {
17290 destroy_association(peer);
17291 memset(&peer->addr, 0, sizeof(peer->addr));
17292 if (option_debug)
17293 ast_log(LOG_DEBUG, "Bah, we're expired (%d/%d/%d)!\n", (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
17294 }
17295 }
17296 ast_copy_flags(&peer->flags[0], &peerflags[0], mask[0].flags);
17297 ast_copy_flags(&peer->flags[1], &peerflags[1], mask[1].flags);
17298 if (ast_test_flag(&peer->flags[1], SIP_PAGE2_ALLOWSUBSCRIBE))
17299 global_allowsubscribe = TRUE;
17300 if (!found && ast_test_flag(&peer->flags[1], SIP_PAGE2_DYNAMIC) && !ast_test_flag(&peer->flags[0], SIP_REALTIME))
17301 reg_source_db(peer);
17302 ASTOBJ_UNMARK(peer);
17303 ast_free_ha(oldha);
17304 return peer;
17305 }
17306
17307 static void display_nat_warning(const char *cat, int reason, struct ast_flags *flags) {
17308 int global_nat, specific_nat;
17309
17310 if (reason == CHANNEL_MODULE_LOAD && (specific_nat = ast_test_flag(&flags[0], SIP_NAT)) != (global_nat = ast_test_flag(&global_flags[0], SIP_NAT))) {
17311 ast_log(LOG_WARNING, "sip.conf: Different 'nat' settings between [general] and section [%s]. See /usr/share/doc/asterisk/README.Debian.gz (global='%s' peer/user='%s')\n",
17312 cat, nat2str(global_nat), nat2str(specific_nat));
17313 }
17314 }
17315
17316
17317
17318
17319
17320
17321
17322 static int reload_config(enum channelreloadreason reason)
17323 {
17324 struct ast_config *cfg, *ucfg;
17325 struct ast_variable *v;
17326 struct sip_peer *peer;
17327 struct sip_user *user;
17328 struct ast_hostent ahp;
17329 char *cat, *stringp, *context, *oldregcontext;
17330 char newcontexts[AST_MAX_CONTEXT], oldcontexts[AST_MAX_CONTEXT];
17331 struct hostent *hp;
17332 int format;
17333 struct ast_flags dummy[2];
17334 int auto_sip_domains = FALSE;
17335 struct sockaddr_in old_bindaddr = bindaddr;
17336 int registry_count = 0, peer_count = 0, user_count = 0;
17337 unsigned int temp_tos = 0;
17338 struct ast_flags debugflag = {0};
17339
17340 cfg = ast_config_load(config);
17341
17342
17343 if (!cfg) {
17344 ast_log(LOG_NOTICE, "Unable to load config %s\n", config);
17345 return -1;
17346 }
17347
17348 if (option_debug > 3)
17349 ast_log(LOG_DEBUG, "--------------- SIP reload started\n");
17350
17351 clear_realm_authentication(authl);
17352 clear_sip_domains();
17353 authl = NULL;
17354
17355
17356
17357 ASTOBJ_CONTAINER_TRAVERSE(®l, 1, do {
17358 ASTOBJ_RDLOCK(iterator);
17359 if (iterator->call) {
17360 if (option_debug > 2)
17361 ast_log(LOG_DEBUG, "Destroying active SIP dialog for registry %s@%s\n", iterator->username, iterator->hostname);
17362
17363 sip_destroy(iterator->call);
17364 }
17365 ASTOBJ_UNLOCK(iterator);
17366
17367 } while(0));
17368
17369
17370 ASTOBJ_CONTAINER_DESTROYALL(&userl, sip_destroy_user);
17371 if (option_debug > 3)
17372 ast_log(LOG_DEBUG, "--------------- Done destroying user list\n");
17373 ASTOBJ_CONTAINER_DESTROYALL(®l, sip_registry_destroy);
17374 if (option_debug > 3)
17375 ast_log(LOG_DEBUG, "--------------- Done destroying registry list\n");
17376 ASTOBJ_CONTAINER_MARKALL(&peerl);
17377
17378
17379 ast_copy_string(oldcontexts, global_regcontext, sizeof(oldcontexts));
17380 oldregcontext = oldcontexts;
17381
17382
17383
17384 ast_copy_flags(&debugflag, &global_flags[1], SIP_PAGE2_DEBUG_CONSOLE);
17385 ast_clear_flag(&global_flags[0], AST_FLAGS_ALL);
17386 ast_clear_flag(&global_flags[1], AST_FLAGS_ALL);
17387 ast_copy_flags(&global_flags[1], &debugflag, SIP_PAGE2_DEBUG_CONSOLE);
17388
17389
17390 memset(&bindaddr, 0, sizeof(bindaddr));
17391 ast_free_ha(localaddr);
17392 memset(&localaddr, 0, sizeof(localaddr));
17393 memset(&externip, 0, sizeof(externip));
17394 memset(&default_prefs, 0 , sizeof(default_prefs));
17395 outboundproxyip.sin_port = htons(STANDARD_SIP_PORT);
17396 outboundproxyip.sin_family = AF_INET;
17397 ourport = STANDARD_SIP_PORT;
17398 srvlookup = DEFAULT_SRVLOOKUP;
17399 global_tos_sip = DEFAULT_TOS_SIP;
17400 global_tos_audio = DEFAULT_TOS_AUDIO;
17401 global_tos_video = DEFAULT_TOS_VIDEO;
17402 externhost[0] = '\0';
17403 externexpire = 0;
17404 externrefresh = 10;
17405 memset(&outboundproxyip, 0, sizeof(outboundproxyip));
17406
17407
17408 allow_external_domains = DEFAULT_ALLOW_EXT_DOM;
17409 global_regcontext[0] = '\0';
17410 expiry = DEFAULT_EXPIRY;
17411 global_notifyringing = DEFAULT_NOTIFYRINGING;
17412 global_limitonpeers = FALSE;
17413 global_directrtpsetup = FALSE;
17414 global_notifyhold = FALSE;
17415 global_alwaysauthreject = 0;
17416 global_allowsubscribe = FALSE;
17417 ast_copy_string(global_useragent, DEFAULT_USERAGENT, sizeof(global_useragent));
17418 ast_copy_string(default_notifymime, DEFAULT_NOTIFYMIME, sizeof(default_notifymime));
17419 if (ast_strlen_zero(ast_config_AST_SYSTEM_NAME))
17420 ast_copy_string(global_realm, DEFAULT_REALM, sizeof(global_realm));
17421 else
17422 ast_copy_string(global_realm, ast_config_AST_SYSTEM_NAME, sizeof(global_realm));
17423 ast_copy_string(default_callerid, DEFAULT_CALLERID, sizeof(default_callerid));
17424 compactheaders = DEFAULT_COMPACTHEADERS;
17425 global_reg_timeout = DEFAULT_REGISTRATION_TIMEOUT;
17426 global_regattempts_max = 0;
17427 pedanticsipchecking = DEFAULT_PEDANTIC;
17428 global_mwitime = DEFAULT_MWITIME;
17429 autocreatepeer = DEFAULT_AUTOCREATEPEER;
17430 global_autoframing = 0;
17431 global_allowguest = DEFAULT_ALLOWGUEST;
17432 global_rtptimeout = 0;
17433 global_rtpholdtimeout = 0;
17434 global_rtpkeepalive = 0;
17435 global_allowtransfer = TRANSFER_OPENFORALL;
17436 global_rtautoclear = 120;
17437 ast_set_flag(&global_flags[1], SIP_PAGE2_ALLOWSUBSCRIBE);
17438 ast_set_flag(&global_flags[1], SIP_PAGE2_ALLOWOVERLAP);
17439 ast_set_flag(&global_flags[1], SIP_PAGE2_RTUPDATE);
17440
17441
17442 ast_copy_string(default_context, DEFAULT_CONTEXT, sizeof(default_context));
17443 default_subscribecontext[0] = '\0';
17444 default_language[0] = '\0';
17445 default_fromdomain[0] = '\0';
17446 default_qualify = DEFAULT_QUALIFY;
17447 default_maxcallbitrate = DEFAULT_MAX_CALL_BITRATE;
17448 ast_copy_string(default_mohinterpret, DEFAULT_MOHINTERPRET, sizeof(default_mohinterpret));
17449 ast_copy_string(default_mohsuggest, DEFAULT_MOHSUGGEST, sizeof(default_mohsuggest));
17450 ast_copy_string(default_vmexten, DEFAULT_VMEXTEN, sizeof(default_vmexten));
17451 ast_set_flag(&global_flags[0], SIP_DTMF_RFC2833);
17452 ast_set_flag(&global_flags[0], SIP_NAT_RFC3581);
17453 ast_set_flag(&global_flags[0], SIP_CAN_REINVITE);
17454 ast_set_flag(&global_flags[0], SIP_NAT_ALWAYS);
17455
17456
17457 dumphistory = FALSE;
17458 recordhistory = FALSE;
17459 ast_clear_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONFIG);
17460
17461
17462 global_relaxdtmf = FALSE;
17463 global_callevents = FALSE;
17464 global_t1min = DEFAULT_T1MIN;
17465
17466 global_matchexterniplocally = FALSE;
17467
17468
17469 memcpy(&global_jbconf, &default_jbconf, sizeof(struct ast_jb_conf));
17470
17471 ast_clear_flag(&global_flags[1], SIP_PAGE2_VIDEOSUPPORT);
17472
17473
17474 for (v = ast_variable_browse(cfg, "general"); v; v = v->next) {
17475 if (handle_common_options(&global_flags[0], &dummy[0], v))
17476 continue;
17477
17478 if (!ast_jb_read_conf(&global_jbconf, v->name, v->value))
17479 continue;
17480
17481
17482 if (!strcasecmp(v->name, "context")) {
17483 ast_copy_string(default_context, v->value, sizeof(default_context));
17484 } else if (!strcasecmp(v->name, "subscribecontext")) {
17485 ast_copy_string(default_subscribecontext, v->value, sizeof(default_subscribecontext));
17486 } else if (!strcasecmp(v->name, "allowguest")) {
17487 global_allowguest = ast_true(v->value) ? 1 : 0;
17488 } else if (!strcasecmp(v->name, "realm")) {
17489 ast_copy_string(global_realm, v->value, sizeof(global_realm));
17490 } else if (!strcasecmp(v->name, "useragent")) {
17491 ast_copy_string(global_useragent, v->value, sizeof(global_useragent));
17492 if (option_debug)
17493 ast_log(LOG_DEBUG, "Setting SIP channel User-Agent Name to %s\n", global_useragent);
17494 } else if (!strcasecmp(v->name, "allowtransfer")) {
17495 global_allowtransfer = ast_true(v->value) ? TRANSFER_OPENFORALL : TRANSFER_CLOSED;
17496 } else if (!strcasecmp(v->name, "rtcachefriends")) {
17497 ast_set2_flag(&global_flags[1], ast_true(v->value), SIP_PAGE2_RTCACHEFRIENDS);
17498 } else if (!strcasecmp(v->name, "rtsavesysname")) {
17499 ast_set2_flag(&global_flags[1], ast_true(v->value), SIP_PAGE2_RTSAVE_SYSNAME);
17500 } else if (!strcasecmp(v->name, "rtupdate")) {
17501 ast_set2_flag(&global_flags[1], ast_true(v->value), SIP_PAGE2_RTUPDATE);
17502 } else if (!strcasecmp(v->name, "ignoreregexpire")) {
17503 ast_set2_flag(&global_flags[1], ast_true(v->value), SIP_PAGE2_IGNOREREGEXPIRE);
17504 } else if (!strcasecmp(v->name, "t1min")) {
17505 global_t1min = atoi(v->value);
17506 } else if (!strcasecmp(v->name, "rtautoclear")) {
17507 int i = atoi(v->value);
17508 if (i > 0)
17509 global_rtautoclear = i;
17510 else
17511 i = 0;
17512 ast_set2_flag(&global_flags[1], i || ast_true(v->value), SIP_PAGE2_RTAUTOCLEAR);
17513 } else if (!strcasecmp(v->name, "usereqphone")) {
17514 ast_set2_flag(&global_flags[0], ast_true(v->value), SIP_USEREQPHONE);
17515 } else if (!strcasecmp(v->name, "relaxdtmf")) {
17516 global_relaxdtmf = ast_true(v->value);
17517 } else if (!strcasecmp(v->name, "checkmwi")) {
17518 if ((sscanf(v->value, "%d", &global_mwitime) != 1) || (global_mwitime < 0)) {
17519 ast_log(LOG_WARNING, "'%s' is not a valid MWI time setting at line %d. Using default (10).\n", v->value, v->lineno);
17520 global_mwitime = DEFAULT_MWITIME;
17521 }
17522 } else if (!strcasecmp(v->name, "vmexten")) {
17523 ast_copy_string(default_vmexten, v->value, sizeof(default_vmexten));
17524 } else if (!strcasecmp(v->name, "rtptimeout")) {
17525 if ((sscanf(v->value, "%d", &global_rtptimeout) != 1) || (global_rtptimeout < 0)) {
17526 ast_log(LOG_WARNING, "'%s' is not a valid RTP hold time at line %d. Using default.\n", v->value, v->lineno);
17527 global_rtptimeout = 0;
17528 }
17529 } else if (!strcasecmp(v->name, "rtpholdtimeout")) {
17530 if ((sscanf(v->value, "%d", &global_rtpholdtimeout) != 1) || (global_rtpholdtimeout < 0)) {
17531 ast_log(LOG_WARNING, "'%s' is not a valid RTP hold time at line %d. Using default.\n", v->value, v->lineno);
17532 global_rtpholdtimeout = 0;
17533 }
17534 } else if (!strcasecmp(v->name, "rtpkeepalive")) {
17535 if ((sscanf(v->value, "%d", &global_rtpkeepalive) != 1) || (global_rtpkeepalive < 0)) {
17536 ast_log(LOG_WARNING, "'%s' is not a valid RTP keepalive time at line %d. Using default.\n", v->value, v->lineno);
17537 global_rtpkeepalive = 0;
17538 }
17539 } else if (!strcasecmp(v->name, "compactheaders")) {
17540 compactheaders = ast_true(v->value);
17541 } else if (!strcasecmp(v->name, "notifymimetype")) {
17542 ast_copy_string(default_notifymime, v->value, sizeof(default_notifymime));
17543 } else if (!strncasecmp(v->name, "limitonpeer", 11)) {
17544 global_limitonpeers = ast_true(v->value);
17545 } else if (!strcasecmp(v->name, "directrtpsetup")) {
17546 global_directrtpsetup = ast_true(v->value);
17547 } else if (!strcasecmp(v->name, "notifyringing")) {
17548 global_notifyringing = ast_true(v->value);
17549 } else if (!strcasecmp(v->name, "notifyhold")) {
17550 global_notifyhold = ast_true(v->value);
17551 } else if (!strcasecmp(v->name, "alwaysauthreject")) {
17552 global_alwaysauthreject = ast_true(v->value);
17553 } else if (!strcasecmp(v->name, "mohinterpret")
17554 || !strcasecmp(v->name, "musicclass") || !strcasecmp(v->name, "musiconhold")) {
17555 ast_copy_string(default_mohinterpret, v->value, sizeof(default_mohinterpret));
17556 } else if (!strcasecmp(v->name, "mohsuggest")) {
17557 ast_copy_string(default_mohsuggest, v->value, sizeof(default_mohsuggest));
17558 } else if (!strcasecmp(v->name, "language")) {
17559 ast_copy_string(default_language, v->value, sizeof(default_language));
17560 } else if (!strcasecmp(v->name, "regcontext")) {
17561 ast_copy_string(newcontexts, v->value, sizeof(newcontexts));
17562 stringp = newcontexts;
17563
17564 cleanup_stale_contexts(stringp, oldregcontext);
17565
17566 while ((context = strsep(&stringp, "&"))) {
17567 if (!ast_context_find(context))
17568 ast_context_create(NULL, context,"SIP");
17569 }
17570 ast_copy_string(global_regcontext, v->value, sizeof(global_regcontext));
17571 } else if (!strcasecmp(v->name, "callerid")) {
17572 ast_copy_string(default_callerid, v->value, sizeof(default_callerid));
17573 } else if (!strcasecmp(v->name, "fromdomain")) {
17574 ast_copy_string(default_fromdomain, v->value, sizeof(default_fromdomain));
17575 } else if (!strcasecmp(v->name, "outboundproxy")) {
17576 if (ast_get_ip_or_srv(&outboundproxyip, v->value, srvlookup ? "_sip._udp" : NULL) < 0)
17577 ast_log(LOG_WARNING, "Unable to locate host '%s'\n", v->value);
17578 } else if (!strcasecmp(v->name, "outboundproxyport")) {
17579
17580 sscanf(v->value, "%d", &format);
17581 outboundproxyip.sin_port = htons(format);
17582 } else if (!strcasecmp(v->name, "autocreatepeer")) {
17583 autocreatepeer = ast_true(v->value);
17584 } else if (!strcasecmp(v->name, "srvlookup")) {
17585 srvlookup = ast_true(v->value);
17586 } else if (!strcasecmp(v->name, "pedantic")) {
17587 pedanticsipchecking = ast_true(v->value);
17588 } else if (!strcasecmp(v->name, "maxexpirey") || !strcasecmp(v->name, "maxexpiry")) {
17589 max_expiry = atoi(v->value);
17590 if (max_expiry < 1)
17591 max_expiry = DEFAULT_MAX_EXPIRY;
17592 } else if (!strcasecmp(v->name, "minexpirey") || !strcasecmp(v->name, "minexpiry")) {
17593 min_expiry = atoi(v->value);
17594 if (min_expiry < 1)
17595 min_expiry = DEFAULT_MIN_EXPIRY;
17596 } else if (!strcasecmp(v->name, "defaultexpiry") || !strcasecmp(v->name, "defaultexpirey")) {
17597 default_expiry = atoi(v->value);
17598 if (default_expiry < 1)
17599 default_expiry = DEFAULT_DEFAULT_EXPIRY;
17600 } else if (!strcasecmp(v->name, "sipdebug")) {
17601 if (ast_true(v->value))
17602 ast_set_flag(&global_flags[1], SIP_PAGE2_DEBUG_CONFIG);
17603 } else if (!strcasecmp(v->name, "dumphistory")) {
17604 dumphistory = ast_true(v->value);
17605 } else if (!strcasecmp(v->name, "recordhistory")) {
17606 recordhistory = ast_true(v->value);
17607 } else if (!strcasecmp(v->name, "registertimeout")) {
17608 global_reg_timeout = atoi(v->value);
17609 if (global_reg_timeout < 1)
17610 global_reg_timeout = DEFAULT_REGISTRATION_TIMEOUT;
17611 } else if (!strcasecmp(v->name, "registerattempts")) {
17612 global_regattempts_max = atoi(v->value);
17613 } else if (!strcasecmp(v->name, "bindaddr")) {
17614 if (!(hp = ast_gethostbyname(v->value, &ahp))) {
17615 ast_log(LOG_WARNING, "Invalid address: %s\n", v->value);
17616 } else {
17617 memcpy(&bindaddr.sin_addr, hp->h_addr, sizeof(bindaddr.sin_addr));
17618 }
17619 } else if (!strcasecmp(v->name, "localnet")) {
17620 struct ast_ha *na;
17621 if (!(na = ast_append_ha("d", v->value, localaddr)))
17622 ast_log(LOG_WARNING, "Invalid localnet value: %s\n", v->value);
17623 else
17624 localaddr = na;
17625 } else if (!strcasecmp(v->name, "localmask")) {
17626 ast_log(LOG_WARNING, "Use of localmask is no long supported -- use localnet with mask syntax\n");
17627 } else if (!strcasecmp(v->name, "externip")) {
17628 if (!(hp = ast_gethostbyname(v->value, &ahp)))
17629 ast_log(LOG_WARNING, "Invalid address for externip keyword: %s\n", v->value);
17630 else
17631 memcpy(&externip.sin_addr, hp->h_addr, sizeof(externip.sin_addr));
17632 externexpire = 0;
17633 } else if (!strcasecmp(v->name, "externhost")) {
17634 ast_copy_string(externhost, v->value, sizeof(externhost));
17635 if (!(hp = ast_gethostbyname(externhost, &ahp)))
17636 ast_log(LOG_WARNING, "Invalid address for externhost keyword: %s\n", externhost);
17637 else
17638 memcpy(&externip.sin_addr, hp->h_addr, sizeof(externip.sin_addr));
17639 externexpire = time(NULL);
17640 } else if (!strcasecmp(v->name, "externrefresh")) {
17641 if (sscanf(v->value, "%d", &externrefresh) != 1) {
17642 ast_log(LOG_WARNING, "Invalid externrefresh value '%s', must be an integer >0 at line %d\n", v->value, v->lineno);
17643 externrefresh = 10;
17644 }
17645 } else if (!strcasecmp(v->name, "allow")) {
17646 ast_parse_allow_disallow(&default_prefs, &global_capability, v->value, 1);
17647 } else if (!strcasecmp(v->name, "disallow")) {
17648 ast_parse_allow_disallow(&default_prefs, &global_capability, v->value, 0);
17649 } else if (!strcasecmp(v->name, "autoframing")) {
17650 global_autoframing = ast_true(v->value);
17651 } else if (!strcasecmp(v->name, "allowexternaldomains")) {
17652 allow_external_domains = ast_true(v->value);
17653 } else if (!strcasecmp(v->name, "autodomain")) {
17654 auto_sip_domains = ast_true(v->value);
17655 } else if (!strcasecmp(v->name, "domain")) {
17656 char *domain = ast_strdupa(v->value);
17657 char *context = strchr(domain, ',');
17658
17659 if (context)
17660 *context++ = '\0';
17661
17662 if (option_debug && ast_strlen_zero(context))
17663 ast_log(LOG_DEBUG, "No context specified at line %d for domain '%s'\n", v->lineno, domain);
17664 if (ast_strlen_zero(domain))
17665 ast_log(LOG_WARNING, "Empty domain specified at line %d\n", v->lineno);
17666 else
17667 add_sip_domain(ast_strip(domain), SIP_DOMAIN_CONFIG, context ? ast_strip(context) : "");
17668 } else if (!strcasecmp(v->name, "register")) {
17669 if (sip_register(v->value, v->lineno) == 0)
17670 registry_count++;
17671 } else if (!strcasecmp(v->name, "tos")) {
17672 if (!ast_str2tos(v->value, &temp_tos)) {
17673 global_tos_sip = temp_tos;
17674 global_tos_audio = temp_tos;
17675 global_tos_video = temp_tos;
17676 ast_log(LOG_WARNING, "tos value at line %d is deprecated. See doc/ip-tos.txt for more information.\n", v->lineno);
17677 } else
17678 ast_log(LOG_WARNING, "Invalid tos value at line %d, See doc/ip-tos.txt for more information.\n", v->lineno);
17679 } else if (!strcasecmp(v->name, "tos_sip")) {
17680 if (ast_str2tos(v->value, &global_tos_sip))
17681 ast_log(LOG_WARNING, "Invalid tos_sip value at line %d, recommended value is 'cs3'. See doc/ip-tos.txt.\n", v->lineno);
17682 } else if (!strcasecmp(v->name, "tos_audio")) {
17683 if (ast_str2tos(v->value, &global_tos_audio))
17684 ast_log(LOG_WARNING, "Invalid tos_audio value at line %d, recommended value is 'ef'. See doc/ip-tos.txt.\n", v->lineno);
17685 } else if (!strcasecmp(v->name, "tos_video")) {
17686 if (ast_str2tos(v->value, &global_tos_video))
17687 ast_log(LOG_WARNING, "Invalid tos_video value at line %d, recommended value is 'af41'. See doc/ip-tos.txt.\n", v->lineno);
17688 } else if (!strcasecmp(v->name, "bindport")) {
17689 if (sscanf(v->value, "%d", &ourport) == 1) {
17690 bindaddr.sin_port = htons(ourport);
17691 } else {
17692 ast_log(LOG_WARNING, "Invalid port number '%s' at line %d of %s\n", v->value, v->lineno, config);
17693 }
17694 } else if (!strcasecmp(v->name, "qualify")) {
17695 if (!strcasecmp(v->value, "no")) {
17696 default_qualify = 0;
17697 } else if (!strcasecmp(v->value, "yes")) {
17698 default_qualify = DEFAULT_MAXMS;
17699 } else if (sscanf(v->value, "%d", &default_qualify) != 1) {
17700 ast_log(LOG_WARNING, "Qualification default should be 'yes', 'no', or a number of milliseconds at line %d of sip.conf\n", v->lineno);
17701 default_qualify = 0;
17702 }
17703 } else if (!strcasecmp(v->name, "callevents")) {
17704 global_callevents = ast_true(v->value);
17705 } else if (!strcasecmp(v->name, "maxcallbitrate")) {
17706 default_maxcallbitrate = atoi(v->value);
17707 if (default_maxcallbitrate < 0)
17708 default_maxcallbitrate = DEFAULT_MAX_CALL_BITRATE;
17709 } else if (!strcasecmp(v->name, "matchexterniplocally")) {
17710 global_matchexterniplocally = ast_true(v->value);
17711 }
17712 }
17713
17714 if (!allow_external_domains && AST_LIST_EMPTY(&domain_list)) {
17715 ast_log(LOG_WARNING, "To disallow external domains, you need to configure local SIP domains.\n");
17716 allow_external_domains = 1;
17717 }
17718
17719
17720 for (v = ast_variable_browse(cfg, "authentication"); v ; v = v->next) {
17721
17722 if (!strcasecmp(v->name, "auth"))
17723 authl = add_realm_authentication(authl, v->value, v->lineno);
17724 }
17725
17726 ucfg = ast_config_load("users.conf");
17727 if (ucfg) {
17728 struct ast_variable *gen;
17729 int genhassip, genregistersip;
17730 const char *hassip, *registersip;
17731
17732 genhassip = ast_true(ast_variable_retrieve(ucfg, "general", "hassip"));
17733 genregistersip = ast_true(ast_variable_retrieve(ucfg, "general", "registersip"));
17734 gen = ast_variable_browse(ucfg, "general");
17735 cat = ast_category_browse(ucfg, NULL);
17736 while (cat) {
17737 if (strcasecmp(cat, "general")) {
17738 hassip = ast_variable_retrieve(ucfg, cat, "hassip");
17739 registersip = ast_variable_retrieve(ucfg, cat, "registersip");
17740 if (ast_true(hassip) || (!hassip && genhassip)) {
17741 user = build_user(cat, gen, ast_variable_browse(ucfg, cat), 0);
17742 if (user) {
17743 ASTOBJ_CONTAINER_LINK(&userl,user);
17744 ASTOBJ_UNREF(user, sip_destroy_user);
17745 user_count++;
17746 }
17747 peer = build_peer(cat, gen, ast_variable_browse(ucfg, cat), 0);
17748 if (peer) {
17749 ast_device_state_changed("SIP/%s", peer->name);
17750 ASTOBJ_CONTAINER_LINK(&peerl,peer);
17751 ASTOBJ_UNREF(peer, sip_destroy_peer);
17752 peer_count++;
17753 }
17754 }
17755 if (ast_true(registersip) || (!registersip && genregistersip)) {
17756 char tmp[256];
17757 const char *host = ast_variable_retrieve(ucfg, cat, "host");
17758 const char *username = ast_variable_retrieve(ucfg, cat, "username");
17759 const char *secret = ast_variable_retrieve(ucfg, cat, "secret");
17760 const char *contact = ast_variable_retrieve(ucfg, cat, "contact");
17761 if (!host)
17762 host = ast_variable_retrieve(ucfg, "general", "host");
17763 if (!username)
17764 username = ast_variable_retrieve(ucfg, "general", "username");
17765 if (!secret)
17766 secret = ast_variable_retrieve(ucfg, "general", "secret");
17767 if (!contact)
17768 contact = "s";
17769 if (!ast_strlen_zero(username) && !ast_strlen_zero(host)) {
17770 if (!ast_strlen_zero(secret))
17771 snprintf(tmp, sizeof(tmp), "%s:%s@%s/%s", username, secret, host, contact);
17772 else
17773 snprintf(tmp, sizeof(tmp), "%s@%s/%s", username, host, contact);
17774 if (sip_register(tmp, 0) == 0)
17775 registry_count++;
17776 }
17777 }
17778 }
17779 cat = ast_category_browse(ucfg, cat);
17780 }
17781 ast_config_destroy(ucfg);
17782 }
17783
17784
17785
17786 cat = NULL;
17787 while ( (cat = ast_category_browse(cfg, cat)) ) {
17788 const char *utype;
17789 if (!strcasecmp(cat, "general") || !strcasecmp(cat, "authentication"))
17790 continue;
17791 utype = ast_variable_retrieve(cfg, cat, "type");
17792 if (!utype) {
17793 ast_log(LOG_WARNING, "Section '%s' lacks type\n", cat);
17794 continue;
17795 } else {
17796 int is_user = 0, is_peer = 0;
17797 if (!strcasecmp(utype, "user"))
17798 is_user = 1;
17799 else if (!strcasecmp(utype, "friend"))
17800 is_user = is_peer = 1;
17801 else if (!strcasecmp(utype, "peer"))
17802 is_peer = 1;
17803 else {
17804 ast_log(LOG_WARNING, "Unknown type '%s' for '%s' in %s\n", utype, cat, "sip.conf");
17805 continue;
17806 }
17807 if (is_user) {
17808 user = build_user(cat, ast_variable_browse(cfg, cat), NULL, 0);
17809 if (user) {
17810 display_nat_warning(cat, reason, &user->flags[0]);
17811 ASTOBJ_CONTAINER_LINK(&userl,user);
17812 ASTOBJ_UNREF(user, sip_destroy_user);
17813 user_count++;
17814 }
17815 }
17816 if (is_peer) {
17817 peer = build_peer(cat, ast_variable_browse(cfg, cat), NULL, 0);
17818 if (peer) {
17819 if (!is_user) {
17820 display_nat_warning(cat, reason, &peer->flags[0]);
17821 }
17822 ASTOBJ_CONTAINER_LINK(&peerl,peer);
17823 ASTOBJ_UNREF(peer, sip_destroy_peer);
17824 peer_count++;
17825 }
17826 }
17827 }
17828 }
17829
17830 if (ast_find_ourip(&__ourip, bindaddr)) {
17831 ast_log(LOG_WARNING, "Unable to get own IP address, SIP disabled\n");
17832 ast_config_destroy(cfg);
17833 return 0;
17834 }
17835 if (!ntohs(bindaddr.sin_port))
17836 bindaddr.sin_port = ntohs(STANDARD_SIP_PORT);
17837 bindaddr.sin_family = AF_INET;
17838 ast_mutex_lock(&netlock);
17839 if ((sipsock > -1) && (memcmp(&old_bindaddr, &bindaddr, sizeof(struct sockaddr_in)))) {
17840 close(sipsock);
17841 sipsock = -1;
17842 }
17843 if (sipsock < 0) {
17844 sipsock = socket(AF_INET, SOCK_DGRAM, 0);
17845 if (sipsock < 0) {
17846 ast_log(LOG_WARNING, "Unable to create SIP socket: %s\n", strerror(errno));
17847 ast_config_destroy(cfg);
17848 return -1;
17849 } else {
17850
17851 const int reuseFlag = 1;
17852
17853 setsockopt(sipsock, SOL_SOCKET, SO_REUSEADDR,
17854 (const char*)&reuseFlag,
17855 sizeof reuseFlag);
17856
17857 ast_enable_packet_fragmentation(sipsock);
17858
17859 if (bind(sipsock, (struct sockaddr *)&bindaddr, sizeof(bindaddr)) < 0) {
17860 ast_log(LOG_WARNING, "Failed to bind to %s:%d: %s\n",
17861 ast_inet_ntoa(bindaddr.sin_addr), ntohs(bindaddr.sin_port),
17862 strerror(errno));
17863 close(sipsock);
17864 sipsock = -1;
17865 } else {
17866 if (option_verbose > 1) {
17867 ast_verbose(VERBOSE_PREFIX_2 "SIP Listening on %s:%d\n",
17868 ast_inet_ntoa(bindaddr.sin_addr), ntohs(bindaddr.sin_port));
17869 ast_verbose(VERBOSE_PREFIX_2 "Using SIP TOS: %s\n", ast_tos2str(global_tos_sip));
17870 }
17871 if (setsockopt(sipsock, IPPROTO_IP, IP_TOS, &global_tos_sip, sizeof(global_tos_sip)))
17872 ast_log(LOG_WARNING, "Unable to set SIP TOS to %s\n", ast_tos2str(global_tos_sip));
17873 }
17874 }
17875 }
17876 ast_mutex_unlock(&netlock);
17877
17878
17879
17880
17881
17882 if (auto_sip_domains) {
17883 char temp[MAXHOSTNAMELEN];
17884
17885
17886 if (bindaddr.sin_addr.s_addr)
17887 add_sip_domain(ast_inet_ntoa(bindaddr.sin_addr), SIP_DOMAIN_AUTO, NULL);
17888 else
17889 ast_log(LOG_NOTICE, "Can't add wildcard IP address to domain list, please add IP address to domain manually.\n");
17890
17891
17892 if (externip.sin_addr.s_addr)
17893 add_sip_domain(ast_inet_ntoa(externip.sin_addr), SIP_DOMAIN_AUTO, NULL);
17894
17895
17896 if (!ast_strlen_zero(externhost))
17897 add_sip_domain(externhost, SIP_DOMAIN_AUTO, NULL);
17898
17899
17900 if (!gethostname(temp, sizeof(temp)))
17901 add_sip_domain(temp, SIP_DOMAIN_AUTO, NULL);
17902 }
17903
17904
17905 ast_config_destroy(cfg);
17906
17907
17908 if (notify_types)
17909 ast_config_destroy(notify_types);
17910 notify_types = ast_config_load(notify_config);
17911
17912
17913 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);
17914
17915 return 0;
17916 }
17917
17918 static struct ast_udptl *sip_get_udptl_peer(struct ast_channel *chan)
17919 {
17920 struct sip_pvt *p;
17921 struct ast_udptl *udptl = NULL;
17922
17923 p = chan->tech_pvt;
17924 if (!p)
17925 return NULL;
17926
17927 ast_mutex_lock(&p->lock);
17928 if (p->udptl && ast_test_flag(&p->flags[0], SIP_CAN_REINVITE))
17929 udptl = p->udptl;
17930 ast_mutex_unlock(&p->lock);
17931 return udptl;
17932 }
17933
17934 static int sip_set_udptl_peer(struct ast_channel *chan, struct ast_udptl *udptl)
17935 {
17936 struct sip_pvt *p;
17937
17938 p = chan->tech_pvt;
17939 if (!p)
17940 return -1;
17941 ast_mutex_lock(&p->lock);
17942 if (udptl)
17943 ast_udptl_get_peer(udptl, &p->udptlredirip);
17944 else
17945 memset(&p->udptlredirip, 0, sizeof(p->udptlredirip));
17946 if (!ast_test_flag(&p->flags[0], SIP_GOTREFER)) {
17947 if (!p->pendinginvite) {
17948 if (option_debug > 2) {
17949 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);
17950 }
17951 transmit_reinvite_with_t38_sdp(p);
17952 } else if (!ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
17953 if (option_debug > 2) {
17954 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);
17955 }
17956 ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
17957 }
17958 }
17959
17960 p->lastrtprx = p->lastrtptx = time(NULL);
17961 ast_mutex_unlock(&p->lock);
17962 return 0;
17963 }
17964
17965
17966
17967
17968
17969
17970 static int sip_handle_t38_reinvite(struct ast_channel *chan, struct sip_pvt *pvt, int reinvite)
17971 {
17972 struct sip_pvt *p;
17973 int flag = 0;
17974
17975 p = chan->tech_pvt;
17976 if (!p || !pvt->udptl)
17977 return -1;
17978
17979
17980 ast_mutex_lock(&p->lock);
17981
17982
17983
17984 p->t38.jointcapability = p->t38.peercapability = pvt->t38.jointcapability;
17985
17986 ast_udptl_set_far_max_datagram(p->udptl, ast_udptl_get_local_max_datagram(pvt->udptl));
17987 ast_udptl_set_local_max_datagram(p->udptl, ast_udptl_get_local_max_datagram(pvt->udptl));
17988 ast_udptl_set_error_correction_scheme(p->udptl, ast_udptl_get_error_correction_scheme(pvt->udptl));
17989
17990 if (reinvite) {
17991
17992
17993
17994
17995
17996 if (ast_test_flag(&p->flags[0], SIP_CAN_REINVITE) && ast_test_flag(&pvt->flags[0], SIP_CAN_REINVITE)) {
17997 ast_udptl_get_peer(pvt->udptl, &p->udptlredirip);
17998 flag =1;
17999 } else {
18000 memset(&p->udptlredirip, 0, sizeof(p->udptlredirip));
18001 }
18002 if (!ast_test_flag(&p->flags[0], SIP_GOTREFER)) {
18003 if (!p->pendinginvite) {
18004 if (option_debug > 2) {
18005 if (flag)
18006 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));
18007 else
18008 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));
18009 }
18010 transmit_reinvite_with_t38_sdp(p);
18011 } else if (!ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
18012 if (option_debug > 2) {
18013 if (flag)
18014 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));
18015 else
18016 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));
18017 }
18018 ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
18019 }
18020 }
18021
18022 p->lastrtprx = p->lastrtptx = time(NULL);
18023 ast_mutex_unlock(&p->lock);
18024 return 0;
18025 } else {
18026 if (ast_test_flag(&p->flags[0], SIP_CAN_REINVITE) && ast_test_flag(&pvt->flags[0], SIP_CAN_REINVITE)) {
18027 ast_udptl_get_peer(pvt->udptl, &p->udptlredirip);
18028 flag = 1;
18029 } else {
18030 memset(&p->udptlredirip, 0, sizeof(p->udptlredirip));
18031 }
18032 if (option_debug > 2) {
18033 if (flag)
18034 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));
18035 else
18036 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));
18037 }
18038 pvt->t38.state = T38_ENABLED;
18039 p->t38.state = T38_ENABLED;
18040 if (option_debug > 1) {
18041 ast_log(LOG_DEBUG, "T38 changed state to %d on channel %s\n", pvt->t38.state, pvt->owner ? pvt->owner->name : "<none>");
18042 ast_log(LOG_DEBUG, "T38 changed state to %d on channel %s\n", p->t38.state, chan ? chan->name : "<none>");
18043 }
18044 transmit_response_with_t38_sdp(p, "200 OK", &p->initreq, XMIT_CRITICAL);
18045 p->lastrtprx = p->lastrtptx = time(NULL);
18046 ast_mutex_unlock(&p->lock);
18047 return 0;
18048 }
18049 }
18050
18051
18052
18053 static enum ast_rtp_get_result sip_get_rtp_peer(struct ast_channel *chan, struct ast_rtp **rtp)
18054 {
18055 struct sip_pvt *p = NULL;
18056 enum ast_rtp_get_result res = AST_RTP_TRY_PARTIAL;
18057
18058 if (!(p = chan->tech_pvt))
18059 return AST_RTP_GET_FAILED;
18060
18061 ast_mutex_lock(&p->lock);
18062 if (!(p->rtp)) {
18063 ast_mutex_unlock(&p->lock);
18064 return AST_RTP_GET_FAILED;
18065 }
18066
18067 *rtp = p->rtp;
18068
18069 if (ast_rtp_getnat(*rtp) && !ast_test_flag(&p->flags[0], SIP_CAN_REINVITE_NAT))
18070 res = AST_RTP_TRY_PARTIAL;
18071 else if (ast_test_flag(&p->flags[0], SIP_CAN_REINVITE))
18072 res = AST_RTP_TRY_NATIVE;
18073 else if (ast_test_flag(&global_jbconf, AST_JB_FORCED))
18074 res = AST_RTP_GET_FAILED;
18075
18076 ast_mutex_unlock(&p->lock);
18077
18078 return res;
18079 }
18080
18081
18082 static enum ast_rtp_get_result sip_get_vrtp_peer(struct ast_channel *chan, struct ast_rtp **rtp)
18083 {
18084 struct sip_pvt *p = NULL;
18085 enum ast_rtp_get_result res = AST_RTP_TRY_PARTIAL;
18086
18087 if (!(p = chan->tech_pvt))
18088 return AST_RTP_GET_FAILED;
18089
18090 ast_mutex_lock(&p->lock);
18091 if (!(p->vrtp)) {
18092 ast_mutex_unlock(&p->lock);
18093 return AST_RTP_GET_FAILED;
18094 }
18095
18096 *rtp = p->vrtp;
18097
18098 if (ast_test_flag(&p->flags[0], SIP_CAN_REINVITE))
18099 res = AST_RTP_TRY_NATIVE;
18100
18101 ast_mutex_unlock(&p->lock);
18102
18103 return res;
18104 }
18105
18106
18107 static int sip_set_rtp_peer(struct ast_channel *chan, struct ast_rtp *rtp, struct ast_rtp *vrtp, int codecs, int nat_active)
18108 {
18109 struct sip_pvt *p;
18110 int changed = 0;
18111
18112 p = chan->tech_pvt;
18113 if (!p)
18114 return -1;
18115
18116
18117 if (chan->_state != AST_STATE_UP && !global_directrtpsetup)
18118 return 0;
18119
18120 ast_mutex_lock(&p->lock);
18121 if (ast_test_flag(&p->flags[0], SIP_ALREADYGONE)) {
18122
18123 ast_mutex_unlock(&p->lock);
18124 return 0;
18125 }
18126
18127
18128
18129
18130 if (nat_active && !ast_test_flag(&p->flags[0], SIP_CAN_REINVITE_NAT)) {
18131 ast_mutex_unlock(&p->lock);
18132 return 0;
18133 }
18134
18135 if (rtp) {
18136 changed |= ast_rtp_get_peer(rtp, &p->redirip);
18137 } else if (p->redirip.sin_addr.s_addr || ntohs(p->redirip.sin_port) != 0) {
18138 memset(&p->redirip, 0, sizeof(p->redirip));
18139 changed = 1;
18140 }
18141 if (vrtp) {
18142 changed |= ast_rtp_get_peer(vrtp, &p->vredirip);
18143 } else if (p->vredirip.sin_addr.s_addr || ntohs(p->vredirip.sin_port) != 0) {
18144 memset(&p->vredirip, 0, sizeof(p->vredirip));
18145 changed = 1;
18146 }
18147 if (codecs) {
18148 if ((p->redircodecs != codecs)) {
18149 p->redircodecs = codecs;
18150 changed = 1;
18151 }
18152 if ((p->capability & codecs) != p->capability) {
18153 p->jointcapability &= codecs;
18154 p->capability &= codecs;
18155 changed = 1;
18156 }
18157 }
18158 if (changed && !ast_test_flag(&p->flags[0], SIP_GOTREFER) && !ast_test_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER)) {
18159 if (chan->_state != AST_STATE_UP) {
18160 if (!ast_test_flag(&p->flags[0], SIP_NO_HISTORY))
18161 append_history(p, "ExtInv", "Initial invite sent with remote bridge proposal.");
18162 if (option_debug)
18163 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));
18164 } else if (!p->pendinginvite) {
18165 if (option_debug > 2) {
18166 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));
18167 }
18168 transmit_reinvite_with_sdp(p);
18169 } else if (!ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
18170 if (option_debug > 2) {
18171 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));
18172 }
18173
18174 ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
18175 }
18176 }
18177
18178 p->lastrtprx = p->lastrtptx = time(NULL);
18179 ast_mutex_unlock(&p->lock);
18180 return 0;
18181 }
18182
18183 static char *synopsis_dtmfmode = "Change the dtmfmode for a SIP call";
18184 static char *descrip_dtmfmode = "SIPDtmfMode(inband|info|rfc2833): Changes the dtmfmode for a SIP call\n";
18185 static char *app_dtmfmode = "SIPDtmfMode";
18186
18187 static char *app_sipaddheader = "SIPAddHeader";
18188 static char *synopsis_sipaddheader = "Add a SIP header to the outbound call";
18189
18190 static char *descrip_sipaddheader = ""
18191 " SIPAddHeader(Header: Content)\n"
18192 "Adds a header to a SIP call placed with DIAL.\n"
18193 "Remember to user the X-header if you are adding non-standard SIP\n"
18194 "headers, like \"X-Asterisk-Accountcode:\". Use this with care.\n"
18195 "Adding the wrong headers may jeopardize the SIP dialog.\n"
18196 "Always returns 0\n";
18197
18198
18199
18200 static int sip_dtmfmode(struct ast_channel *chan, void *data)
18201 {
18202 struct sip_pvt *p;
18203 char *mode;
18204 if (data)
18205 mode = (char *)data;
18206 else {
18207 ast_log(LOG_WARNING, "This application requires the argument: info, inband, rfc2833\n");
18208 return 0;
18209 }
18210 ast_channel_lock(chan);
18211 if (chan->tech != &sip_tech && chan->tech != &sip_tech_info) {
18212 ast_log(LOG_WARNING, "Call this application only on SIP incoming calls\n");
18213 ast_channel_unlock(chan);
18214 return 0;
18215 }
18216 p = chan->tech_pvt;
18217 if (!p) {
18218 ast_channel_unlock(chan);
18219 return 0;
18220 }
18221 ast_mutex_lock(&p->lock);
18222 if (!strcasecmp(mode,"info")) {
18223 ast_clear_flag(&p->flags[0], SIP_DTMF);
18224 ast_set_flag(&p->flags[0], SIP_DTMF_INFO);
18225 p->jointnoncodeccapability &= ~AST_RTP_DTMF;
18226 } else if (!strcasecmp(mode,"rfc2833")) {
18227 ast_clear_flag(&p->flags[0], SIP_DTMF);
18228 ast_set_flag(&p->flags[0], SIP_DTMF_RFC2833);
18229 p->jointnoncodeccapability |= AST_RTP_DTMF;
18230 } else if (!strcasecmp(mode,"inband")) {
18231 ast_clear_flag(&p->flags[0], SIP_DTMF);
18232 ast_set_flag(&p->flags[0], SIP_DTMF_INBAND);
18233 p->jointnoncodeccapability &= ~AST_RTP_DTMF;
18234 } else
18235 ast_log(LOG_WARNING, "I don't know about this dtmf mode: %s\n",mode);
18236 if (p->rtp)
18237 ast_rtp_setdtmf(p->rtp, ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833);
18238 if (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_INBAND) {
18239 if (!p->vad) {
18240 p->vad = ast_dsp_new();
18241 ast_dsp_set_features(p->vad, DSP_FEATURE_DTMF_DETECT);
18242 }
18243 } else {
18244 if (p->vad) {
18245 ast_dsp_free(p->vad);
18246 p->vad = NULL;
18247 }
18248 }
18249 ast_mutex_unlock(&p->lock);
18250 ast_channel_unlock(chan);
18251 return 0;
18252 }
18253
18254
18255 static int sip_addheader(struct ast_channel *chan, void *data)
18256 {
18257 int no = 0;
18258 int ok = FALSE;
18259 char varbuf[30];
18260 char *inbuf = (char *) data;
18261
18262 if (ast_strlen_zero(inbuf)) {
18263 ast_log(LOG_WARNING, "This application requires the argument: Header\n");
18264 return 0;
18265 }
18266 ast_channel_lock(chan);
18267
18268
18269 while (!ok && no <= 50) {
18270 no++;
18271 snprintf(varbuf, sizeof(varbuf), "_SIPADDHEADER%.2d", no);
18272
18273
18274 if( (pbx_builtin_getvar_helper(chan, (const char *) varbuf + 1) == (const char *) NULL) )
18275 ok = TRUE;
18276 }
18277 if (ok) {
18278 pbx_builtin_setvar_helper (chan, varbuf, inbuf);
18279 if (sipdebug)
18280 ast_log(LOG_DEBUG,"SIP Header added \"%s\" as %s\n", inbuf, varbuf);
18281 } else {
18282 ast_log(LOG_WARNING, "Too many SIP headers added, max 50\n");
18283 }
18284 ast_channel_unlock(chan);
18285 return 0;
18286 }
18287
18288
18289
18290
18291
18292
18293
18294 static int sip_sipredirect(struct sip_pvt *p, const char *dest)
18295 {
18296 char *cdest;
18297 char *extension, *host, *port;
18298 char tmp[80];
18299
18300 cdest = ast_strdupa(dest);
18301
18302 extension = strsep(&cdest, "@");
18303 host = strsep(&cdest, ":");
18304 port = strsep(&cdest, ":");
18305 if (ast_strlen_zero(extension)) {
18306 ast_log(LOG_ERROR, "Missing mandatory argument: extension\n");
18307 return 0;
18308 }
18309
18310
18311 if (!host) {
18312 char *localtmp;
18313 ast_copy_string(tmp, get_header(&p->initreq, "To"), sizeof(tmp));
18314 if (ast_strlen_zero(tmp)) {
18315 ast_log(LOG_ERROR, "Cannot retrieve the 'To' header from the original SIP request!\n");
18316 return 0;
18317 }
18318 if ((localtmp = strcasestr(tmp, "sip:")) && (localtmp = strchr(localtmp, '@'))) {
18319 char lhost[80], lport[80];
18320 memset(lhost, 0, sizeof(lhost));
18321 memset(lport, 0, sizeof(lport));
18322 localtmp++;
18323
18324 sscanf(localtmp, "%[^<>:; ]:%[^<>:; ]", lhost, lport);
18325 if (ast_strlen_zero(lhost)) {
18326 ast_log(LOG_ERROR, "Can't find the host address\n");
18327 return 0;
18328 }
18329 host = ast_strdupa(lhost);
18330 if (!ast_strlen_zero(lport)) {
18331 port = ast_strdupa(lport);
18332 }
18333 }
18334 }
18335
18336 ast_string_field_build(p, our_contact, "Transfer <sip:%s@%s%s%s>", extension, host, port ? ":" : "", port ? port : "");
18337 transmit_response_reliable(p, "302 Moved Temporarily", &p->initreq);
18338
18339 sip_scheddestroy(p, SIP_TRANS_TIMEOUT);
18340 sip_alreadygone(p);
18341 return 0;
18342 }
18343
18344
18345 static int sip_get_codec(struct ast_channel *chan)
18346 {
18347 struct sip_pvt *p = chan->tech_pvt;
18348 return p->peercapability ? p->peercapability : p->capability;
18349 }
18350
18351
18352
18353
18354
18355 static void sip_poke_all_peers(void)
18356 {
18357 int ms = 0;
18358
18359 if (!speerobjs)
18360 return;
18361
18362 ASTOBJ_CONTAINER_TRAVERSE(&peerl, 1, do {
18363 ASTOBJ_WRLOCK(iterator);
18364 if (!AST_SCHED_DEL(sched, iterator->pokeexpire)) {
18365 struct sip_peer *peer_ptr = iterator;
18366 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
18367 }
18368 ms += 100;
18369 iterator->pokeexpire = ast_sched_add(sched, ms, sip_poke_peer_s, ASTOBJ_REF(iterator));
18370 if (iterator->pokeexpire == -1) {
18371 struct sip_peer *peer_ptr = iterator;
18372 ASTOBJ_UNREF(peer_ptr, sip_destroy_peer);
18373 }
18374 ASTOBJ_UNLOCK(iterator);
18375 } while (0)
18376 );
18377 }
18378
18379
18380 static void sip_send_all_registers(void)
18381 {
18382 int ms;
18383 int regspacing;
18384 if (!regobjs)
18385 return;
18386 regspacing = default_expiry * 1000/regobjs;
18387 if (regspacing > 100)
18388 regspacing = 100;
18389 ms = regspacing;
18390 ASTOBJ_CONTAINER_TRAVERSE(®l, 1, do {
18391 ASTOBJ_WRLOCK(iterator);
18392 AST_SCHED_DEL(sched, iterator->expire);
18393 ms += regspacing;
18394 iterator->expire = ast_sched_add(sched, ms, sip_reregister, iterator);
18395 ASTOBJ_UNLOCK(iterator);
18396 } while (0)
18397 );
18398 }
18399
18400
18401 static int sip_do_reload(enum channelreloadreason reason)
18402 {
18403 reload_config(reason);
18404
18405
18406 ASTOBJ_CONTAINER_PRUNE_MARKED(&peerl, sip_destroy_peer);
18407 if (option_debug > 3)
18408 ast_log(LOG_DEBUG, "--------------- Done destroying pruned peers\n");
18409
18410
18411 sip_poke_all_peers();
18412
18413
18414 sip_send_all_registers();
18415
18416 if (option_debug > 3)
18417 ast_log(LOG_DEBUG, "--------------- SIP reload done\n");
18418
18419 return 0;
18420 }
18421
18422
18423 static int sip_reload(int fd, int argc, char *argv[])
18424 {
18425 ast_mutex_lock(&sip_reload_lock);
18426 if (sip_reloading)
18427 ast_verbose("Previous SIP reload not yet done\n");
18428 else {
18429 sip_reloading = TRUE;
18430 if (fd)
18431 sip_reloadreason = CHANNEL_CLI_RELOAD;
18432 else
18433 sip_reloadreason = CHANNEL_MODULE_RELOAD;
18434 }
18435 ast_mutex_unlock(&sip_reload_lock);
18436 restart_monitor();
18437
18438 return 0;
18439 }
18440
18441
18442 static int reload(void)
18443 {
18444 return sip_reload(0, 0, NULL);
18445 }
18446
18447 static struct ast_cli_entry cli_sip_debug_deprecated =
18448 { { "sip", "debug", NULL },
18449 sip_do_debug_deprecated, "Enable SIP debugging",
18450 debug_usage };
18451
18452 static struct ast_cli_entry cli_sip_no_debug_deprecated =
18453 { { "sip", "no", "debug", NULL },
18454 sip_no_debug_deprecated, "Disable SIP debugging",
18455 debug_usage };
18456
18457 static struct ast_cli_entry cli_sip[] = {
18458 { { "sip", "show", "channels", NULL },
18459 sip_show_channels, "List active SIP channels",
18460 show_channels_usage },
18461
18462 { { "sip", "show", "domains", NULL },
18463 sip_show_domains, "List our local SIP domains.",
18464 show_domains_usage },
18465
18466 { { "sip", "show", "inuse", NULL },
18467 sip_show_inuse, "List all inuse/limits",
18468 show_inuse_usage },
18469
18470 { { "sip", "show", "objects", NULL },
18471 sip_show_objects, "List all SIP object allocations",
18472 show_objects_usage },
18473
18474 { { "sip", "show", "peers", NULL },
18475 sip_show_peers, "List defined SIP peers",
18476 show_peers_usage },
18477
18478 { { "sip", "show", "registry", NULL },
18479 sip_show_registry, "List SIP registration status",
18480 show_reg_usage },
18481
18482 { { "sip", "show", "settings", NULL },
18483 sip_show_settings, "Show SIP global settings",
18484 show_settings_usage },
18485
18486 { { "sip", "show", "subscriptions", NULL },
18487 sip_show_subscriptions, "List active SIP subscriptions",
18488 show_subscriptions_usage },
18489
18490 { { "sip", "show", "users", NULL },
18491 sip_show_users, "List defined SIP users",
18492 show_users_usage },
18493
18494 { { "sip", "notify", NULL },
18495 sip_notify, "Send a notify packet to a SIP peer",
18496 notify_usage, complete_sipnotify },
18497
18498 { { "sip", "show", "channel", NULL },
18499 sip_show_channel, "Show detailed SIP channel info",
18500 show_channel_usage, complete_sipch },
18501
18502 { { "sip", "show", "history", NULL },
18503 sip_show_history, "Show SIP dialog history",
18504 show_history_usage, complete_sipch },
18505
18506 { { "sip", "show", "peer", NULL },
18507 sip_show_peer, "Show details on specific SIP peer",
18508 show_peer_usage, complete_sip_show_peer },
18509
18510 { { "sip", "show", "user", NULL },
18511 sip_show_user, "Show details on specific SIP user",
18512 show_user_usage, complete_sip_show_user },
18513
18514 { { "sip", "prune", "realtime", NULL },
18515 sip_prune_realtime, "Prune cached Realtime object(s)",
18516 prune_realtime_usage },
18517
18518 { { "sip", "prune", "realtime", "peer", NULL },
18519 sip_prune_realtime, "Prune cached Realtime peer(s)",
18520 prune_realtime_usage, complete_sip_prune_realtime_peer },
18521
18522 { { "sip", "prune", "realtime", "user", NULL },
18523 sip_prune_realtime, "Prune cached Realtime user(s)",
18524 prune_realtime_usage, complete_sip_prune_realtime_user },
18525
18526 { { "sip", "set", "debug", NULL },
18527 sip_do_debug, "Enable SIP debugging",
18528 debug_usage, NULL, &cli_sip_debug_deprecated },
18529
18530 { { "sip", "set", "debug", "ip", NULL },
18531 sip_do_debug, "Enable SIP debugging on IP",
18532 debug_usage },
18533
18534 { { "sip", "set", "debug", "peer", NULL },
18535 sip_do_debug, "Enable SIP debugging on Peername",
18536 debug_usage, complete_sip_debug_peer },
18537
18538 { { "sip", "set", "debug", "off", NULL },
18539 sip_no_debug, "Disable SIP debugging",
18540 no_debug_usage, NULL, &cli_sip_no_debug_deprecated },
18541
18542 { { "sip", "history", NULL },
18543 sip_do_history, "Enable SIP history",
18544 history_usage },
18545
18546 { { "sip", "history", "off", NULL },
18547 sip_no_history, "Disable SIP history",
18548 no_history_usage },
18549
18550 { { "sip", "reload", NULL },
18551 sip_reload, "Reload SIP configuration",
18552 sip_reload_usage },
18553 };
18554
18555
18556 static int load_module(void)
18557 {
18558 ASTOBJ_CONTAINER_INIT(&userl);
18559 ASTOBJ_CONTAINER_INIT(&peerl);
18560 ASTOBJ_CONTAINER_INIT(®l);
18561
18562 if (!(sched = sched_context_create())) {
18563 ast_log(LOG_ERROR, "Unable to create scheduler context\n");
18564 return AST_MODULE_LOAD_FAILURE;
18565 }
18566
18567 if (!(io = io_context_create())) {
18568 ast_log(LOG_ERROR, "Unable to create I/O context\n");
18569 sched_context_destroy(sched);
18570 return AST_MODULE_LOAD_FAILURE;
18571 }
18572
18573 sip_reloadreason = CHANNEL_MODULE_LOAD;
18574
18575 if(reload_config(sip_reloadreason))
18576 return AST_MODULE_LOAD_DECLINE;
18577
18578
18579 if (ast_channel_register(&sip_tech)) {
18580 ast_log(LOG_ERROR, "Unable to register channel type 'SIP'\n");
18581 io_context_destroy(io);
18582 sched_context_destroy(sched);
18583 return AST_MODULE_LOAD_FAILURE;
18584 }
18585
18586
18587 ast_cli_register_multiple(cli_sip, sizeof(cli_sip)/ sizeof(struct ast_cli_entry));
18588
18589
18590 ast_rtp_proto_register(&sip_rtp);
18591
18592
18593 ast_udptl_proto_register(&sip_udptl);
18594
18595
18596 ast_register_application(app_dtmfmode, sip_dtmfmode, synopsis_dtmfmode, descrip_dtmfmode);
18597 ast_register_application(app_sipaddheader, sip_addheader, synopsis_sipaddheader, descrip_sipaddheader);
18598
18599
18600 ast_custom_function_register(&sip_header_function);
18601 ast_custom_function_register(&sippeer_function);
18602 ast_custom_function_register(&sipchaninfo_function);
18603 ast_custom_function_register(&checksipdomain_function);
18604
18605
18606 ast_manager_register2("SIPpeers", EVENT_FLAG_SYSTEM, manager_sip_show_peers,
18607 "List SIP peers (text format)", mandescr_show_peers);
18608 ast_manager_register2("SIPshowpeer", EVENT_FLAG_SYSTEM, manager_sip_show_peer,
18609 "Show SIP peer (text format)", mandescr_show_peer);
18610
18611 sip_poke_all_peers();
18612 sip_send_all_registers();
18613
18614
18615 restart_monitor();
18616
18617 return AST_MODULE_LOAD_SUCCESS;
18618 }
18619
18620
18621 static int unload_module(void)
18622 {
18623 struct sip_pvt *p, *pl;
18624
18625
18626 ast_channel_unregister(&sip_tech);
18627
18628
18629 ast_custom_function_unregister(&sipchaninfo_function);
18630 ast_custom_function_unregister(&sippeer_function);
18631 ast_custom_function_unregister(&sip_header_function);
18632 ast_custom_function_unregister(&checksipdomain_function);
18633
18634
18635 ast_unregister_application(app_dtmfmode);
18636 ast_unregister_application(app_sipaddheader);
18637
18638
18639 ast_cli_unregister_multiple(cli_sip, sizeof(cli_sip) / sizeof(struct ast_cli_entry));
18640
18641
18642 ast_rtp_proto_unregister(&sip_rtp);
18643
18644
18645 ast_udptl_proto_unregister(&sip_udptl);
18646
18647
18648 ast_manager_unregister("SIPpeers");
18649 ast_manager_unregister("SIPshowpeer");
18650
18651 ast_mutex_lock(&iflock);
18652
18653 for (p = iflist; p ; p = p->next) {
18654 if (p->owner)
18655 ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
18656 }
18657 ast_mutex_unlock(&iflock);
18658
18659 ast_mutex_lock(&monlock);
18660 if (monitor_thread && (monitor_thread != AST_PTHREADT_STOP) && (monitor_thread != AST_PTHREADT_NULL)) {
18661 pthread_cancel(monitor_thread);
18662 pthread_kill(monitor_thread, SIGURG);
18663 pthread_join(monitor_thread, NULL);
18664 }
18665 monitor_thread = AST_PTHREADT_STOP;
18666 ast_mutex_unlock(&monlock);
18667
18668 restartdestroy:
18669 ast_mutex_lock(&iflock);
18670
18671 p = iflist;
18672 while (p) {
18673 pl = p;
18674 p = p->next;
18675 if (__sip_destroy(pl, TRUE) < 0) {
18676
18677 iflist = p;
18678 ast_mutex_unlock(&iflock);
18679 usleep(1);
18680 goto restartdestroy;
18681 }
18682 }
18683 iflist = NULL;
18684 ast_mutex_unlock(&iflock);
18685
18686
18687 ast_free_ha(localaddr);
18688
18689 ASTOBJ_CONTAINER_DESTROYALL(&userl, sip_destroy_user);
18690 ASTOBJ_CONTAINER_DESTROY(&userl);
18691 ASTOBJ_CONTAINER_DESTROYALL(&peerl, sip_destroy_peer);
18692 ASTOBJ_CONTAINER_DESTROY(&peerl);
18693 ASTOBJ_CONTAINER_DESTROYALL(®l, sip_registry_destroy);
18694 ASTOBJ_CONTAINER_DESTROY(®l);
18695
18696 clear_realm_authentication(authl);
18697 clear_sip_domains();
18698 close(sipsock);
18699 sched_context_destroy(sched);
18700
18701 return 0;
18702 }
18703
18704 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Session Initiation Protocol (SIP)",
18705 .load = load_module,
18706 .unload = unload_module,
18707 .reload = reload,
18708 );