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
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210 #include "asterisk.h"
00211
00212 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 357264 $")
00213
00214 #include <signal.h>
00215 #include <sys/signal.h>
00216 #include <regex.h>
00217 #include <inttypes.h>
00218
00219 #include "asterisk/network.h"
00220 #include "asterisk/paths.h"
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233 #include "asterisk/lock.h"
00234 #include "asterisk/config.h"
00235 #include "asterisk/module.h"
00236 #include "asterisk/pbx.h"
00237 #include "asterisk/sched.h"
00238 #include "asterisk/io.h"
00239 #include "asterisk/rtp_engine.h"
00240 #include "asterisk/udptl.h"
00241 #include "asterisk/acl.h"
00242 #include "asterisk/manager.h"
00243 #include "asterisk/callerid.h"
00244 #include "asterisk/cli.h"
00245 #include "asterisk/musiconhold.h"
00246 #include "asterisk/dsp.h"
00247 #include "asterisk/features.h"
00248 #include "asterisk/srv.h"
00249 #include "asterisk/astdb.h"
00250 #include "asterisk/causes.h"
00251 #include "asterisk/utils.h"
00252 #include "asterisk/file.h"
00253 #include "asterisk/astobj2.h"
00254 #include "asterisk/dnsmgr.h"
00255 #include "asterisk/devicestate.h"
00256 #include "asterisk/monitor.h"
00257 #include "asterisk/netsock2.h"
00258 #include "asterisk/localtime.h"
00259 #include "asterisk/abstract_jb.h"
00260 #include "asterisk/threadstorage.h"
00261 #include "asterisk/translate.h"
00262 #include "asterisk/ast_version.h"
00263 #include "asterisk/event.h"
00264 #include "asterisk/cel.h"
00265 #include "asterisk/data.h"
00266 #include "asterisk/aoc.h"
00267 #include "sip/include/sip.h"
00268 #include "sip/include/globals.h"
00269 #include "sip/include/config_parser.h"
00270 #include "sip/include/reqresp_parser.h"
00271 #include "sip/include/sip_utils.h"
00272 #include "sip/include/srtp.h"
00273 #include "sip/include/sdp_crypto.h"
00274 #include "asterisk/ccss.h"
00275 #include "asterisk/xml.h"
00276 #include "sip/include/dialog.h"
00277 #include "sip/include/dialplan_functions.h"
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335
00336
00337
00338
00339
00340
00341
00342
00343
00344
00345
00346
00347
00348
00349
00350
00351
00352
00353
00354
00355
00356
00357
00358
00359
00360
00361
00362
00363
00364
00365
00366
00367
00368
00369
00370
00371
00372
00373
00374
00375
00376
00377
00378
00379
00380
00381
00382
00383
00384
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415
00416
00417
00418
00419
00420
00421
00422
00423
00424
00425
00426
00427
00428
00429
00430
00431
00432
00433
00434
00435
00436
00437
00438
00439
00440
00441
00442
00443
00444
00445
00446
00447
00448
00449
00450
00451
00452
00453
00454
00455
00456
00457
00458
00459
00460
00461
00462
00463
00464
00465
00466
00467
00468
00469
00470
00471
00472
00473
00474
00475
00476
00477
00478
00479
00480
00481
00482
00483
00484
00485
00486
00487
00488
00489
00490
00491
00492
00493
00494
00495
00496
00497
00498
00499
00500
00501
00502
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529
00530
00531
00532
00533
00534
00535
00536
00537
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557
00558 static int min_expiry = DEFAULT_MIN_EXPIRY;
00559 static int max_expiry = DEFAULT_MAX_EXPIRY;
00560 static int default_expiry = DEFAULT_DEFAULT_EXPIRY;
00561 static int mwi_expiry = DEFAULT_MWI_EXPIRY;
00562
00563 static int unauth_sessions = 0;
00564 static int authlimit = DEFAULT_AUTHLIMIT;
00565 static int authtimeout = DEFAULT_AUTHTIMEOUT;
00566
00567
00568
00569 static struct ast_jb_conf default_jbconf =
00570 {
00571 .flags = 0,
00572 .max_size = 200,
00573 .resync_threshold = 1000,
00574 .impl = "fixed",
00575 .target_extra = 40,
00576 };
00577 static struct ast_jb_conf global_jbconf;
00578
00579 static const char config[] = "sip.conf";
00580 static const char notify_config[] = "sip_notify.conf";
00581
00582
00583
00584 static const struct invstate2stringtable {
00585 const enum invitestates state;
00586 const char *desc;
00587 } invitestate2string[] = {
00588 {INV_NONE, "None" },
00589 {INV_CALLING, "Calling (Trying)"},
00590 {INV_PROCEEDING, "Proceeding "},
00591 {INV_EARLY_MEDIA, "Early media"},
00592 {INV_COMPLETED, "Completed (done)"},
00593 {INV_CONFIRMED, "Confirmed (up)"},
00594 {INV_TERMINATED, "Done"},
00595 {INV_CANCELLED, "Cancelled"}
00596 };
00597
00598
00599
00600
00601
00602
00603 static const struct cfsubscription_types {
00604 enum subscriptiontype type;
00605 const char * const event;
00606 const char * const mediatype;
00607 const char * const text;
00608 } subscription_types[] = {
00609 { NONE, "-", "unknown", "unknown" },
00610
00611 { DIALOG_INFO_XML, "dialog", "application/dialog-info+xml", "dialog-info+xml" },
00612 { CPIM_PIDF_XML, "presence", "application/cpim-pidf+xml", "cpim-pidf+xml" },
00613 { PIDF_XML, "presence", "application/pidf+xml", "pidf+xml" },
00614 { XPIDF_XML, "presence", "application/xpidf+xml", "xpidf+xml" },
00615 { MWI_NOTIFICATION, "message-summary", "application/simple-message-summary", "mwi" }
00616 };
00617
00618
00619
00620
00621
00622
00623 static const struct cfsip_methods {
00624 enum sipmethod id;
00625 int need_rtp;
00626 char * const text;
00627 enum can_create_dialog can_create;
00628 } sip_methods[] = {
00629 { SIP_UNKNOWN, RTP, "-UNKNOWN-",CAN_CREATE_DIALOG },
00630 { SIP_RESPONSE, NO_RTP, "SIP/2.0", CAN_NOT_CREATE_DIALOG },
00631 { SIP_REGISTER, NO_RTP, "REGISTER", CAN_CREATE_DIALOG },
00632 { SIP_OPTIONS, NO_RTP, "OPTIONS", CAN_CREATE_DIALOG },
00633 { SIP_NOTIFY, NO_RTP, "NOTIFY", CAN_CREATE_DIALOG },
00634 { SIP_INVITE, RTP, "INVITE", CAN_CREATE_DIALOG },
00635 { SIP_ACK, NO_RTP, "ACK", CAN_NOT_CREATE_DIALOG },
00636 { SIP_PRACK, NO_RTP, "PRACK", CAN_NOT_CREATE_DIALOG },
00637 { SIP_BYE, NO_RTP, "BYE", CAN_NOT_CREATE_DIALOG },
00638 { SIP_REFER, NO_RTP, "REFER", CAN_CREATE_DIALOG },
00639 { SIP_SUBSCRIBE, NO_RTP, "SUBSCRIBE",CAN_CREATE_DIALOG },
00640 { SIP_MESSAGE, NO_RTP, "MESSAGE", CAN_CREATE_DIALOG },
00641 { SIP_UPDATE, NO_RTP, "UPDATE", CAN_NOT_CREATE_DIALOG },
00642 { SIP_INFO, NO_RTP, "INFO", CAN_NOT_CREATE_DIALOG },
00643 { SIP_CANCEL, NO_RTP, "CANCEL", CAN_NOT_CREATE_DIALOG },
00644 { SIP_PUBLISH, NO_RTP, "PUBLISH", CAN_CREATE_DIALOG },
00645 { SIP_PING, NO_RTP, "PING", CAN_CREATE_DIALOG_UNSUPPORTED_METHOD }
00646 };
00647
00648
00649
00650
00651
00652
00653
00654
00655 static const struct sip_reasons {
00656 enum AST_REDIRECTING_REASON code;
00657 char * const text;
00658 } sip_reason_table[] = {
00659 { AST_REDIRECTING_REASON_UNKNOWN, "unknown" },
00660 { AST_REDIRECTING_REASON_USER_BUSY, "user-busy" },
00661 { AST_REDIRECTING_REASON_NO_ANSWER, "no-answer" },
00662 { AST_REDIRECTING_REASON_UNAVAILABLE, "unavailable" },
00663 { AST_REDIRECTING_REASON_UNCONDITIONAL, "unconditional" },
00664 { AST_REDIRECTING_REASON_TIME_OF_DAY, "time-of-day" },
00665 { AST_REDIRECTING_REASON_DO_NOT_DISTURB, "do-not-disturb" },
00666 { AST_REDIRECTING_REASON_DEFLECTION, "deflection" },
00667 { AST_REDIRECTING_REASON_FOLLOW_ME, "follow-me" },
00668 { AST_REDIRECTING_REASON_OUT_OF_ORDER, "out-of-service" },
00669 { AST_REDIRECTING_REASON_AWAY, "away" },
00670 { AST_REDIRECTING_REASON_CALL_FWD_DTE, "unknown"}
00671 };
00672
00673
00674
00675
00676
00677
00678
00679 static char default_language[MAX_LANGUAGE];
00680 static char default_callerid[AST_MAX_EXTENSION];
00681 static char default_mwi_from[80];
00682 static char default_fromdomain[AST_MAX_EXTENSION];
00683 static int default_fromdomainport;
00684 static char default_notifymime[AST_MAX_EXTENSION];
00685 static char default_vmexten[AST_MAX_EXTENSION];
00686 static int default_qualify;
00687 static char default_mohinterpret[MAX_MUSICCLASS];
00688 static char default_mohsuggest[MAX_MUSICCLASS];
00689
00690 static char default_parkinglot[AST_MAX_CONTEXT];
00691 static char default_engine[256];
00692 static int default_maxcallbitrate;
00693 static struct ast_codec_pref default_prefs;
00694 static unsigned int default_transports;
00695 static unsigned int default_primary_transport;
00696
00697
00698 static struct sip_settings sip_cfg;
00699
00700
00701
00702 #define SIP_PEDANTIC_DECODE(str) \
00703 if (sip_cfg.pedanticsipchecking && !ast_strlen_zero(str)) { \
00704 ast_uri_decode(str); \
00705 } \
00706
00707 static unsigned int chan_idx;
00708 static int global_match_auth_username;
00709
00710 static int global_relaxdtmf;
00711 static int global_prematuremediafilter;
00712 static int global_rtptimeout;
00713 static int global_rtpholdtimeout;
00714 static int global_rtpkeepalive;
00715 static int global_reg_timeout;
00716 static int global_regattempts_max;
00717 static int global_shrinkcallerid;
00718 static int global_callcounter;
00719
00720
00721 static unsigned int global_tos_sip;
00722 static unsigned int global_tos_audio;
00723 static unsigned int global_tos_video;
00724 static unsigned int global_tos_text;
00725 static unsigned int global_cos_sip;
00726 static unsigned int global_cos_audio;
00727 static unsigned int global_cos_video;
00728 static unsigned int global_cos_text;
00729 static unsigned int recordhistory;
00730 static unsigned int dumphistory;
00731 static char global_useragent[AST_MAX_EXTENSION];
00732 static char global_sdpsession[AST_MAX_EXTENSION];
00733 static char global_sdpowner[AST_MAX_EXTENSION];
00734 static int global_authfailureevents;
00735 static int global_t1;
00736 static int global_t1min;
00737 static int global_timer_b;
00738 static unsigned int global_autoframing;
00739 static int global_qualifyfreq;
00740 static int global_qualify_gap;
00741 static int global_qualify_peers;
00742
00743 static enum st_mode global_st_mode;
00744 static enum st_refresher global_st_refresher;
00745 static int global_min_se;
00746 static int global_max_se;
00747
00748 static int global_store_sip_cause;
00749
00750 static int global_dynamic_exclude_static = 0;
00751
00752
00753
00754
00755
00756
00757
00758
00759 static int can_parse_xml;
00760
00761
00762
00763
00764 static int speerobjs = 0;
00765 static int rpeerobjs = 0;
00766 static int apeerobjs = 0;
00767 static int regobjs = 0;
00768
00769
00770 static struct ast_flags global_flags[3] = {{0}};
00771 static int global_t38_maxdatagram;
00772
00773 static struct ast_event_sub *network_change_event_subscription;
00774 static int network_change_event_sched_id = -1;
00775
00776 static char used_context[AST_MAX_CONTEXT];
00777
00778 AST_MUTEX_DEFINE_STATIC(netlock);
00779
00780
00781
00782 AST_MUTEX_DEFINE_STATIC(monlock);
00783
00784 AST_MUTEX_DEFINE_STATIC(sip_reload_lock);
00785
00786
00787
00788 static pthread_t monitor_thread = AST_PTHREADT_NULL;
00789
00790 static int sip_reloading = FALSE;
00791 static enum channelreloadreason sip_reloadreason;
00792
00793 struct sched_context *sched;
00794 static struct io_context *io;
00795 static int *sipsock_read_id;
00796 struct sip_pkt;
00797 static AST_LIST_HEAD_STATIC(domain_list, domain);
00798
00799 AST_LIST_HEAD_NOLOCK(sip_history_head, sip_history);
00800
00801 static enum sip_debug_e sipdebug;
00802
00803
00804
00805
00806
00807 static int sipdebug_text;
00808
00809 static const struct _map_x_s referstatusstrings[] = {
00810 { REFER_IDLE, "<none>" },
00811 { REFER_SENT, "Request sent" },
00812 { REFER_RECEIVED, "Request received" },
00813 { REFER_CONFIRMED, "Confirmed" },
00814 { REFER_ACCEPTED, "Accepted" },
00815 { REFER_RINGING, "Target ringing" },
00816 { REFER_200OK, "Done" },
00817 { REFER_FAILED, "Failed" },
00818 { REFER_NOAUTH, "Failed - auth failure" },
00819 { -1, NULL}
00820 };
00821
00822
00823 #ifdef LOW_MEMORY
00824 static const int HASH_PEER_SIZE = 17;
00825 static const int HASH_DIALOG_SIZE = 17;
00826 #else
00827 static const int HASH_PEER_SIZE = 563;
00828 static const int HASH_DIALOG_SIZE = 563;
00829 #endif
00830
00831 static const struct {
00832 enum ast_cc_service_type service;
00833 const char *service_string;
00834 } sip_cc_service_map [] = {
00835 [AST_CC_NONE] = { AST_CC_NONE, "" },
00836 [AST_CC_CCBS] = { AST_CC_CCBS, "BS" },
00837 [AST_CC_CCNR] = { AST_CC_CCNR, "NR" },
00838 [AST_CC_CCNL] = { AST_CC_CCNL, "NL" },
00839 };
00840
00841 static enum ast_cc_service_type service_string_to_service_type(const char * const service_string)
00842 {
00843 enum ast_cc_service_type service;
00844 for (service = AST_CC_CCBS; service <= AST_CC_CCNL; ++service) {
00845 if (!strcasecmp(service_string, sip_cc_service_map[service].service_string)) {
00846 return service;
00847 }
00848 }
00849 return AST_CC_NONE;
00850 }
00851
00852 static const struct {
00853 enum sip_cc_notify_state state;
00854 const char *state_string;
00855 } sip_cc_notify_state_map [] = {
00856 [CC_QUEUED] = {CC_QUEUED, "cc-state: queued"},
00857 [CC_READY] = {CC_READY, "cc-state: ready"},
00858 };
00859
00860 AST_LIST_HEAD_STATIC(epa_static_data_list, epa_backend);
00861
00862 static int sip_epa_register(const struct epa_static_data *static_data)
00863 {
00864 struct epa_backend *backend = ast_calloc(1, sizeof(*backend));
00865
00866 if (!backend) {
00867 return -1;
00868 }
00869
00870 backend->static_data = static_data;
00871
00872 AST_LIST_LOCK(&epa_static_data_list);
00873 AST_LIST_INSERT_TAIL(&epa_static_data_list, backend, next);
00874 AST_LIST_UNLOCK(&epa_static_data_list);
00875 return 0;
00876 }
00877
00878 static void sip_epa_unregister_all(void)
00879 {
00880 struct epa_backend *backend;
00881
00882 AST_LIST_LOCK(&epa_static_data_list);
00883 while ((backend = AST_LIST_REMOVE_HEAD(&epa_static_data_list, next))) {
00884 ast_free(backend);
00885 }
00886 AST_LIST_UNLOCK(&epa_static_data_list);
00887 }
00888
00889 static void cc_handle_publish_error(struct sip_pvt *pvt, const int resp, struct sip_request *req, struct sip_epa_entry *epa_entry);
00890
00891 static void cc_epa_destructor(void *data)
00892 {
00893 struct sip_epa_entry *epa_entry = data;
00894 struct cc_epa_entry *cc_entry = epa_entry->instance_data;
00895 ast_free(cc_entry);
00896 }
00897
00898 static const struct epa_static_data cc_epa_static_data = {
00899 .event = CALL_COMPLETION,
00900 .name = "call-completion",
00901 .handle_error = cc_handle_publish_error,
00902 .destructor = cc_epa_destructor,
00903 };
00904
00905 static const struct epa_static_data *find_static_data(const char * const event_package)
00906 {
00907 const struct epa_backend *backend = NULL;
00908
00909 AST_LIST_LOCK(&epa_static_data_list);
00910 AST_LIST_TRAVERSE(&epa_static_data_list, backend, next) {
00911 if (!strcmp(backend->static_data->name, event_package)) {
00912 break;
00913 }
00914 }
00915 AST_LIST_UNLOCK(&epa_static_data_list);
00916 return backend ? backend->static_data : NULL;
00917 }
00918
00919 static struct sip_epa_entry *create_epa_entry (const char * const event_package, const char * const destination)
00920 {
00921 struct sip_epa_entry *epa_entry;
00922 const struct epa_static_data *static_data;
00923
00924 if (!(static_data = find_static_data(event_package))) {
00925 return NULL;
00926 }
00927
00928 if (!(epa_entry = ao2_t_alloc(sizeof(*epa_entry), static_data->destructor, "Allocate new EPA entry"))) {
00929 return NULL;
00930 }
00931
00932 epa_entry->static_data = static_data;
00933 ast_copy_string(epa_entry->destination, destination, sizeof(epa_entry->destination));
00934 return epa_entry;
00935 }
00936
00937
00938
00939
00940 static int esc_etag_counter;
00941 static const int DEFAULT_PUBLISH_EXPIRES = 3600;
00942
00943 #ifdef HAVE_LIBXML2
00944 static int cc_esc_publish_handler(struct sip_pvt *pvt, struct sip_request *req, struct event_state_compositor *esc, struct sip_esc_entry *esc_entry);
00945
00946 static const struct sip_esc_publish_callbacks cc_esc_publish_callbacks = {
00947 .initial_handler = cc_esc_publish_handler,
00948 .modify_handler = cc_esc_publish_handler,
00949 };
00950 #endif
00951
00952
00953
00954
00955
00956
00957
00958
00959
00960
00961
00962
00963
00964 static struct event_state_compositor {
00965 enum subscriptiontype event;
00966 const char * name;
00967 const struct sip_esc_publish_callbacks *callbacks;
00968 struct ao2_container *compositor;
00969 } event_state_compositors [] = {
00970 #ifdef HAVE_LIBXML2
00971 {CALL_COMPLETION, "call-completion", &cc_esc_publish_callbacks},
00972 #endif
00973 };
00974
00975 static const int ESC_MAX_BUCKETS = 37;
00976
00977 static void esc_entry_destructor(void *obj)
00978 {
00979 struct sip_esc_entry *esc_entry = obj;
00980 if (esc_entry->sched_id > -1) {
00981 AST_SCHED_DEL(sched, esc_entry->sched_id);
00982 }
00983 }
00984
00985 static int esc_hash_fn(const void *obj, const int flags)
00986 {
00987 const struct sip_esc_entry *entry = obj;
00988 return ast_str_hash(entry->entity_tag);
00989 }
00990
00991 static int esc_cmp_fn(void *obj, void *arg, int flags)
00992 {
00993 struct sip_esc_entry *entry1 = obj;
00994 struct sip_esc_entry *entry2 = arg;
00995
00996 return (!strcmp(entry1->entity_tag, entry2->entity_tag)) ? (CMP_MATCH | CMP_STOP) : 0;
00997 }
00998
00999 static struct event_state_compositor *get_esc(const char * const event_package) {
01000 int i;
01001 for (i = 0; i < ARRAY_LEN(event_state_compositors); i++) {
01002 if (!strcasecmp(event_package, event_state_compositors[i].name)) {
01003 return &event_state_compositors[i];
01004 }
01005 }
01006 return NULL;
01007 }
01008
01009 static struct sip_esc_entry *get_esc_entry(const char * entity_tag, struct event_state_compositor *esc) {
01010 struct sip_esc_entry *entry;
01011 struct sip_esc_entry finder;
01012
01013 ast_copy_string(finder.entity_tag, entity_tag, sizeof(finder.entity_tag));
01014
01015 entry = ao2_find(esc->compositor, &finder, OBJ_POINTER);
01016
01017 return entry;
01018 }
01019
01020 static int publish_expire(const void *data)
01021 {
01022 struct sip_esc_entry *esc_entry = (struct sip_esc_entry *) data;
01023 struct event_state_compositor *esc = get_esc(esc_entry->event);
01024
01025 ast_assert(esc != NULL);
01026
01027 ao2_unlink(esc->compositor, esc_entry);
01028 ao2_ref(esc_entry, -1);
01029 return 0;
01030 }
01031
01032 static void create_new_sip_etag(struct sip_esc_entry *esc_entry, int is_linked)
01033 {
01034 int new_etag = ast_atomic_fetchadd_int(&esc_etag_counter, +1);
01035 struct event_state_compositor *esc = get_esc(esc_entry->event);
01036
01037 ast_assert(esc != NULL);
01038 if (is_linked) {
01039 ao2_unlink(esc->compositor, esc_entry);
01040 }
01041 snprintf(esc_entry->entity_tag, sizeof(esc_entry->entity_tag), "%d", new_etag);
01042 ao2_link(esc->compositor, esc_entry);
01043 }
01044
01045 static struct sip_esc_entry *create_esc_entry(struct event_state_compositor *esc, struct sip_request *req, const int expires)
01046 {
01047 struct sip_esc_entry *esc_entry;
01048 int expires_ms;
01049
01050 if (!(esc_entry = ao2_alloc(sizeof(*esc_entry), esc_entry_destructor))) {
01051 return NULL;
01052 }
01053
01054 esc_entry->event = esc->name;
01055
01056 expires_ms = expires * 1000;
01057
01058 ao2_ref(esc_entry, +1);
01059 esc_entry->sched_id = ast_sched_add(sched, expires_ms, publish_expire, esc_entry);
01060
01061
01062 create_new_sip_etag(esc_entry, 0);
01063
01064 return esc_entry;
01065 }
01066
01067 static int initialize_escs(void)
01068 {
01069 int i, res = 0;
01070 for (i = 0; i < ARRAY_LEN(event_state_compositors); i++) {
01071 if (!((event_state_compositors[i].compositor) =
01072 ao2_container_alloc(ESC_MAX_BUCKETS, esc_hash_fn, esc_cmp_fn))) {
01073 res = -1;
01074 }
01075 }
01076 return res;
01077 }
01078
01079 static void destroy_escs(void)
01080 {
01081 int i;
01082 for (i = 0; i < ARRAY_LEN(event_state_compositors); i++) {
01083 ao2_ref(event_state_compositors[i].compositor, -1);
01084 }
01085 }
01086
01087
01088
01089
01090
01091 struct ao2_container *dialogs_to_destroy;
01092
01093
01094
01095
01096
01097
01098
01099
01100
01101 static struct ao2_container *dialogs;
01102 #define sip_pvt_lock(x) ao2_lock(x)
01103 #define sip_pvt_trylock(x) ao2_trylock(x)
01104 #define sip_pvt_unlock(x) ao2_unlock(x)
01105
01106
01107 static struct ao2_container *threadt;
01108
01109
01110 static struct ao2_container *peers;
01111 static struct ao2_container *peers_by_ip;
01112
01113
01114 static struct ast_register_list {
01115 ASTOBJ_CONTAINER_COMPONENTS(struct sip_registry);
01116 int recheck;
01117 } regl;
01118
01119
01120 static struct ast_subscription_mwi_list {
01121 ASTOBJ_CONTAINER_COMPONENTS(struct sip_subscription_mwi);
01122 } submwil;
01123 static int temp_pvt_init(void *);
01124 static void temp_pvt_cleanup(void *);
01125
01126
01127 AST_THREADSTORAGE_CUSTOM(ts_temp_pvt, temp_pvt_init, temp_pvt_cleanup);
01128
01129
01130 static struct sip_auth_container *authl = NULL;
01131
01132 AST_MUTEX_DEFINE_STATIC(authl_lock);
01133
01134
01135
01136
01137
01138
01139
01140
01141
01142
01143
01144
01145
01146
01147
01148
01149
01150 static int sipsock = -1;
01151
01152 struct ast_sockaddr bindaddr;
01153
01154
01155
01156
01157
01158
01159
01160 static struct ast_sockaddr internip;
01161
01162
01163
01164
01165
01166
01167
01168
01169
01170
01171
01172
01173
01174
01175
01176
01177 static struct ast_sockaddr externaddr;
01178 static struct ast_sockaddr media_address;
01179
01180 static char externhost[MAXHOSTNAMELEN];
01181 static time_t externexpire;
01182 static int externrefresh = 10;
01183 static uint16_t externtcpport;
01184 static uint16_t externtlsport;
01185
01186
01187
01188
01189
01190
01191
01192 static struct ast_ha *localaddr;
01193
01194 static int ourport_tcp;
01195 static int ourport_tls;
01196 static struct ast_sockaddr debugaddr;
01197
01198 static struct ast_config *notify_types = NULL;
01199
01200
01201
01202 #define UNLINK(element, head, prev) do { \
01203 if (prev) \
01204 (prev)->next = (element)->next; \
01205 else \
01206 (head) = (element)->next; \
01207 } while (0)
01208
01209
01210
01211
01212
01213
01214 static struct ast_channel *sip_request_call(const char *type, format_t format, const struct ast_channel *requestor, void *data, int *cause);
01215 static int sip_devicestate(void *data);
01216 static int sip_sendtext(struct ast_channel *ast, const char *text);
01217 static int sip_call(struct ast_channel *ast, char *dest, int timeout);
01218 static int sip_sendhtml(struct ast_channel *chan, int subclass, const char *data, int datalen);
01219 static int sip_hangup(struct ast_channel *ast);
01220 static int sip_answer(struct ast_channel *ast);
01221 static struct ast_frame *sip_read(struct ast_channel *ast);
01222 static int sip_write(struct ast_channel *ast, struct ast_frame *frame);
01223 static int sip_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen);
01224 static int sip_transfer(struct ast_channel *ast, const char *dest);
01225 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
01226 static int sip_senddigit_begin(struct ast_channel *ast, char digit);
01227 static int sip_senddigit_end(struct ast_channel *ast, char digit, unsigned int duration);
01228 static int sip_setoption(struct ast_channel *chan, int option, void *data, int datalen);
01229 static int sip_queryoption(struct ast_channel *chan, int option, void *data, int *datalen);
01230 static const char *sip_get_callid(struct ast_channel *chan);
01231
01232 static int handle_request_do(struct sip_request *req, struct ast_sockaddr *addr);
01233 static int sip_standard_port(enum sip_transport type, int port);
01234 static int sip_prepare_socket(struct sip_pvt *p);
01235 static int get_address_family_filter(const struct ast_sockaddr *addr);
01236
01237
01238 static int sipsock_read(int *id, int fd, short events, void *ignore);
01239 static int __sip_xmit(struct sip_pvt *p, struct ast_str *data);
01240 static int __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, struct ast_str *data, int fatal, int sipmethod);
01241 static void add_cc_call_info_to_response(struct sip_pvt *p, struct sip_request *resp);
01242 static int __transmit_response(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable);
01243 static int retrans_pkt(const void *data);
01244 static int transmit_response_using_temp(ast_string_field callid, struct ast_sockaddr *addr, int useglobal_nat, const int intended_method, const struct sip_request *req, const char *msg);
01245 static int transmit_response(struct sip_pvt *p, const char *msg, const struct sip_request *req);
01246 static int transmit_response_reliable(struct sip_pvt *p, const char *msg, const struct sip_request *req);
01247 static int transmit_response_with_date(struct sip_pvt *p, const char *msg, const struct sip_request *req);
01248 static int transmit_response_with_sdp(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable, int oldsdp, int rpid);
01249 static int transmit_response_with_unsupported(struct sip_pvt *p, const char *msg, const struct sip_request *req, const char *unsupported);
01250 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);
01251 static int transmit_provisional_response(struct sip_pvt *p, const char *msg, const struct sip_request *req, int with_sdp);
01252 static int transmit_response_with_allow(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable);
01253 static void transmit_fake_auth_response(struct sip_pvt *p, int sipmethod, struct sip_request *req, enum xmittype reliable);
01254 static int transmit_request(struct sip_pvt *p, int sipmethod, int inc, enum xmittype reliable, int newbranch);
01255 static int transmit_request_with_auth(struct sip_pvt *p, int sipmethod, int seqno, enum xmittype reliable, int newbranch);
01256 static int transmit_publish(struct sip_epa_entry *epa_entry, enum sip_publish_type publish_type, const char * const explicit_uri);
01257 static int transmit_invite(struct sip_pvt *p, int sipmethod, int sdp, int init, const char * const explicit_uri);
01258 static int transmit_reinvite_with_sdp(struct sip_pvt *p, int t38version, int oldsdp);
01259 static int transmit_info_with_aoc(struct sip_pvt *p, struct ast_aoc_decoded *decoded);
01260 static int transmit_info_with_digit(struct sip_pvt *p, const char digit, unsigned int duration);
01261 static int transmit_info_with_vidupdate(struct sip_pvt *p);
01262 static int transmit_message_with_text(struct sip_pvt *p, const char *text);
01263 static int transmit_refer(struct sip_pvt *p, const char *dest);
01264 static int transmit_notify_with_mwi(struct sip_pvt *p, int newmsgs, int oldmsgs, const char *vmexten);
01265 static int transmit_notify_with_sipfrag(struct sip_pvt *p, int cseq, char *message, int terminate);
01266 static int transmit_cc_notify(struct ast_cc_agent *agent, struct sip_pvt *subscription, enum sip_cc_notify_state state);
01267 static int transmit_register(struct sip_registry *r, int sipmethod, const char *auth, const char *authheader);
01268 static int send_response(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno);
01269 static int send_request(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno);
01270 static void copy_request(struct sip_request *dst, const struct sip_request *src);
01271 static void receive_message(struct sip_pvt *p, struct sip_request *req);
01272 static void parse_moved_contact(struct sip_pvt *p, struct sip_request *req, char **name, char **number, int set_call_forward);
01273 static int sip_send_mwi_to_peer(struct sip_peer *peer, int cache_only);
01274
01275
01276 static int __sip_autodestruct(const void *data);
01277 static void *registry_unref(struct sip_registry *reg, char *tag);
01278 static int update_call_counter(struct sip_pvt *fup, int event);
01279 static int auto_congest(const void *arg);
01280 static struct sip_pvt *find_call(struct sip_request *req, struct ast_sockaddr *addr, const int intended_method);
01281 static void free_old_route(struct sip_route *route);
01282 static void list_route(struct sip_route *route);
01283 static void build_route(struct sip_pvt *p, struct sip_request *req, int backwards, int resp);
01284 static enum check_auth_result register_verify(struct sip_pvt *p, struct ast_sockaddr *addr,
01285 struct sip_request *req, const char *uri);
01286 static struct sip_pvt *get_sip_pvt_byid_locked(const char *callid, const char *totag, const char *fromtag);
01287 static void check_pendings(struct sip_pvt *p);
01288 static void *sip_park_thread(void *stuff);
01289 static int sip_park(struct ast_channel *chan1, struct ast_channel *chan2, struct sip_request *req, int seqno, const char *park_exten, const char *park_context);
01290
01291 static void *sip_pickup_thread(void *stuff);
01292 static int sip_pickup(struct ast_channel *chan);
01293
01294 static int sip_sipredirect(struct sip_pvt *p, const char *dest);
01295 static int is_method_allowed(unsigned int *allowed_methods, enum sipmethod method);
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 char get_sdp_line(int *start, int stop, struct sip_request *req, const char **value);
01301 static int find_sdp(struct sip_request *req);
01302 static int process_sdp(struct sip_pvt *p, struct sip_request *req, int t38action);
01303 static int process_sdp_o(const char *o, struct sip_pvt *p);
01304 static int process_sdp_c(const char *c, struct ast_sockaddr *addr);
01305 static int process_sdp_a_sendonly(const char *a, int *sendonly);
01306 static int process_sdp_a_audio(const char *a, struct sip_pvt *p, struct ast_rtp_codecs *newaudiortp, int *last_rtpmap_codec);
01307 static int process_sdp_a_video(const char *a, struct sip_pvt *p, struct ast_rtp_codecs *newvideortp, int *last_rtpmap_codec);
01308 static int process_sdp_a_text(const char *a, struct sip_pvt *p, struct ast_rtp_codecs *newtextrtp, char *red_fmtp, int *red_num_gen, int *red_data_pt, int *last_rtpmap_codec);
01309 static int process_sdp_a_image(const char *a, struct sip_pvt *p);
01310 static void add_codec_to_sdp(const struct sip_pvt *p, format_t codec,
01311 struct ast_str **m_buf, struct ast_str **a_buf,
01312 int debug, int *min_packet_size);
01313 static void add_noncodec_to_sdp(const struct sip_pvt *p, int format,
01314 struct ast_str **m_buf, struct ast_str **a_buf,
01315 int debug);
01316 static enum sip_result add_sdp(struct sip_request *resp, struct sip_pvt *p, int oldsdp, int add_audio, int add_t38);
01317 static void do_setnat(struct sip_pvt *p);
01318 static void stop_media_flows(struct sip_pvt *p);
01319
01320
01321 static int reply_digest(struct sip_pvt *p, struct sip_request *req, char *header, int sipmethod, char *digest, int digest_len);
01322 static int build_reply_digest(struct sip_pvt *p, int method, char *digest, int digest_len);
01323 static enum check_auth_result check_auth(struct sip_pvt *p, struct sip_request *req, const char *username,
01324 const char *secret, const char *md5secret, int sipmethod,
01325 const char *uri, enum xmittype reliable, int ignore);
01326 static enum check_auth_result check_user_full(struct sip_pvt *p, struct sip_request *req,
01327 int sipmethod, const char *uri, enum xmittype reliable,
01328 struct ast_sockaddr *addr, struct sip_peer **authpeer);
01329 static int check_user(struct sip_pvt *p, struct sip_request *req, int sipmethod, const char *uri, enum xmittype reliable, struct ast_sockaddr *addr);
01330
01331
01332 static int check_sip_domain(const char *domain, char *context, size_t len);
01333 static int add_sip_domain(const char *domain, const enum domain_mode mode, const char *context);
01334 static void clear_sip_domains(void);
01335
01336
01337 static void add_realm_authentication(struct sip_auth_container **credentials, const char *configuration, int lineno);
01338 static struct sip_auth *find_realm_authentication(struct sip_auth_container *credentials, const char *realm);
01339
01340
01341 static void check_rtp_timeout(struct sip_pvt *dialog, time_t t);
01342 static int reload_config(enum channelreloadreason reason);
01343 static void add_diversion_header(struct sip_request *req, struct sip_pvt *pvt);
01344 static int expire_register(const void *data);
01345 static void *do_monitor(void *data);
01346 static int restart_monitor(void);
01347 static void peer_mailboxes_to_str(struct ast_str **mailbox_str, struct sip_peer *peer);
01348 static struct ast_variable *copy_vars(struct ast_variable *src);
01349 static int dialog_find_multiple(void *obj, void *arg, int flags);
01350 static struct ast_channel *sip_pvt_lock_full(struct sip_pvt *pvt);
01351
01352 static int sip_refer_allocate(struct sip_pvt *p);
01353 static int sip_notify_allocate(struct sip_pvt *p);
01354 static void ast_quiet_chan(struct ast_channel *chan);
01355 static int attempt_transfer(struct sip_dual *transferer, struct sip_dual *target);
01356 static int do_magic_pickup(struct ast_channel *channel, const char *extension, const char *context);
01357
01358
01359 static int cb_extensionstate(char *context, char* exten, int state, void *data);
01360 static int sip_devicestate(void *data);
01361 static int sip_poke_noanswer(const void *data);
01362 static int sip_poke_peer(struct sip_peer *peer, int force);
01363 static void sip_poke_all_peers(void);
01364 static void sip_peer_hold(struct sip_pvt *p, int hold);
01365 static void mwi_event_cb(const struct ast_event *, void *);
01366 static void network_change_event_cb(const struct ast_event *, void *);
01367
01368
01369 static const char *sip_nat_mode(const struct sip_pvt *p);
01370 static char *sip_show_inuse(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
01371 static char *transfermode2str(enum transfermodes mode) attribute_const;
01372 static int peer_status(struct sip_peer *peer, char *status, int statuslen);
01373 static char *sip_show_sched(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
01374 static char * _sip_show_peers(int fd, int *total, struct mansession *s, const struct message *m, int argc, const char *argv[]);
01375 static char *sip_show_peers(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
01376 static char *sip_show_objects(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
01377 static void print_group(int fd, ast_group_t group, int crlf);
01378 static const char *dtmfmode2str(int mode) attribute_const;
01379 static int str2dtmfmode(const char *str) attribute_unused;
01380 static const char *insecure2str(int mode) attribute_const;
01381 static const char *allowoverlap2str(int mode) attribute_const;
01382 static void cleanup_stale_contexts(char *new, char *old);
01383 static void print_codec_to_cli(int fd, struct ast_codec_pref *pref);
01384 static const char *domain_mode_to_text(const enum domain_mode mode);
01385 static char *sip_show_domains(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
01386 static char *_sip_show_peer(int type, int fd, struct mansession *s, const struct message *m, int argc, const char *argv[]);
01387 static char *sip_show_peer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
01388 static char *_sip_qualify_peer(int type, int fd, struct mansession *s, const struct message *m, int argc, const char *argv[]);
01389 static char *sip_qualify_peer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
01390 static char *sip_show_registry(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
01391 static char *sip_unregister(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
01392 static char *sip_show_settings(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
01393 static char *sip_show_mwi(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
01394 static const char *subscription_type2str(enum subscriptiontype subtype) attribute_pure;
01395 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype);
01396 static char *complete_sip_peer(const char *word, int state, int flags2);
01397 static char *complete_sip_registered_peer(const char *word, int state, int flags2);
01398 static char *complete_sip_show_history(const char *line, const char *word, int pos, int state);
01399 static char *complete_sip_show_peer(const char *line, const char *word, int pos, int state);
01400 static char *complete_sip_unregister(const char *line, const char *word, int pos, int state);
01401 static char *complete_sipnotify(const char *line, const char *word, int pos, int state);
01402 static char *sip_show_channel(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
01403 static char *sip_show_channelstats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
01404 static char *sip_show_history(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
01405 static char *sip_do_debug_ip(int fd, const char *arg);
01406 static char *sip_do_debug_peer(int fd, const char *arg);
01407 static char *sip_do_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
01408 static char *sip_cli_notify(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
01409 static char *sip_set_history(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
01410 static int sip_dtmfmode(struct ast_channel *chan, const char *data);
01411 static int sip_addheader(struct ast_channel *chan, const char *data);
01412 static int sip_do_reload(enum channelreloadreason reason);
01413 static char *sip_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
01414 static int ast_sockaddr_resolve_first_af(struct ast_sockaddr *addr,
01415 const char *name, int flag, int family);
01416 static int ast_sockaddr_resolve_first(struct ast_sockaddr *addr,
01417 const char *name, int flag);
01418
01419
01420
01421
01422
01423 static void sip_dump_history(struct sip_pvt *dialog);
01424 static inline int sip_debug_test_addr(const struct ast_sockaddr *addr);
01425 static inline int sip_debug_test_pvt(struct sip_pvt *p);
01426 static void append_history_full(struct sip_pvt *p, const char *fmt, ...);
01427 static void sip_dump_history(struct sip_pvt *dialog);
01428
01429
01430 static struct sip_peer *build_peer(const char *name, struct ast_variable *v, struct ast_variable *alt, int realtime, int devstate_only);
01431 static int update_call_counter(struct sip_pvt *fup, int event);
01432 static void sip_destroy_peer(struct sip_peer *peer);
01433 static void sip_destroy_peer_fn(void *peer);
01434 static void set_peer_defaults(struct sip_peer *peer);
01435 static struct sip_peer *temp_peer(const char *name);
01436 static void register_peer_exten(struct sip_peer *peer, int onoff);
01437 static struct sip_peer *find_peer(const char *peer, struct ast_sockaddr *addr, int realtime, int forcenamematch, int devstate_only, int transport);
01438 static int sip_poke_peer_s(const void *data);
01439 static enum parse_register_result parse_register_contact(struct sip_pvt *pvt, struct sip_peer *p, struct sip_request *req);
01440 static void reg_source_db(struct sip_peer *peer);
01441 static void destroy_association(struct sip_peer *peer);
01442 static void set_insecure_flags(struct ast_flags *flags, const char *value, int lineno);
01443 static int handle_common_options(struct ast_flags *flags, struct ast_flags *mask, struct ast_variable *v);
01444 static void set_socket_transport(struct sip_socket *socket, int transport);
01445
01446
01447 static void realtime_update_peer(const char *peername, struct ast_sockaddr *addr, const char *username, const char *fullcontact, const char *useragent, int expirey, unsigned short deprecated_username, int lastms);
01448 static void update_peer(struct sip_peer *p, int expire);
01449 static struct ast_variable *get_insecure_variable_from_config(struct ast_config *config);
01450 static const char *get_name_from_variable(const struct ast_variable *var);
01451 static struct sip_peer *realtime_peer(const char *peername, struct ast_sockaddr *sin, int devstate_only, int which_objects);
01452 static char *sip_prune_realtime(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
01453
01454
01455 static void ast_sip_ouraddrfor(const struct ast_sockaddr *them, struct ast_sockaddr *us, struct sip_pvt *p);
01456 static void sip_registry_destroy(struct sip_registry *reg);
01457 static int sip_register(const char *value, int lineno);
01458 static const char *regstate2str(enum sipregistrystate regstate) attribute_const;
01459 static int sip_reregister(const void *data);
01460 static int __sip_do_register(struct sip_registry *r);
01461 static int sip_reg_timeout(const void *data);
01462 static void sip_send_all_registers(void);
01463 static int sip_reinvite_retry(const void *data);
01464
01465
01466 static void append_date(struct sip_request *req);
01467 static int determine_firstline_parts(struct sip_request *req);
01468 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype);
01469 static const char *gettag(const struct sip_request *req, const char *header, char *tagbuf, int tagbufsize);
01470 static int find_sip_method(const char *msg);
01471 static unsigned int parse_allowed_methods(struct sip_request *req);
01472 static unsigned int set_pvt_allowed_methods(struct sip_pvt *pvt, struct sip_request *req);
01473 static int parse_request(struct sip_request *req);
01474 static const char *get_header(const struct sip_request *req, const char *name);
01475 static const char *referstatus2str(enum referstatus rstatus) attribute_pure;
01476 static int method_match(enum sipmethod id, const char *name);
01477 static void parse_copy(struct sip_request *dst, const struct sip_request *src);
01478 static const char *find_alias(const char *name, const char *_default);
01479 static const char *__get_header(const struct sip_request *req, const char *name, int *start);
01480 static void lws2sws(struct ast_str *msgbuf);
01481 static void extract_uri(struct sip_pvt *p, struct sip_request *req);
01482 static char *remove_uri_parameters(char *uri);
01483 static int get_refer_info(struct sip_pvt *transferer, struct sip_request *outgoing_req);
01484 static int get_also_info(struct sip_pvt *p, struct sip_request *oreq);
01485 static int parse_ok_contact(struct sip_pvt *pvt, struct sip_request *req);
01486 static int set_address_from_contact(struct sip_pvt *pvt);
01487 static void check_via(struct sip_pvt *p, struct sip_request *req);
01488 static int get_rpid(struct sip_pvt *p, struct sip_request *oreq);
01489 static int get_rdnis(struct sip_pvt *p, struct sip_request *oreq, char **name, char **number, int *reason);
01490 static enum sip_get_dest_result get_destination(struct sip_pvt *p, struct sip_request *oreq, int *cc_recall_core_id);
01491 static int get_msg_text(char *buf, int len, struct sip_request *req);
01492 static int transmit_state_notify(struct sip_pvt *p, int state, int full, int timeout);
01493 static void update_connectedline(struct sip_pvt *p, const void *data, size_t datalen);
01494 static void update_redirecting(struct sip_pvt *p, const void *data, size_t datalen);
01495 static int get_domain(const char *str, char *domain, int len);
01496 static void get_realm(struct sip_pvt *p, const struct sip_request *req);
01497
01498
01499 static void *_sip_tcp_helper_thread(struct sip_pvt *pvt, struct ast_tcptls_session_instance *tcptls_session);
01500 static void *sip_tcp_worker_fn(void *);
01501
01502
01503 static void initialize_initreq(struct sip_pvt *p, struct sip_request *req);
01504 static int init_req(struct sip_request *req, int sipmethod, const char *recip);
01505 static void deinit_req(struct sip_request *req);
01506 static int reqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod, int seqno, int newbranch);
01507 static void initreqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod, const char * const explicit_uri);
01508 static int init_resp(struct sip_request *resp, const char *msg);
01509 static inline int resp_needs_contact(const char *msg, enum sipmethod method);
01510 static int respprep(struct sip_request *resp, struct sip_pvt *p, const char *msg, const struct sip_request *req);
01511 static const struct ast_sockaddr *sip_real_dst(const struct sip_pvt *p);
01512 static void build_via(struct sip_pvt *p);
01513 static int create_addr_from_peer(struct sip_pvt *r, struct sip_peer *peer);
01514 static int create_addr(struct sip_pvt *dialog, const char *opeer, struct ast_sockaddr *addr, int newdialog, struct ast_sockaddr *remote_address);
01515 static char *generate_random_string(char *buf, size_t size);
01516 static void build_callid_pvt(struct sip_pvt *pvt);
01517 static void change_callid_pvt(struct sip_pvt *pvt, const char *callid);
01518 static void build_callid_registry(struct sip_registry *reg, const struct ast_sockaddr *ourip, const char *fromdomain);
01519 static void make_our_tag(char *tagbuf, size_t len);
01520 static int add_header(struct sip_request *req, const char *var, const char *value);
01521 static int add_header_max_forwards(struct sip_pvt *dialog, struct sip_request *req);
01522 static int add_content(struct sip_request *req, const char *line);
01523 static int finalize_content(struct sip_request *req);
01524 static int add_text(struct sip_request *req, const char *text);
01525 static int add_digit(struct sip_request *req, char digit, unsigned int duration, int mode);
01526 static int add_rpid(struct sip_request *req, struct sip_pvt *p);
01527 static int add_vidupdate(struct sip_request *req);
01528 static void add_route(struct sip_request *req, struct sip_route *route);
01529 static int copy_header(struct sip_request *req, const struct sip_request *orig, const char *field);
01530 static int copy_all_header(struct sip_request *req, const struct sip_request *orig, const char *field);
01531 static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, const struct sip_request *orig, const char *field);
01532 static void set_destination(struct sip_pvt *p, char *uri);
01533 static void append_date(struct sip_request *req);
01534 static void build_contact(struct sip_pvt *p);
01535
01536
01537 static int handle_incoming(struct sip_pvt *p, struct sip_request *req, struct ast_sockaddr *addr, int *recount, int *nounlock);
01538 static int handle_request_update(struct sip_pvt *p, struct sip_request *req);
01539 static int handle_request_invite(struct sip_pvt *p, struct sip_request *req, int debug, int seqno, struct ast_sockaddr *addr, int *recount, const char *e, int *nounlock);
01540 static int handle_request_refer(struct sip_pvt *p, struct sip_request *req, int debug, int seqno, int *nounlock);
01541 static int handle_request_bye(struct sip_pvt *p, struct sip_request *req);
01542 static int handle_request_register(struct sip_pvt *p, struct sip_request *req, struct ast_sockaddr *sin, const char *e);
01543 static int handle_request_cancel(struct sip_pvt *p, struct sip_request *req);
01544 static int handle_request_message(struct sip_pvt *p, struct sip_request *req);
01545 static int handle_request_subscribe(struct sip_pvt *p, struct sip_request *req, struct ast_sockaddr *addr, int seqno, const char *e);
01546 static void handle_request_info(struct sip_pvt *p, struct sip_request *req);
01547 static int handle_request_options(struct sip_pvt *p, struct sip_request *req, struct ast_sockaddr *addr, const char *e);
01548 static int handle_invite_replaces(struct sip_pvt *p, struct sip_request *req, int debug, int seqno, struct ast_sockaddr *addr, int *nounlock);
01549 static int handle_request_notify(struct sip_pvt *p, struct sip_request *req, struct ast_sockaddr *addr, int seqno, const char *e);
01550 static int local_attended_transfer(struct sip_pvt *transferer, struct sip_dual *current, struct sip_request *req, int seqno, int *nounlock);
01551
01552
01553 static void handle_response_publish(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno);
01554 static void handle_response_invite(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno);
01555 static void handle_response_notify(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno);
01556 static void handle_response_refer(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno);
01557 static void handle_response_subscribe(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno);
01558 static int handle_response_register(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno);
01559 static void handle_response(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno);
01560
01561
01562 static int setup_srtp(struct sip_srtp **srtp);
01563 static int process_crypto(struct sip_pvt *p, struct ast_rtp_instance *rtp, struct sip_srtp **srtp, const char *a);
01564
01565
01566 static int transmit_response_with_t38_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans);
01567 static struct ast_udptl *sip_get_udptl_peer(struct ast_channel *chan);
01568 static int sip_set_udptl_peer(struct ast_channel *chan, struct ast_udptl *udptl);
01569 static void change_t38_state(struct sip_pvt *p, int state);
01570
01571
01572 static void proc_422_rsp(struct sip_pvt *p, struct sip_request *rsp);
01573 static int proc_session_timer(const void *vp);
01574 static void stop_session_timer(struct sip_pvt *p);
01575 static void start_session_timer(struct sip_pvt *p);
01576 static void restart_session_timer(struct sip_pvt *p);
01577 static const char *strefresher2str(enum st_refresher r);
01578 static int parse_session_expires(const char *p_hdrval, int *const p_interval, enum st_refresher *const p_ref);
01579 static int parse_minse(const char *p_hdrval, int *const p_interval);
01580 static int st_get_se(struct sip_pvt *, int max);
01581 static enum st_refresher st_get_refresher(struct sip_pvt *);
01582 static enum st_mode st_get_mode(struct sip_pvt *, int no_cached);
01583 static struct sip_st_dlg* sip_st_alloc(struct sip_pvt *const p);
01584
01585
01586 static int sip_set_rtp_peer(struct ast_channel *chan, struct ast_rtp_instance *instance, struct ast_rtp_instance *vinstance, struct ast_rtp_instance *tinstance, format_t codecs, int nat_active);
01587
01588
01589 static int sip_subscribe_mwi(const char *value, int lineno);
01590 static void sip_subscribe_mwi_destroy(struct sip_subscription_mwi *mwi);
01591 static void sip_send_all_mwi_subscriptions(void);
01592 static int sip_subscribe_mwi_do(const void *data);
01593 static int __sip_subscribe_mwi_do(struct sip_subscription_mwi *mwi);
01594
01595
01596 const struct ast_channel_tech sip_tech = {
01597 .type = "SIP",
01598 .description = "Session Initiation Protocol (SIP)",
01599 .capabilities = AST_FORMAT_AUDIO_MASK,
01600 .properties = AST_CHAN_TP_WANTSJITTER | AST_CHAN_TP_CREATESJITTER,
01601 .requester = sip_request_call,
01602 .devicestate = sip_devicestate,
01603 .call = sip_call,
01604 .send_html = sip_sendhtml,
01605 .hangup = sip_hangup,
01606 .answer = sip_answer,
01607 .read = sip_read,
01608 .write = sip_write,
01609 .write_video = sip_write,
01610 .write_text = sip_write,
01611 .indicate = sip_indicate,
01612 .transfer = sip_transfer,
01613 .fixup = sip_fixup,
01614 .send_digit_begin = sip_senddigit_begin,
01615 .send_digit_end = sip_senddigit_end,
01616 .bridge = ast_rtp_instance_bridge,
01617 .early_bridge = ast_rtp_instance_early_bridge,
01618 .send_text = sip_sendtext,
01619 .func_channel_read = sip_acf_channel_read,
01620 .setoption = sip_setoption,
01621 .queryoption = sip_queryoption,
01622 .get_pvt_uniqueid = sip_get_callid,
01623 };
01624
01625
01626
01627
01628
01629
01630
01631 struct ast_channel_tech sip_tech_info;
01632
01633 static int sip_cc_agent_init(struct ast_cc_agent *agent, struct ast_channel *chan);
01634 static int sip_cc_agent_start_offer_timer(struct ast_cc_agent *agent);
01635 static int sip_cc_agent_stop_offer_timer(struct ast_cc_agent *agent);
01636 static void sip_cc_agent_respond(struct ast_cc_agent *agent, enum ast_cc_agent_response_reason reason);
01637 static int sip_cc_agent_status_request(struct ast_cc_agent *agent);
01638 static int sip_cc_agent_start_monitoring(struct ast_cc_agent *agent);
01639 static int sip_cc_agent_recall(struct ast_cc_agent *agent);
01640 static void sip_cc_agent_destructor(struct ast_cc_agent *agent);
01641
01642 static struct ast_cc_agent_callbacks sip_cc_agent_callbacks = {
01643 .type = "SIP",
01644 .init = sip_cc_agent_init,
01645 .start_offer_timer = sip_cc_agent_start_offer_timer,
01646 .stop_offer_timer = sip_cc_agent_stop_offer_timer,
01647 .respond = sip_cc_agent_respond,
01648 .status_request = sip_cc_agent_status_request,
01649 .start_monitoring = sip_cc_agent_start_monitoring,
01650 .callee_available = sip_cc_agent_recall,
01651 .destructor = sip_cc_agent_destructor,
01652 };
01653
01654 static int find_by_notify_uri_helper(void *obj, void *arg, int flags)
01655 {
01656 struct ast_cc_agent *agent = obj;
01657 struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
01658 const char *uri = arg;
01659
01660 return !sip_uri_cmp(agent_pvt->notify_uri, uri) ? CMP_MATCH | CMP_STOP : 0;
01661 }
01662
01663 static struct ast_cc_agent *find_sip_cc_agent_by_notify_uri(const char * const uri)
01664 {
01665 struct ast_cc_agent *agent = ast_cc_agent_callback(0, find_by_notify_uri_helper, (char *)uri, "SIP");
01666 return agent;
01667 }
01668
01669 static int find_by_subscribe_uri_helper(void *obj, void *arg, int flags)
01670 {
01671 struct ast_cc_agent *agent = obj;
01672 struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
01673 const char *uri = arg;
01674
01675 return !sip_uri_cmp(agent_pvt->subscribe_uri, uri) ? CMP_MATCH | CMP_STOP : 0;
01676 }
01677
01678 static struct ast_cc_agent *find_sip_cc_agent_by_subscribe_uri(const char * const uri)
01679 {
01680 struct ast_cc_agent *agent = ast_cc_agent_callback(0, find_by_subscribe_uri_helper, (char *)uri, "SIP");
01681 return agent;
01682 }
01683
01684 static int find_by_callid_helper(void *obj, void *arg, int flags)
01685 {
01686 struct ast_cc_agent *agent = obj;
01687 struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
01688 struct sip_pvt *call_pvt = arg;
01689
01690 return !strcmp(agent_pvt->original_callid, call_pvt->callid) ? CMP_MATCH | CMP_STOP : 0;
01691 }
01692
01693 static struct ast_cc_agent *find_sip_cc_agent_by_original_callid(struct sip_pvt *pvt)
01694 {
01695 struct ast_cc_agent *agent = ast_cc_agent_callback(0, find_by_callid_helper, pvt, "SIP");
01696 return agent;
01697 }
01698
01699 static int sip_cc_agent_init(struct ast_cc_agent *agent, struct ast_channel *chan)
01700 {
01701 struct sip_cc_agent_pvt *agent_pvt = ast_calloc(1, sizeof(*agent_pvt));
01702 struct sip_pvt *call_pvt = chan->tech_pvt;
01703
01704 if (!agent_pvt) {
01705 return -1;
01706 }
01707
01708 ast_assert(!strcmp(chan->tech->type, "SIP"));
01709
01710 ast_copy_string(agent_pvt->original_callid, call_pvt->callid, sizeof(agent_pvt->original_callid));
01711 ast_copy_string(agent_pvt->original_exten, call_pvt->exten, sizeof(agent_pvt->original_exten));
01712 agent_pvt->offer_timer_id = -1;
01713 agent->private_data = agent_pvt;
01714 sip_pvt_lock(call_pvt);
01715 ast_set_flag(&call_pvt->flags[0], SIP_OFFER_CC);
01716 sip_pvt_unlock(call_pvt);
01717 return 0;
01718 }
01719
01720 static int sip_offer_timer_expire(const void *data)
01721 {
01722 struct ast_cc_agent *agent = (struct ast_cc_agent *) data;
01723 struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
01724
01725 agent_pvt->offer_timer_id = -1;
01726
01727 return ast_cc_failed(agent->core_id, "SIP agent %s's offer timer expired", agent->device_name);
01728 }
01729
01730 static int sip_cc_agent_start_offer_timer(struct ast_cc_agent *agent)
01731 {
01732 struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
01733 int when;
01734
01735 when = ast_get_cc_offer_timer(agent->cc_params) * 1000;
01736 agent_pvt->offer_timer_id = ast_sched_add(sched, when, sip_offer_timer_expire, agent);
01737 return 0;
01738 }
01739
01740 static int sip_cc_agent_stop_offer_timer(struct ast_cc_agent *agent)
01741 {
01742 struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
01743
01744 AST_SCHED_DEL(sched, agent_pvt->offer_timer_id);
01745 return 0;
01746 }
01747
01748 static void sip_cc_agent_respond(struct ast_cc_agent *agent, enum ast_cc_agent_response_reason reason)
01749 {
01750 struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
01751
01752 sip_pvt_lock(agent_pvt->subscribe_pvt);
01753 ast_set_flag(&agent_pvt->subscribe_pvt->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
01754 if (reason == AST_CC_AGENT_RESPONSE_SUCCESS || !ast_strlen_zero(agent_pvt->notify_uri)) {
01755
01756
01757
01758
01759
01760
01761
01762
01763
01764
01765
01766
01767 transmit_response(agent_pvt->subscribe_pvt, "200 OK", &agent_pvt->subscribe_pvt->initreq);
01768 transmit_cc_notify(agent, agent_pvt->subscribe_pvt, CC_QUEUED);
01769 } else {
01770 transmit_response(agent_pvt->subscribe_pvt, "500 Internal Error", &agent_pvt->subscribe_pvt->initreq);
01771 }
01772 sip_pvt_unlock(agent_pvt->subscribe_pvt);
01773 agent_pvt->is_available = TRUE;
01774 }
01775
01776 static int sip_cc_agent_status_request(struct ast_cc_agent *agent)
01777 {
01778 struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
01779 enum ast_device_state state = agent_pvt->is_available ? AST_DEVICE_NOT_INUSE : AST_DEVICE_INUSE;
01780 return ast_cc_agent_status_response(agent->core_id, state);
01781 }
01782
01783 static int sip_cc_agent_start_monitoring(struct ast_cc_agent *agent)
01784 {
01785
01786
01787
01788
01789 return 0;
01790 }
01791
01792 static int sip_cc_agent_recall(struct ast_cc_agent *agent)
01793 {
01794 struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
01795
01796
01797
01798
01799 if (!agent_pvt->is_available) {
01800 return ast_cc_agent_caller_busy(agent->core_id, "Caller %s is busy, reporting to the core",
01801 agent->device_name);
01802 }
01803
01804
01805
01806 sip_pvt_lock(agent_pvt->subscribe_pvt);
01807 transmit_cc_notify(agent, agent_pvt->subscribe_pvt, CC_READY);
01808 sip_pvt_unlock(agent_pvt->subscribe_pvt);
01809 return 0;
01810 }
01811
01812 static void sip_cc_agent_destructor(struct ast_cc_agent *agent)
01813 {
01814 struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
01815
01816 if (!agent_pvt) {
01817
01818 return;
01819 }
01820
01821 sip_cc_agent_stop_offer_timer(agent);
01822 if (agent_pvt->subscribe_pvt) {
01823 sip_pvt_lock(agent_pvt->subscribe_pvt);
01824 if (!ast_test_flag(&agent_pvt->subscribe_pvt->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED)) {
01825
01826
01827
01828 transmit_response(agent_pvt->subscribe_pvt, "500 Internal Server Error", &agent_pvt->subscribe_pvt->initreq);
01829 }
01830 sip_pvt_unlock(agent_pvt->subscribe_pvt);
01831 agent_pvt->subscribe_pvt = dialog_unref(agent_pvt->subscribe_pvt, "SIP CC agent destructor: Remove ref to subscription");
01832 }
01833 ast_free(agent_pvt);
01834 }
01835
01836 struct ao2_container *sip_monitor_instances;
01837
01838 static int sip_monitor_instance_hash_fn(const void *obj, const int flags)
01839 {
01840 const struct sip_monitor_instance *monitor_instance = obj;
01841 return monitor_instance->core_id;
01842 }
01843
01844 static int sip_monitor_instance_cmp_fn(void *obj, void *arg, int flags)
01845 {
01846 struct sip_monitor_instance *monitor_instance1 = obj;
01847 struct sip_monitor_instance *monitor_instance2 = arg;
01848
01849 return monitor_instance1->core_id == monitor_instance2->core_id ? CMP_MATCH | CMP_STOP : 0;
01850 }
01851
01852 static void sip_monitor_instance_destructor(void *data)
01853 {
01854 struct sip_monitor_instance *monitor_instance = data;
01855 if (monitor_instance->subscription_pvt) {
01856 sip_pvt_lock(monitor_instance->subscription_pvt);
01857 monitor_instance->subscription_pvt->expiry = 0;
01858 transmit_invite(monitor_instance->subscription_pvt, SIP_SUBSCRIBE, FALSE, 0, monitor_instance->subscribe_uri);
01859 sip_pvt_unlock(monitor_instance->subscription_pvt);
01860 dialog_unref(monitor_instance->subscription_pvt, "Unref monitor instance ref of subscription pvt");
01861 }
01862 if (monitor_instance->suspension_entry) {
01863 monitor_instance->suspension_entry->body[0] = '\0';
01864 transmit_publish(monitor_instance->suspension_entry, SIP_PUBLISH_REMOVE ,monitor_instance->notify_uri);
01865 ao2_t_ref(monitor_instance->suspension_entry, -1, "Decrementing suspension entry refcount in sip_monitor_instance_destructor");
01866 }
01867 ast_string_field_free_memory(monitor_instance);
01868 }
01869
01870 static struct sip_monitor_instance *sip_monitor_instance_init(int core_id, const char * const subscribe_uri, const char * const peername, const char * const device_name)
01871 {
01872 struct sip_monitor_instance *monitor_instance = ao2_alloc(sizeof(*monitor_instance), sip_monitor_instance_destructor);
01873
01874 if (!monitor_instance) {
01875 return NULL;
01876 }
01877
01878 if (ast_string_field_init(monitor_instance, 256)) {
01879 ao2_ref(monitor_instance, -1);
01880 return NULL;
01881 }
01882
01883 ast_string_field_set(monitor_instance, subscribe_uri, subscribe_uri);
01884 ast_string_field_set(monitor_instance, peername, peername);
01885 ast_string_field_set(monitor_instance, device_name, device_name);
01886 monitor_instance->core_id = core_id;
01887 ao2_link(sip_monitor_instances, monitor_instance);
01888 return monitor_instance;
01889 }
01890
01891 static int find_sip_monitor_instance_by_subscription_pvt(void *obj, void *arg, int flags)
01892 {
01893 struct sip_monitor_instance *monitor_instance = obj;
01894 return monitor_instance->subscription_pvt == arg ? CMP_MATCH | CMP_STOP : 0;
01895 }
01896
01897 static int find_sip_monitor_instance_by_suspension_entry(void *obj, void *arg, int flags)
01898 {
01899 struct sip_monitor_instance *monitor_instance = obj;
01900 return monitor_instance->suspension_entry == arg ? CMP_MATCH | CMP_STOP : 0;
01901 }
01902
01903 static int sip_cc_monitor_request_cc(struct ast_cc_monitor *monitor, int *available_timer_id);
01904 static int sip_cc_monitor_suspend(struct ast_cc_monitor *monitor);
01905 static int sip_cc_monitor_unsuspend(struct ast_cc_monitor *monitor);
01906 static int sip_cc_monitor_cancel_available_timer(struct ast_cc_monitor *monitor, int *sched_id);
01907 static void sip_cc_monitor_destructor(void *private_data);
01908
01909 static struct ast_cc_monitor_callbacks sip_cc_monitor_callbacks = {
01910 .type = "SIP",
01911 .request_cc = sip_cc_monitor_request_cc,
01912 .suspend = sip_cc_monitor_suspend,
01913 .unsuspend = sip_cc_monitor_unsuspend,
01914 .cancel_available_timer = sip_cc_monitor_cancel_available_timer,
01915 .destructor = sip_cc_monitor_destructor,
01916 };
01917
01918 static int sip_cc_monitor_request_cc(struct ast_cc_monitor *monitor, int *available_timer_id)
01919 {
01920 struct sip_monitor_instance *monitor_instance = monitor->private_data;
01921 enum ast_cc_service_type service = monitor->service_offered;
01922 int when;
01923
01924 if (!monitor_instance) {
01925 return -1;
01926 }
01927
01928 if (!(monitor_instance->subscription_pvt = sip_alloc(NULL, NULL, 0, SIP_SUBSCRIBE, NULL))) {
01929 return -1;
01930 }
01931
01932 when = service == AST_CC_CCBS ? ast_get_ccbs_available_timer(monitor->interface->config_params) :
01933 ast_get_ccnr_available_timer(monitor->interface->config_params);
01934
01935 sip_pvt_lock(monitor_instance->subscription_pvt);
01936 ast_set_flag(&monitor_instance->subscription_pvt->flags[0], SIP_OUTGOING);
01937 create_addr(monitor_instance->subscription_pvt, monitor_instance->peername, 0, 1, NULL);
01938 ast_sip_ouraddrfor(&monitor_instance->subscription_pvt->sa, &monitor_instance->subscription_pvt->ourip, monitor_instance->subscription_pvt);
01939 monitor_instance->subscription_pvt->subscribed = CALL_COMPLETION;
01940 monitor_instance->subscription_pvt->expiry = when;
01941
01942 transmit_invite(monitor_instance->subscription_pvt, SIP_SUBSCRIBE, FALSE, 2, monitor_instance->subscribe_uri);
01943 sip_pvt_unlock(monitor_instance->subscription_pvt);
01944
01945 ao2_t_ref(monitor, +1, "Adding a ref to the monitor for the scheduler");
01946 *available_timer_id = ast_sched_add(sched, when * 1000, ast_cc_available_timer_expire, monitor);
01947 return 0;
01948 }
01949
01950 static int construct_pidf_body(enum sip_cc_publish_state state, char *pidf_body, size_t size, const char *presentity)
01951 {
01952 struct ast_str *body = ast_str_alloca(size);
01953 char tuple_id[32];
01954
01955 generate_random_string(tuple_id, sizeof(tuple_id));
01956
01957
01958
01959
01960 ast_str_append(&body, 0, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
01961
01962
01963
01964
01965
01966
01967 ast_str_append(&body, 0, "<presence xmlns=\"urn:ietf:params:xml:ns:pidf\" entity=\"%s\">\n", presentity);
01968 ast_str_append(&body, 0, "<tuple id=\"%s\">\n", tuple_id);
01969 ast_str_append(&body, 0, "<status><basic>%s</basic></status>\n", state == CC_OPEN ? "open" : "closed");
01970 ast_str_append(&body, 0, "</tuple>\n");
01971 ast_str_append(&body, 0, "</presence>\n");
01972 ast_copy_string(pidf_body, ast_str_buffer(body), size);
01973 return 0;
01974 }
01975
01976 static int sip_cc_monitor_suspend(struct ast_cc_monitor *monitor)
01977 {
01978 struct sip_monitor_instance *monitor_instance = monitor->private_data;
01979 enum sip_publish_type publish_type;
01980 struct cc_epa_entry *cc_entry;
01981
01982 if (!monitor_instance) {
01983 return -1;
01984 }
01985
01986 if (!monitor_instance->suspension_entry) {
01987
01988 if (!(monitor_instance->suspension_entry = create_epa_entry("call-completion", monitor_instance->peername))) {
01989 ast_log(LOG_WARNING, "Unable to allocate sip EPA entry for call-completion\n");
01990 ao2_ref(monitor_instance, -1);
01991 return -1;
01992 }
01993 if (!(cc_entry = ast_calloc(1, sizeof(*cc_entry)))) {
01994 ast_log(LOG_WARNING, "Unable to allocate space for instance data of EPA entry for call-completion\n");
01995 ao2_ref(monitor_instance, -1);
01996 return -1;
01997 }
01998 cc_entry->core_id = monitor->core_id;
01999 monitor_instance->suspension_entry->instance_data = cc_entry;
02000 publish_type = SIP_PUBLISH_INITIAL;
02001 } else {
02002 publish_type = SIP_PUBLISH_MODIFY;
02003 cc_entry = monitor_instance->suspension_entry->instance_data;
02004 }
02005
02006 cc_entry->current_state = CC_CLOSED;
02007
02008 if (ast_strlen_zero(monitor_instance->notify_uri)) {
02009
02010
02011
02012
02013
02014
02015
02016
02017
02018
02019
02020
02021 return 0;
02022 }
02023 construct_pidf_body(CC_CLOSED, monitor_instance->suspension_entry->body, sizeof(monitor_instance->suspension_entry->body), monitor_instance->peername);
02024 return transmit_publish(monitor_instance->suspension_entry, publish_type, monitor_instance->notify_uri);
02025 }
02026
02027 static int sip_cc_monitor_unsuspend(struct ast_cc_monitor *monitor)
02028 {
02029 struct sip_monitor_instance *monitor_instance = monitor->private_data;
02030 struct cc_epa_entry *cc_entry;
02031
02032 if (!monitor_instance) {
02033 return -1;
02034 }
02035
02036 ast_assert(monitor_instance->suspension_entry != NULL);
02037
02038 cc_entry = monitor_instance->suspension_entry->instance_data;
02039 cc_entry->current_state = CC_OPEN;
02040 if (ast_strlen_zero(monitor_instance->notify_uri)) {
02041
02042
02043
02044
02045 return 0;
02046 }
02047 construct_pidf_body(CC_OPEN, monitor_instance->suspension_entry->body, sizeof(monitor_instance->suspension_entry->body), monitor_instance->peername);
02048 return transmit_publish(monitor_instance->suspension_entry, SIP_PUBLISH_MODIFY, monitor_instance->notify_uri);
02049 }
02050
02051 static int sip_cc_monitor_cancel_available_timer(struct ast_cc_monitor *monitor, int *sched_id)
02052 {
02053 if (*sched_id != -1) {
02054 AST_SCHED_DEL(sched, *sched_id);
02055 ao2_t_ref(monitor, -1, "Removing scheduler's reference to the monitor");
02056 }
02057 return 0;
02058 }
02059
02060 static void sip_cc_monitor_destructor(void *private_data)
02061 {
02062 struct sip_monitor_instance *monitor_instance = private_data;
02063 ao2_unlink(sip_monitor_instances, monitor_instance);
02064 ast_module_unref(ast_module_info->self);
02065 }
02066
02067 static int sip_get_cc_information(struct sip_request *req, char *subscribe_uri, size_t size, enum ast_cc_service_type *service)
02068 {
02069 char *call_info = ast_strdupa(get_header(req, "Call-Info"));
02070 char *uri;
02071 char *purpose;
02072 char *service_str;
02073 static const char cc_purpose[] = "purpose=call-completion";
02074 static const int cc_purpose_len = sizeof(cc_purpose) - 1;
02075
02076 if (ast_strlen_zero(call_info)) {
02077
02078 return -1;
02079 }
02080
02081 uri = strsep(&call_info, ";");
02082
02083 while ((purpose = strsep(&call_info, ";"))) {
02084 if (!strncmp(purpose, cc_purpose, cc_purpose_len)) {
02085 break;
02086 }
02087 }
02088 if (!purpose) {
02089
02090 return -1;
02091 }
02092
02093
02094 while ((service_str = strsep(&call_info, ";"))) {
02095 if (!strncmp(service_str, "m=", 2)) {
02096 break;
02097 }
02098 }
02099 if (!service_str) {
02100
02101
02102
02103 service_str = "BS";
02104 } else {
02105
02106
02107
02108 strsep(&service_str, "=");
02109 }
02110
02111 if ((*service = service_string_to_service_type(service_str)) == AST_CC_NONE) {
02112
02113 return -1;
02114 }
02115
02116 ast_copy_string(subscribe_uri, get_in_brackets(uri), size);
02117
02118 return 0;
02119 }
02120
02121
02122
02123
02124
02125
02126
02127
02128
02129
02130
02131
02132
02133
02134
02135
02136
02137
02138 static void sip_handle_cc(struct sip_pvt *pvt, struct sip_request *req, enum ast_cc_service_type service)
02139 {
02140 enum ast_cc_monitor_policies monitor_policy = ast_get_cc_monitor_policy(pvt->cc_params);
02141 int core_id;
02142 char interface_name[AST_CHANNEL_NAME];
02143
02144 if (monitor_policy == AST_CC_MONITOR_NEVER) {
02145
02146 return;
02147 }
02148
02149 if ((core_id = ast_cc_get_current_core_id(pvt->owner)) == -1) {
02150
02151 return;
02152 }
02153
02154 ast_channel_get_device_name(pvt->owner, interface_name, sizeof(interface_name));
02155
02156 if (monitor_policy == AST_CC_MONITOR_ALWAYS || monitor_policy == AST_CC_MONITOR_NATIVE) {
02157 char subscribe_uri[SIPBUFSIZE];
02158 char device_name[AST_CHANNEL_NAME];
02159 enum ast_cc_service_type offered_service;
02160 struct sip_monitor_instance *monitor_instance;
02161 if (sip_get_cc_information(req, subscribe_uri, sizeof(subscribe_uri), &offered_service)) {
02162
02163
02164
02165
02166 goto generic;
02167 }
02168 ast_channel_get_device_name(pvt->owner, device_name, sizeof(device_name));
02169 if (!(monitor_instance = sip_monitor_instance_init(core_id, subscribe_uri, pvt->peername, device_name))) {
02170
02171 goto generic;
02172 }
02173
02174
02175
02176
02177 ast_module_ref(ast_module_info->self);
02178 ast_queue_cc_frame(pvt->owner, "SIP", pvt->dialstring, offered_service, monitor_instance);
02179 ao2_ref(monitor_instance, -1);
02180 return;
02181 }
02182
02183 generic:
02184 if (monitor_policy == AST_CC_MONITOR_GENERIC || monitor_policy == AST_CC_MONITOR_ALWAYS) {
02185 ast_queue_cc_frame(pvt->owner, AST_CC_GENERIC_MONITOR_TYPE, interface_name, service, NULL);
02186 }
02187 }
02188
02189
02190 static struct ast_tls_config sip_tls_cfg;
02191
02192
02193 static struct ast_tls_config default_tls_cfg;
02194
02195
02196 static struct ast_tcptls_session_args sip_tcp_desc = {
02197 .accept_fd = -1,
02198 .master = AST_PTHREADT_NULL,
02199 .tls_cfg = NULL,
02200 .poll_timeout = -1,
02201 .name = "SIP TCP server",
02202 .accept_fn = ast_tcptls_server_root,
02203 .worker_fn = sip_tcp_worker_fn,
02204 };
02205
02206
02207 static struct ast_tcptls_session_args sip_tls_desc = {
02208 .accept_fd = -1,
02209 .master = AST_PTHREADT_NULL,
02210 .tls_cfg = &sip_tls_cfg,
02211 .poll_timeout = -1,
02212 .name = "SIP TLS server",
02213 .accept_fn = ast_tcptls_server_root,
02214 .worker_fn = sip_tcp_worker_fn,
02215 };
02216
02217
02218
02219 #define append_history(p, event, fmt , args... ) append_history_full(p, "%-15s " fmt, event, ## args)
02220
02221 struct sip_pvt *dialog_ref_debug(struct sip_pvt *p, char *tag, char *file, int line, const char *func)
02222 {
02223 if (p)
02224 #ifdef REF_DEBUG
02225 __ao2_ref_debug(p, 1, tag, file, line, func);
02226 #else
02227 ao2_ref(p, 1);
02228 #endif
02229 else
02230 ast_log(LOG_ERROR, "Attempt to Ref a null pointer\n");
02231 return p;
02232 }
02233
02234 struct sip_pvt *dialog_unref_debug(struct sip_pvt *p, char *tag, char *file, int line, const char *func)
02235 {
02236 if (p)
02237 #ifdef REF_DEBUG
02238 __ao2_ref_debug(p, -1, tag, file, line, func);
02239 #else
02240 ao2_ref(p, -1);
02241 #endif
02242 return NULL;
02243 }
02244
02245
02246
02247
02248 static const char *map_x_s(const struct _map_x_s *table, int x, const char *errorstring)
02249 {
02250 const struct _map_x_s *cur;
02251
02252 for (cur = table; cur->s; cur++)
02253 if (cur->x == x)
02254 return cur->s;
02255 return errorstring;
02256 }
02257
02258
02259
02260
02261 static int map_s_x(const struct _map_x_s *table, const char *s, int errorvalue)
02262 {
02263 const struct _map_x_s *cur;
02264
02265 for (cur = table; cur->s; cur++)
02266 if (!strcasecmp(cur->s, s))
02267 return cur->x;
02268 return errorvalue;
02269 }
02270
02271 static enum AST_REDIRECTING_REASON sip_reason_str_to_code(const char *text)
02272 {
02273 enum AST_REDIRECTING_REASON ast = AST_REDIRECTING_REASON_UNKNOWN;
02274 int i;
02275
02276 for (i = 0; i < ARRAY_LEN(sip_reason_table); ++i) {
02277 if (!strcasecmp(text, sip_reason_table[i].text)) {
02278 ast = sip_reason_table[i].code;
02279 break;
02280 }
02281 }
02282
02283 return ast;
02284 }
02285
02286 static const char *sip_reason_code_to_str(enum AST_REDIRECTING_REASON code)
02287 {
02288 if (code >= 0 && code < ARRAY_LEN(sip_reason_table)) {
02289 return sip_reason_table[code].text;
02290 }
02291
02292 return "unknown";
02293 }
02294
02295
02296
02297
02298
02299
02300
02301
02302 #define check_request_transport(peer, tmpl) ({ \
02303 int ret = 0; \
02304 if (peer->socket.type == tmpl->socket.type) \
02305 ; \
02306 else if (!(peer->transports & tmpl->socket.type)) {\
02307 ast_log(LOG_ERROR, \
02308 "'%s' is not a valid transport for '%s'. we only use '%s'! ending call.\n", \
02309 get_transport(tmpl->socket.type), peer->name, get_transport_list(peer->transports) \
02310 ); \
02311 ret = 1; \
02312 } else if (peer->socket.type & SIP_TRANSPORT_TLS) { \
02313 ast_log(LOG_WARNING, \
02314 "peer '%s' HAS NOT USED (OR SWITCHED TO) TLS in favor of '%s' (but this was allowed in sip.conf)!\n", \
02315 peer->name, get_transport(tmpl->socket.type) \
02316 ); \
02317 } else { \
02318 ast_debug(1, \
02319 "peer '%s' has contacted us over %s even though we prefer %s.\n", \
02320 peer->name, get_transport(tmpl->socket.type), get_transport(peer->socket.type) \
02321 ); \
02322 }\
02323 (ret); \
02324 })
02325
02326
02327
02328
02329 static struct ast_variable *copy_vars(struct ast_variable *src)
02330 {
02331 struct ast_variable *res = NULL, *tmp, *v = NULL;
02332
02333 for (v = src ; v ; v = v->next) {
02334 if ((tmp = ast_variable_new(v->name, v->value, v->file))) {
02335 tmp->next = res;
02336 res = tmp;
02337 }
02338 }
02339 return res;
02340 }
02341
02342 static void tcptls_packet_destructor(void *obj)
02343 {
02344 struct tcptls_packet *packet = obj;
02345
02346 ast_free(packet->data);
02347 }
02348
02349 static void sip_tcptls_client_args_destructor(void *obj)
02350 {
02351 struct ast_tcptls_session_args *args = obj;
02352 if (args->tls_cfg) {
02353 ast_free(args->tls_cfg->certfile);
02354 ast_free(args->tls_cfg->pvtfile);
02355 ast_free(args->tls_cfg->cipher);
02356 ast_free(args->tls_cfg->cafile);
02357 ast_free(args->tls_cfg->capath);
02358 }
02359 ast_free(args->tls_cfg);
02360 ast_free((char *) args->name);
02361 }
02362
02363 static void sip_threadinfo_destructor(void *obj)
02364 {
02365 struct sip_threadinfo *th = obj;
02366 struct tcptls_packet *packet;
02367 if (th->alert_pipe[1] > -1) {
02368 close(th->alert_pipe[0]);
02369 }
02370 if (th->alert_pipe[1] > -1) {
02371 close(th->alert_pipe[1]);
02372 }
02373 th->alert_pipe[0] = th->alert_pipe[1] = -1;
02374
02375 while ((packet = AST_LIST_REMOVE_HEAD(&th->packet_q, entry))) {
02376 ao2_t_ref(packet, -1, "thread destruction, removing packet from frame queue");
02377 }
02378
02379 if (th->tcptls_session) {
02380 ao2_t_ref(th->tcptls_session, -1, "remove tcptls_session for sip_threadinfo object");
02381 }
02382 }
02383
02384
02385 static struct sip_threadinfo *sip_threadinfo_create(struct ast_tcptls_session_instance *tcptls_session, int transport)
02386 {
02387 struct sip_threadinfo *th;
02388
02389 if (!tcptls_session || !(th = ao2_alloc(sizeof(*th), sip_threadinfo_destructor))) {
02390 return NULL;
02391 }
02392
02393 th->alert_pipe[0] = th->alert_pipe[1] = -1;
02394
02395 if (pipe(th->alert_pipe) == -1) {
02396 ao2_t_ref(th, -1, "Failed to open alert pipe on sip_threadinfo");
02397 ast_log(LOG_ERROR, "Could not create sip alert pipe in tcptls thread, error %s\n", strerror(errno));
02398 return NULL;
02399 }
02400 ao2_t_ref(tcptls_session, +1, "tcptls_session ref for sip_threadinfo object");
02401 th->tcptls_session = tcptls_session;
02402 th->type = transport ? transport : (tcptls_session->ssl ? SIP_TRANSPORT_TLS: SIP_TRANSPORT_TCP);
02403 ao2_t_link(threadt, th, "Adding new tcptls helper thread");
02404 ao2_t_ref(th, -1, "Decrementing threadinfo ref from alloc, only table ref remains");
02405 return th;
02406 }
02407
02408
02409 static int sip_tcptls_write(struct ast_tcptls_session_instance *tcptls_session, const void *buf, size_t len)
02410 {
02411 int res = len;
02412 struct sip_threadinfo *th = NULL;
02413 struct tcptls_packet *packet = NULL;
02414 struct sip_threadinfo tmp = {
02415 .tcptls_session = tcptls_session,
02416 };
02417 enum sip_tcptls_alert alert = TCPTLS_ALERT_DATA;
02418
02419 if (!tcptls_session) {
02420 return XMIT_ERROR;
02421 }
02422
02423 ast_mutex_lock(&tcptls_session->lock);
02424
02425 if ((tcptls_session->fd == -1) ||
02426 !(th = ao2_t_find(threadt, &tmp, OBJ_POINTER, "ao2_find, getting sip_threadinfo in tcp helper thread")) ||
02427 !(packet = ao2_alloc(sizeof(*packet), tcptls_packet_destructor)) ||
02428 !(packet->data = ast_str_create(len))) {
02429 goto tcptls_write_setup_error;
02430 }
02431
02432
02433 ast_str_set(&packet->data, 0, "%s", (char *) buf);
02434 packet->len = len;
02435
02436
02437
02438
02439 ao2_lock(th);
02440 if (write(th->alert_pipe[1], &alert, sizeof(alert)) == -1) {
02441 ast_log(LOG_ERROR, "write() to alert pipe failed: %s\n", strerror(errno));
02442 ao2_t_ref(packet, -1, "could not write to alert pipe, remove packet");
02443 packet = NULL;
02444 res = XMIT_ERROR;
02445 } else {
02446 AST_LIST_INSERT_TAIL(&th->packet_q, packet, entry);
02447 }
02448 ao2_unlock(th);
02449
02450 ast_mutex_unlock(&tcptls_session->lock);
02451 ao2_t_ref(th, -1, "In sip_tcptls_write, unref threadinfo object after finding it");
02452 return res;
02453
02454 tcptls_write_setup_error:
02455 if (th) {
02456 ao2_t_ref(th, -1, "In sip_tcptls_write, unref threadinfo obj, could not create packet");
02457 }
02458 if (packet) {
02459 ao2_t_ref(packet, -1, "could not allocate packet's data");
02460 }
02461 ast_mutex_unlock(&tcptls_session->lock);
02462
02463 return XMIT_ERROR;
02464 }
02465
02466
02467 static void *sip_tcp_worker_fn(void *data)
02468 {
02469 struct ast_tcptls_session_instance *tcptls_session = data;
02470
02471 return _sip_tcp_helper_thread(NULL, tcptls_session);
02472 }
02473
02474
02475
02476
02477
02478
02479
02480
02481 static int sip_check_authtimeout(time_t start)
02482 {
02483 int timeout;
02484 time_t now;
02485 if(time(&now) == -1) {
02486 ast_log(LOG_ERROR, "error executing time(): %s\n", strerror(errno));
02487 return -1;
02488 }
02489
02490 timeout = (authtimeout - (now - start)) * 1000;
02491 if (timeout < 0) {
02492
02493 return 0;
02494 }
02495
02496 return timeout;
02497 }
02498
02499
02500
02501
02502 static void *_sip_tcp_helper_thread(struct sip_pvt *pvt, struct ast_tcptls_session_instance *tcptls_session)
02503 {
02504 int res, cl, timeout = -1, authenticated = 0, flags, after_poll = 0, need_poll = 1;
02505 time_t start;
02506 struct sip_request req = { 0, } , reqcpy = { 0, };
02507 struct sip_threadinfo *me = NULL;
02508 char buf[1024] = "";
02509 struct pollfd fds[2] = { { 0 }, { 0 }, };
02510 struct ast_tcptls_session_args *ca = NULL;
02511
02512
02513
02514
02515
02516
02517
02518
02519
02520
02521
02522
02523 if (!tcptls_session->client) {
02524 if (ast_atomic_fetchadd_int(&unauth_sessions, +1) >= authlimit) {
02525
02526 goto cleanup;
02527 }
02528
02529 if ((flags = fcntl(tcptls_session->fd, F_GETFL)) == -1) {
02530 ast_log(LOG_ERROR, "error setting socket to non blocking mode, fcntl() failed: %s\n", strerror(errno));
02531 goto cleanup;
02532 }
02533
02534 flags |= O_NONBLOCK;
02535 if (fcntl(tcptls_session->fd, F_SETFL, flags) == -1) {
02536 ast_log(LOG_ERROR, "error setting socket to non blocking mode, fcntl() failed: %s\n", strerror(errno));
02537 goto cleanup;
02538 }
02539
02540 if (!(me = sip_threadinfo_create(tcptls_session, tcptls_session->ssl ? SIP_TRANSPORT_TLS : SIP_TRANSPORT_TCP))) {
02541 goto cleanup;
02542 }
02543 ao2_t_ref(me, +1, "Adding threadinfo ref for tcp_helper_thread");
02544 } else {
02545 struct sip_threadinfo tmp = {
02546 .tcptls_session = tcptls_session,
02547 };
02548
02549 if ((!(ca = tcptls_session->parent)) ||
02550 (!(me = ao2_t_find(threadt, &tmp, OBJ_POINTER, "ao2_find, getting sip_threadinfo in tcp helper thread"))) ||
02551 (!(tcptls_session = ast_tcptls_client_start(tcptls_session)))) {
02552 goto cleanup;
02553 }
02554 }
02555
02556 flags = 1;
02557 if (setsockopt(tcptls_session->fd, SOL_SOCKET, SO_KEEPALIVE, &flags, sizeof(flags))) {
02558 ast_log(LOG_ERROR, "error enabling TCP keep-alives on sip socket: %s\n", strerror(errno));
02559 goto cleanup;
02560 }
02561
02562 me->threadid = pthread_self();
02563 ast_debug(2, "Starting thread for %s server\n", tcptls_session->ssl ? "SSL" : "TCP");
02564
02565
02566 fds[0].fd = tcptls_session->fd;
02567 fds[1].fd = me->alert_pipe[0];
02568 fds[0].events = fds[1].events = POLLIN | POLLPRI;
02569
02570 if (!(req.data = ast_str_create(SIP_MIN_PACKET))) {
02571 goto cleanup;
02572 }
02573 if (!(reqcpy.data = ast_str_create(SIP_MIN_PACKET))) {
02574 goto cleanup;
02575 }
02576
02577 if(time(&start) == -1) {
02578 ast_log(LOG_ERROR, "error executing time(): %s\n", strerror(errno));
02579 goto cleanup;
02580 }
02581
02582 for (;;) {
02583 struct ast_str *str_save;
02584
02585 if (!tcptls_session->client && req.authenticated && !authenticated) {
02586 authenticated = 1;
02587 ast_atomic_fetchadd_int(&unauth_sessions, -1);
02588 }
02589
02590
02591 if (!tcptls_session->client && !authenticated ) {
02592 if ((timeout = sip_check_authtimeout(start)) < 0) {
02593 goto cleanup;
02594 }
02595
02596 if (timeout == 0) {
02597 ast_debug(2, "SIP %s server timed out\n", tcptls_session->ssl ? "SSL": "TCP");
02598 goto cleanup;
02599 }
02600 } else {
02601 timeout = -1;
02602 }
02603
02604 res = ast_poll(fds, 2, timeout);
02605 if (res < 0) {
02606 ast_debug(2, "SIP %s server :: ast_wait_for_input returned %d\n", tcptls_session->ssl ? "SSL": "TCP", res);
02607 goto cleanup;
02608 } else if (res == 0) {
02609
02610 ast_debug(2, "SIP %s server timed out\n", tcptls_session->ssl ? "SSL": "TCP");
02611 goto cleanup;
02612 }
02613
02614
02615
02616 if (fds[0].revents) {
02617 after_poll = 1;
02618
02619 fds[0].revents = 0;
02620
02621
02622 str_save = req.data;
02623 memset(&req, 0, sizeof(req));
02624 req.data = str_save;
02625 ast_str_reset(req.data);
02626
02627 str_save = reqcpy.data;
02628 memset(&reqcpy, 0, sizeof(reqcpy));
02629 reqcpy.data = str_save;
02630 ast_str_reset(reqcpy.data);
02631
02632 memset(buf, 0, sizeof(buf));
02633
02634 if (tcptls_session->ssl) {
02635 set_socket_transport(&req.socket, SIP_TRANSPORT_TLS);
02636 req.socket.port = htons(ourport_tls);
02637 } else {
02638 set_socket_transport(&req.socket, SIP_TRANSPORT_TCP);
02639 req.socket.port = htons(ourport_tcp);
02640 }
02641 req.socket.fd = tcptls_session->fd;
02642
02643
02644 while (ast_str_strlen(req.data) < 4 || strncmp(REQ_OFFSET_TO_STR(&req, data->used - 4), "\r\n\r\n", 4)) {
02645 if (!tcptls_session->client && !authenticated ) {
02646 if ((timeout = sip_check_authtimeout(start)) < 0) {
02647 goto cleanup;
02648 }
02649
02650 if (timeout == 0) {
02651 ast_debug(2, "SIP %s server timed out\n", tcptls_session->ssl ? "SSL": "TCP");
02652 goto cleanup;
02653 }
02654 } else {
02655 timeout = -1;
02656 }
02657
02658
02659
02660
02661 if (!tcptls_session->ssl || need_poll) {
02662 need_poll = 0;
02663 after_poll = 1;
02664 res = ast_wait_for_input(tcptls_session->fd, timeout);
02665 if (res < 0) {
02666 ast_debug(2, "SIP TCP server :: ast_wait_for_input returned %d\n", res);
02667 goto cleanup;
02668 } else if (res == 0) {
02669
02670 ast_debug(2, "SIP TCP server timed out\n");
02671 goto cleanup;
02672 }
02673 }
02674
02675 ast_mutex_lock(&tcptls_session->lock);
02676 if (!fgets(buf, sizeof(buf), tcptls_session->f)) {
02677 ast_mutex_unlock(&tcptls_session->lock);
02678 if (after_poll) {
02679 goto cleanup;
02680 } else {
02681 need_poll = 1;
02682 continue;
02683 }
02684 }
02685 ast_mutex_unlock(&tcptls_session->lock);
02686 after_poll = 0;
02687 if (me->stop) {
02688 goto cleanup;
02689 }
02690 ast_str_append(&req.data, 0, "%s", buf);
02691 }
02692 copy_request(&reqcpy, &req);
02693 parse_request(&reqcpy);
02694
02695 if (sscanf(get_header(&reqcpy, "Content-Length"), "%30d", &cl)) {
02696 while (cl > 0) {
02697 size_t bytes_read;
02698 if (!tcptls_session->client && !authenticated ) {
02699 if ((timeout = sip_check_authtimeout(start)) < 0) {
02700 goto cleanup;
02701 }
02702
02703 if (timeout == 0) {
02704 ast_debug(2, "SIP %s server timed out\n", tcptls_session->ssl ? "SSL": "TCP");
02705 goto cleanup;
02706 }
02707 } else {
02708 timeout = -1;
02709 }
02710
02711 if (!tcptls_session->ssl || need_poll) {
02712 need_poll = 0;
02713 after_poll = 1;
02714 res = ast_wait_for_input(tcptls_session->fd, timeout);
02715 if (res < 0) {
02716 ast_debug(2, "SIP TCP server :: ast_wait_for_input returned %d\n", res);
02717 goto cleanup;
02718 } else if (res == 0) {
02719
02720 ast_debug(2, "SIP TCP server timed out\n");
02721 goto cleanup;
02722 }
02723 }
02724
02725 ast_mutex_lock(&tcptls_session->lock);
02726 if (!(bytes_read = fread(buf, 1, MIN(sizeof(buf) - 1, cl), tcptls_session->f))) {
02727 ast_mutex_unlock(&tcptls_session->lock);
02728 if (after_poll) {
02729 goto cleanup;
02730 } else {
02731 need_poll = 1;
02732 continue;
02733 }
02734 }
02735 buf[bytes_read] = '\0';
02736 ast_mutex_unlock(&tcptls_session->lock);
02737 after_poll = 0;
02738 if (me->stop) {
02739 goto cleanup;
02740 }
02741 cl -= strlen(buf);
02742 ast_str_append(&req.data, 0, "%s", buf);
02743 }
02744 }
02745
02746
02747
02748 req.socket.tcptls_session = tcptls_session;
02749 handle_request_do(&req, &tcptls_session->remote_address);
02750 }
02751
02752 if (fds[1].revents) {
02753 enum sip_tcptls_alert alert;
02754 struct tcptls_packet *packet;
02755
02756 fds[1].revents = 0;
02757
02758 if (read(me->alert_pipe[0], &alert, sizeof(alert)) == -1) {
02759 ast_log(LOG_ERROR, "read() failed: %s\n", strerror(errno));
02760 continue;
02761 }
02762
02763 switch (alert) {
02764 case TCPTLS_ALERT_STOP:
02765 goto cleanup;
02766 case TCPTLS_ALERT_DATA:
02767 ao2_lock(me);
02768 if (!(packet = AST_LIST_REMOVE_HEAD(&me->packet_q, entry))) {
02769 ast_log(LOG_WARNING, "TCPTLS thread alert_pipe indicated packet should be sent, but frame_q is empty");
02770 }
02771 ao2_unlock(me);
02772
02773 if (packet) {
02774 if (ast_tcptls_server_write(tcptls_session, ast_str_buffer(packet->data), packet->len) == -1) {
02775 ast_log(LOG_WARNING, "Failure to write to tcp/tls socket\n");
02776 }
02777 ao2_t_ref(packet, -1, "tcptls packet sent, this is no longer needed");
02778 }
02779 break;
02780 default:
02781 ast_log(LOG_ERROR, "Unknown tcptls thread alert '%d'\n", alert);
02782 }
02783 }
02784 }
02785
02786 ast_debug(2, "Shutting down thread for %s server\n", tcptls_session->ssl ? "SSL" : "TCP");
02787
02788 cleanup:
02789 if (tcptls_session && !tcptls_session->client && !authenticated) {
02790 ast_atomic_fetchadd_int(&unauth_sessions, -1);
02791 }
02792
02793 if (me) {
02794 ao2_t_unlink(threadt, me, "Removing tcptls helper thread, thread is closing");
02795 ao2_t_ref(me, -1, "Removing tcp_helper_threads threadinfo ref");
02796 }
02797 deinit_req(&reqcpy);
02798 deinit_req(&req);
02799
02800
02801 if (ca) {
02802 ao2_t_ref(ca, -1, "closing tcptls thread, getting rid of client tcptls_session arguments");
02803 }
02804
02805 if (tcptls_session) {
02806 ast_mutex_lock(&tcptls_session->lock);
02807 ast_tcptls_close_session_file(tcptls_session);
02808 tcptls_session->parent = NULL;
02809 ast_mutex_unlock(&tcptls_session->lock);
02810
02811 ao2_ref(tcptls_session, -1);
02812 tcptls_session = NULL;
02813 }
02814 return NULL;
02815 }
02816
02817 #ifdef REF_DEBUG
02818 #define ref_peer(arg1,arg2) _ref_peer((arg1),(arg2), __FILE__, __LINE__, __PRETTY_FUNCTION__)
02819 #define unref_peer(arg1,arg2) _unref_peer((arg1),(arg2), __FILE__, __LINE__, __PRETTY_FUNCTION__)
02820 static struct sip_peer *_ref_peer(struct sip_peer *peer, char *tag, char *file, int line, const char *func)
02821 {
02822 if (peer)
02823 __ao2_ref_debug(peer, 1, tag, file, line, func);
02824 else
02825 ast_log(LOG_ERROR, "Attempt to Ref a null peer pointer\n");
02826 return peer;
02827 }
02828
02829 static struct sip_peer *_unref_peer(struct sip_peer *peer, char *tag, char *file, int line, const char *func)
02830 {
02831 if (peer)
02832 __ao2_ref_debug(peer, -1, tag, file, line, func);
02833 return NULL;
02834 }
02835 #else
02836
02837
02838
02839
02840
02841 static void *unref_peer(struct sip_peer *peer, char *tag)
02842 {
02843 ao2_t_ref(peer, -1, tag);
02844 return NULL;
02845 }
02846
02847 static struct sip_peer *ref_peer(struct sip_peer *peer, char *tag)
02848 {
02849 ao2_t_ref(peer, 1, tag);
02850 return peer;
02851 }
02852 #endif
02853
02854 static void peer_sched_cleanup(struct sip_peer *peer)
02855 {
02856 if (peer->pokeexpire != -1) {
02857 AST_SCHED_DEL_UNREF(sched, peer->pokeexpire,
02858 unref_peer(peer, "removing poke peer ref"));
02859 }
02860 if (peer->expire != -1) {
02861 AST_SCHED_DEL_UNREF(sched, peer->expire,
02862 unref_peer(peer, "remove register expire ref"));
02863 }
02864 }
02865
02866 typedef enum {
02867 SIP_PEERS_MARKED,
02868 SIP_PEERS_ALL,
02869 } peer_unlink_flag_t;
02870
02871
02872
02873 static int match_and_cleanup_peer_sched(void *peerobj, void *arg, int flags)
02874 {
02875 struct sip_peer *peer = peerobj;
02876 peer_unlink_flag_t which = *(peer_unlink_flag_t *)arg;
02877
02878 if (which == SIP_PEERS_ALL || peer->the_mark) {
02879 peer_sched_cleanup(peer);
02880 if (peer->dnsmgr) {
02881 ast_dnsmgr_release(peer->dnsmgr);
02882 peer->dnsmgr = NULL;
02883 unref_peer(peer, "Release peer from dnsmgr");
02884 }
02885 return CMP_MATCH;
02886 }
02887 return 0;
02888 }
02889
02890 static void unlink_peers_from_tables(peer_unlink_flag_t flag)
02891 {
02892 ao2_t_callback(peers, OBJ_NODATA | OBJ_UNLINK | OBJ_MULTIPLE,
02893 match_and_cleanup_peer_sched, &flag, "initiating callback to remove marked peers");
02894 ao2_t_callback(peers_by_ip, OBJ_NODATA | OBJ_UNLINK | OBJ_MULTIPLE,
02895 match_and_cleanup_peer_sched, &flag, "initiating callback to remove marked peers");
02896 }
02897
02898
02899 static void unlink_marked_peers_from_tables(void)
02900 {
02901 unlink_peers_from_tables(SIP_PEERS_MARKED);
02902 }
02903
02904 static void unlink_all_peers_from_tables(void)
02905 {
02906 unlink_peers_from_tables(SIP_PEERS_ALL);
02907 }
02908
02909
02910 static void unlink_peer_from_tables(struct sip_peer *peer)
02911 {
02912 ao2_t_unlink(peers, peer, "ao2_unlink of peer from peers table");
02913 if (!ast_sockaddr_isnull(&peer->addr)) {
02914 ao2_t_unlink(peers_by_ip, peer, "ao2_unlink of peer from peers_by_ip table");
02915 }
02916 }
02917
02918
02919
02920
02921
02922
02923
02924
02925
02926
02927
02928
02929 static void ref_proxy(struct sip_pvt *pvt, struct sip_proxy *proxy)
02930 {
02931 struct sip_proxy *old_obproxy = pvt->outboundproxy;
02932
02933
02934
02935 if (proxy && proxy != &sip_cfg.outboundproxy) {
02936 ao2_ref(proxy, +1);
02937 }
02938 pvt->outboundproxy = proxy;
02939 if (old_obproxy && old_obproxy != &sip_cfg.outboundproxy) {
02940 ao2_ref(old_obproxy, -1);
02941 }
02942 }
02943
02944
02945
02946
02947
02948
02949
02950
02951 void dialog_unlink_all(struct sip_pvt *dialog)
02952 {
02953 struct sip_pkt *cp;
02954 struct ast_channel *owner;
02955
02956 dialog_ref(dialog, "Let's bump the count in the unlink so it doesn't accidentally become dead before we are done");
02957
02958 ao2_t_unlink(dialogs, dialog, "unlinking dialog via ao2_unlink");
02959
02960
02961 owner = sip_pvt_lock_full(dialog);
02962 if (owner) {
02963 ast_debug(1, "Detaching from channel %s\n", owner->name);
02964 owner->tech_pvt = dialog_unref(owner->tech_pvt, "resetting channel dialog ptr in unlink_all");
02965 ast_channel_unlock(owner);
02966 ast_channel_unref(owner);
02967 dialog->owner = NULL;
02968 }
02969 sip_pvt_unlock(dialog);
02970
02971 if (dialog->registry) {
02972 if (dialog->registry->call == dialog) {
02973 dialog->registry->call = dialog_unref(dialog->registry->call, "nulling out the registry's call dialog field in unlink_all");
02974 }
02975 dialog->registry = registry_unref(dialog->registry, "delete dialog->registry");
02976 }
02977 if (dialog->stateid != -1) {
02978 ast_extension_state_del(dialog->stateid, cb_extensionstate);
02979 dialog->stateid = -1;
02980 }
02981
02982 if (dialog->relatedpeer && dialog->relatedpeer->mwipvt == dialog) {
02983 dialog->relatedpeer->mwipvt = dialog_unref(dialog->relatedpeer->mwipvt, "delete ->relatedpeer->mwipvt");
02984 }
02985 if (dialog->relatedpeer && dialog->relatedpeer->call == dialog) {
02986 dialog->relatedpeer->call = dialog_unref(dialog->relatedpeer->call, "unset the relatedpeer->call field in tandem with relatedpeer field itself");
02987 }
02988
02989
02990 while((cp = dialog->packets)) {
02991 dialog->packets = dialog->packets->next;
02992 AST_SCHED_DEL(sched, cp->retransid);
02993 dialog_unref(cp->owner, "remove all current packets in this dialog, and the pointer to the dialog too as part of __sip_destroy");
02994 if (cp->data) {
02995 ast_free(cp->data);
02996 }
02997 ast_free(cp);
02998 }
02999
03000 AST_SCHED_DEL_UNREF(sched, dialog->waitid, dialog_unref(dialog, "when you delete the waitid sched, you should dec the refcount for the stored dialog ptr"));
03001
03002 AST_SCHED_DEL_UNREF(sched, dialog->initid, dialog_unref(dialog, "when you delete the initid sched, you should dec the refcount for the stored dialog ptr"));
03003
03004 if (dialog->autokillid > -1) {
03005 AST_SCHED_DEL_UNREF(sched, dialog->autokillid, dialog_unref(dialog, "when you delete the autokillid sched, you should dec the refcount for the stored dialog ptr"));
03006 }
03007
03008 if (dialog->request_queue_sched_id > -1) {
03009 AST_SCHED_DEL_UNREF(sched, dialog->request_queue_sched_id, dialog_unref(dialog, "when you delete the request_queue_sched_id sched, you should dec the refcount for the stored dialog ptr"));
03010 }
03011
03012 AST_SCHED_DEL_UNREF(sched, dialog->provisional_keepalive_sched_id, dialog_unref(dialog, "when you delete the provisional_keepalive_sched_id, you should dec the refcount for the stored dialog ptr"));
03013
03014 if (dialog->t38id > -1) {
03015 AST_SCHED_DEL_UNREF(sched, dialog->t38id, dialog_unref(dialog, "when you delete the t38id sched, you should dec the refcount for the stored dialog ptr"));
03016 }
03017
03018 if (dialog->stimer) {
03019 stop_session_timer(dialog);
03020 }
03021
03022 dialog_unref(dialog, "Let's unbump the count in the unlink so the poor pvt can disappear if it is time");
03023 }
03024
03025 void *registry_unref(struct sip_registry *reg, char *tag)
03026 {
03027 ast_debug(3, "SIP Registry %s: refcount now %d\n", reg->hostname, reg->refcount - 1);
03028 ASTOBJ_UNREF(reg, sip_registry_destroy);
03029 return NULL;
03030 }
03031
03032
03033 static struct sip_registry *registry_addref(struct sip_registry *reg, char *tag)
03034 {
03035 ast_debug(3, "SIP Registry %s: refcount now %d\n", reg->hostname, reg->refcount + 1);
03036 return ASTOBJ_REF(reg);
03037 }
03038
03039
03040 static struct ast_udptl_protocol sip_udptl = {
03041 type: "SIP",
03042 get_udptl_info: sip_get_udptl_peer,
03043 set_udptl_peer: sip_set_udptl_peer,
03044 };
03045
03046 static void append_history_full(struct sip_pvt *p, const char *fmt, ...)
03047 __attribute__((format(printf, 2, 3)));
03048
03049
03050
03051 static const char *referstatus2str(enum referstatus rstatus)
03052 {
03053 return map_x_s(referstatusstrings, rstatus, "");
03054 }
03055
03056 static inline void pvt_set_needdestroy(struct sip_pvt *pvt, const char *reason)
03057 {
03058 if (pvt->final_destruction_scheduled) {
03059 return;
03060 }
03061 append_history(pvt, "NeedDestroy", "Setting needdestroy because %s", reason);
03062 pvt->needdestroy = 1;
03063 }
03064
03065
03066
03067
03068 static void initialize_initreq(struct sip_pvt *p, struct sip_request *req)
03069 {
03070 if (p->initreq.headers) {
03071 ast_debug(1, "Initializing already initialized SIP dialog %s (presumably reinvite)\n", p->callid);
03072 } else {
03073 ast_debug(1, "Initializing initreq for method %s - callid %s\n", sip_methods[req->method].text, p->callid);
03074 }
03075
03076 copy_request(&p->initreq, req);
03077 parse_request(&p->initreq);
03078 if (req->debug) {
03079 ast_verbose("Initreq: %d headers, %d lines\n", p->initreq.headers, p->initreq.lines);
03080 }
03081 }
03082
03083
03084 static void sip_alreadygone(struct sip_pvt *dialog)
03085 {
03086 ast_debug(3, "Setting SIP_ALREADYGONE on dialog %s\n", dialog->callid);
03087 dialog->alreadygone = 1;
03088 }
03089
03090
03091 static int proxy_update(struct sip_proxy *proxy)
03092 {
03093
03094
03095 if (!ast_sockaddr_parse(&proxy->ip, proxy->name, 0)) {
03096
03097
03098 proxy->ip.ss.ss_family = get_address_family_filter(&bindaddr);
03099 if (ast_get_ip_or_srv(&proxy->ip, proxy->name, sip_cfg.srvlookup ? "_sip._udp" : NULL) < 0) {
03100 ast_log(LOG_WARNING, "Unable to locate host '%s'\n", proxy->name);
03101 return FALSE;
03102 }
03103
03104 }
03105
03106 ast_sockaddr_set_port(&proxy->ip, proxy->port);
03107
03108 proxy->last_dnsupdate = time(NULL);
03109 return TRUE;
03110 }
03111
03112
03113
03114
03115
03116 unsigned int port_str2int(const char *pt, unsigned int standard)
03117 {
03118 int port = standard;
03119 if (ast_strlen_zero(pt) || (sscanf(pt, "%30d", &port) != 1) || (port < 1) || (port > 65535)) {
03120 port = standard;
03121 }
03122
03123 return port;
03124 }
03125
03126
03127 static struct sip_proxy *obproxy_get(struct sip_pvt *dialog, struct sip_peer *peer)
03128 {
03129 if (peer && peer->outboundproxy) {
03130 if (sipdebug) {
03131 ast_debug(1, "OBPROXY: Applying peer OBproxy to this call\n");
03132 }
03133 append_history(dialog, "OBproxy", "Using peer obproxy %s", peer->outboundproxy->name);
03134 return peer->outboundproxy;
03135 }
03136 if (sip_cfg.outboundproxy.name[0]) {
03137 if (sipdebug) {
03138 ast_debug(1, "OBPROXY: Applying global OBproxy to this call\n");
03139 }
03140 append_history(dialog, "OBproxy", "Using global obproxy %s", sip_cfg.outboundproxy.name);
03141 return &sip_cfg.outboundproxy;
03142 }
03143 if (sipdebug) {
03144 ast_debug(1, "OBPROXY: Not applying OBproxy to this call\n");
03145 }
03146 return NULL;
03147 }
03148
03149
03150
03151
03152
03153
03154
03155 static int method_match(enum sipmethod id, const char *name)
03156 {
03157 int len = strlen(sip_methods[id].text);
03158 int l_name = name ? strlen(name) : 0;
03159
03160 return (l_name >= len && name[len] < 33 &&
03161 !strncasecmp(sip_methods[id].text, name, len));
03162 }
03163
03164
03165 static int find_sip_method(const char *msg)
03166 {
03167 int i, res = 0;
03168
03169 if (ast_strlen_zero(msg)) {
03170 return 0;
03171 }
03172 for (i = 1; i < ARRAY_LEN(sip_methods) && !res; i++) {
03173 if (method_match(i, msg)) {
03174 res = sip_methods[i].id;
03175 }
03176 }
03177 return res;
03178 }
03179
03180
03181 static inline int sip_debug_test_addr(const struct ast_sockaddr *addr)
03182 {
03183
03184 if (!sipdebug) {
03185 return 0;
03186 }
03187
03188
03189 if (ast_sockaddr_isnull(&debugaddr)) {
03190 return 1;
03191 }
03192
03193
03194
03195
03196 if (ast_sockaddr_port(&debugaddr)) {
03197 return !ast_sockaddr_cmp(&debugaddr, addr);
03198 } else {
03199 return !ast_sockaddr_cmp_addr(&debugaddr, addr);
03200 }
03201 }
03202
03203
03204 static const struct ast_sockaddr *sip_real_dst(const struct sip_pvt *p)
03205 {
03206 if (p->outboundproxy) {
03207 return &p->outboundproxy->ip;
03208 }
03209
03210 return ast_test_flag(&p->flags[0], SIP_NAT_FORCE_RPORT) || ast_test_flag(&p->flags[0], SIP_NAT_RPORT_PRESENT) ? &p->recv : &p->sa;
03211 }
03212
03213
03214 static const char *sip_nat_mode(const struct sip_pvt *p)
03215 {
03216 return ast_test_flag(&p->flags[0], SIP_NAT_FORCE_RPORT) ? "NAT" : "no NAT";
03217 }
03218
03219
03220 static inline int sip_debug_test_pvt(struct sip_pvt *p)
03221 {
03222 if (!sipdebug) {
03223 return 0;
03224 }
03225 return sip_debug_test_addr(sip_real_dst(p));
03226 }
03227
03228
03229 static int get_transport_str2enum(const char *transport)
03230 {
03231 int res = 0;
03232
03233 if (ast_strlen_zero(transport)) {
03234 return res;
03235 }
03236
03237 if (!strcasecmp(transport, "udp")) {
03238 res |= SIP_TRANSPORT_UDP;
03239 }
03240 if (!strcasecmp(transport, "tcp")) {
03241 res |= SIP_TRANSPORT_TCP;
03242 }
03243 if (!strcasecmp(transport, "tls")) {
03244 res |= SIP_TRANSPORT_TLS;
03245 }
03246
03247 return res;
03248 }
03249
03250
03251 static inline const char *get_transport_list(unsigned int transports) {
03252 switch (transports) {
03253 case SIP_TRANSPORT_UDP:
03254 return "UDP";
03255 case SIP_TRANSPORT_TCP:
03256 return "TCP";
03257 case SIP_TRANSPORT_TLS:
03258 return "TLS";
03259 case SIP_TRANSPORT_UDP | SIP_TRANSPORT_TCP:
03260 return "TCP,UDP";
03261 case SIP_TRANSPORT_UDP | SIP_TRANSPORT_TLS:
03262 return "TLS,UDP";
03263 case SIP_TRANSPORT_TCP | SIP_TRANSPORT_TLS:
03264 return "TLS,TCP";
03265 default:
03266 return transports ?
03267 "TLS,TCP,UDP" : "UNKNOWN";
03268 }
03269 }
03270
03271
03272 static inline const char *get_transport(enum sip_transport t)
03273 {
03274 switch (t) {
03275 case SIP_TRANSPORT_UDP:
03276 return "UDP";
03277 case SIP_TRANSPORT_TCP:
03278 return "TCP";
03279 case SIP_TRANSPORT_TLS:
03280 return "TLS";
03281 }
03282
03283 return "UNKNOWN";
03284 }
03285
03286
03287 static inline const char *get_srv_protocol(enum sip_transport t)
03288 {
03289 switch (t) {
03290 case SIP_TRANSPORT_UDP:
03291 return "udp";
03292 case SIP_TRANSPORT_TLS:
03293 case SIP_TRANSPORT_TCP:
03294 return "tcp";
03295 }
03296
03297 return "udp";
03298 }
03299
03300
03301 static inline const char *get_srv_service(enum sip_transport t)
03302 {
03303 switch (t) {
03304 case SIP_TRANSPORT_TCP:
03305 case SIP_TRANSPORT_UDP:
03306 return "sip";
03307 case SIP_TRANSPORT_TLS:
03308 return "sips";
03309 }
03310 return "sip";
03311 }
03312
03313
03314
03315
03316
03317
03318
03319 static inline const char *get_transport_pvt(struct sip_pvt *p)
03320 {
03321 if (p->outboundproxy && p->outboundproxy->transport) {
03322 set_socket_transport(&p->socket, p->outboundproxy->transport);
03323 }
03324
03325 return get_transport(p->socket.type);
03326 }
03327
03328
03329
03330
03331
03332
03333
03334
03335
03336
03337
03338
03339 static int __sip_xmit(struct sip_pvt *p, struct ast_str *data)
03340 {
03341 int res = 0;
03342 const struct ast_sockaddr *dst = sip_real_dst(p);
03343
03344 ast_debug(2, "Trying to put '%.11s' onto %s socket destined for %s\n", data->str, get_transport_pvt(p), ast_sockaddr_stringify(dst));
03345
03346 if (sip_prepare_socket(p) < 0) {
03347 return XMIT_ERROR;
03348 }
03349
03350 if (p->socket.type == SIP_TRANSPORT_UDP) {
03351 res = ast_sendto(p->socket.fd, data->str, ast_str_strlen(data), 0, dst);
03352 } else if (p->socket.tcptls_session) {
03353 res = sip_tcptls_write(p->socket.tcptls_session, data->str, ast_str_strlen(data));
03354 } else {
03355 ast_debug(2, "Socket type is TCP but no tcptls_session is present to write to\n");
03356 return XMIT_ERROR;
03357 }
03358
03359 if (res == -1) {
03360 switch (errno) {
03361 case EBADF:
03362 case EHOSTUNREACH:
03363 case ENETDOWN:
03364 case ENETUNREACH:
03365 case ECONNREFUSED:
03366 res = XMIT_ERROR;
03367 }
03368 }
03369 if (res != ast_str_strlen(data)) {
03370 ast_log(LOG_WARNING, "sip_xmit of %p (len %zu) to %s returned %d: %s\n", data, ast_str_strlen(data), ast_sockaddr_stringify(dst), res, strerror(errno));
03371 }
03372
03373 return res;
03374 }
03375
03376
03377 static void build_via(struct sip_pvt *p)
03378 {
03379
03380 const char *rport = (ast_test_flag(&p->flags[0], SIP_NAT_FORCE_RPORT) || ast_test_flag(&p->flags[0], SIP_NAT_RPORT_PRESENT)) ? ";rport" : "";
03381
03382
03383 snprintf(p->via, sizeof(p->via), "SIP/2.0/%s %s;branch=z9hG4bK%08x%s",
03384 get_transport_pvt(p),
03385 ast_sockaddr_stringify_remote(&p->ourip),
03386 (int) p->branch, rport);
03387 }
03388
03389
03390
03391
03392
03393
03394
03395
03396 static void ast_sip_ouraddrfor(const struct ast_sockaddr *them, struct ast_sockaddr *us, struct sip_pvt *p)
03397 {
03398 struct ast_sockaddr theirs;
03399
03400
03401
03402
03403
03404
03405
03406
03407
03408
03409
03410
03411
03412 int want_remap = 0;
03413
03414 ast_sockaddr_copy(us, &internip);
03415
03416 ast_ouraddrfor(them, us);
03417 ast_sockaddr_copy(&theirs, them);
03418
03419 if (ast_sockaddr_is_ipv6(&theirs)) {
03420 if (localaddr && !ast_sockaddr_isnull(&externaddr)) {
03421 ast_log(LOG_WARNING, "Address remapping activated in sip.conf "
03422 "but we're using IPv6, which doesn't need it. Please "
03423 "remove \"localnet\" and/or \"externaddr\" settings.\n");
03424 }
03425 } else {
03426 want_remap = localaddr &&
03427 !ast_sockaddr_isnull(&externaddr) &&
03428 ast_apply_ha(localaddr, &theirs) == AST_SENSE_ALLOW ;
03429 }
03430
03431 if (want_remap &&
03432 (!sip_cfg.matchexternaddrlocally || !ast_apply_ha(localaddr, us)) ) {
03433
03434 if (externexpire && time(NULL) >= externexpire) {
03435 if (ast_sockaddr_resolve_first(&externaddr, externhost, 0)) {
03436 ast_log(LOG_NOTICE, "Warning: Re-lookup of '%s' failed!\n", externhost);
03437 }
03438 externexpire = time(NULL) + externrefresh;
03439 }
03440 if (!ast_sockaddr_isnull(&externaddr)) {
03441 ast_sockaddr_copy(us, &externaddr);
03442 switch (p->socket.type) {
03443 case SIP_TRANSPORT_TCP:
03444 if (!externtcpport && ast_sockaddr_port(&externaddr)) {
03445
03446 externtcpport = ast_sockaddr_port(&externaddr);
03447 }
03448 ast_sockaddr_set_port(us, externtcpport);
03449 break;
03450 case SIP_TRANSPORT_TLS:
03451 ast_sockaddr_set_port(us, externtlsport);
03452 break;
03453 case SIP_TRANSPORT_UDP:
03454 if (!ast_sockaddr_port(&externaddr)) {
03455 ast_sockaddr_set_port(us, ast_sockaddr_port(&bindaddr));
03456 }
03457 break;
03458 default:
03459 break;
03460 }
03461 }
03462 ast_debug(1, "Target address %s is not local, substituting externaddr\n",
03463 ast_sockaddr_stringify(them));
03464 } else if (p) {
03465
03466 switch (p->socket.type) {
03467 case SIP_TRANSPORT_TCP:
03468 if (!ast_sockaddr_is_any(&sip_tcp_desc.local_address)) {
03469 ast_sockaddr_copy(us,
03470 &sip_tcp_desc.local_address);
03471 } else {
03472 ast_sockaddr_set_port(us,
03473 ast_sockaddr_port(&sip_tcp_desc.local_address));
03474 }
03475 break;
03476 case SIP_TRANSPORT_TLS:
03477 if (!ast_sockaddr_is_any(&sip_tls_desc.local_address)) {
03478 ast_sockaddr_copy(us,
03479 &sip_tls_desc.local_address);
03480 } else {
03481 ast_sockaddr_set_port(us,
03482 ast_sockaddr_port(&sip_tls_desc.local_address));
03483 }
03484 break;
03485 case SIP_TRANSPORT_UDP:
03486
03487 default:
03488 if (!ast_sockaddr_is_any(&bindaddr)) {
03489 ast_sockaddr_copy(us, &bindaddr);
03490 }
03491 if (!ast_sockaddr_port(us)) {
03492 ast_sockaddr_set_port(us, ast_sockaddr_port(&bindaddr));
03493 }
03494 }
03495 } else if (!ast_sockaddr_is_any(&bindaddr)) {
03496 ast_sockaddr_copy(us, &bindaddr);
03497 }
03498 ast_debug(3, "Setting SIP_TRANSPORT_%s with address %s\n", get_transport(p->socket.type), ast_sockaddr_stringify(us));
03499 }
03500
03501
03502 static __attribute__((format(printf, 2, 0))) void append_history_va(struct sip_pvt *p, const char *fmt, va_list ap)
03503 {
03504 char buf[80], *c = buf;
03505 struct sip_history *hist;
03506 int l;
03507
03508 vsnprintf(buf, sizeof(buf), fmt, ap);
03509 strsep(&c, "\r\n");
03510 l = strlen(buf) + 1;
03511 if (!(hist = ast_calloc(1, sizeof(*hist) + l))) {
03512 return;
03513 }
03514 if (!p->history && !(p->history = ast_calloc(1, sizeof(*p->history)))) {
03515 ast_free(hist);
03516 return;
03517 }
03518 memcpy(hist->event, buf, l);
03519 if (p->history_entries == MAX_HISTORY_ENTRIES) {
03520 struct sip_history *oldest;
03521 oldest = AST_LIST_REMOVE_HEAD(p->history, list);
03522 p->history_entries--;
03523 ast_free(oldest);
03524 }
03525 AST_LIST_INSERT_TAIL(p->history, hist, list);
03526 p->history_entries++;
03527 }
03528
03529
03530 static void append_history_full(struct sip_pvt *p, const char *fmt, ...)
03531 {
03532 va_list ap;
03533
03534 if (!p) {
03535 return;
03536 }
03537
03538 if (!p->do_history && !recordhistory && !dumphistory) {
03539 return;
03540 }
03541
03542 va_start(ap, fmt);
03543 append_history_va(p, fmt, ap);
03544 va_end(ap);
03545
03546 return;
03547 }
03548
03549
03550 static int retrans_pkt(const void *data)
03551 {
03552 struct sip_pkt *pkt = (struct sip_pkt *)data, *prev, *cur = NULL;
03553 int reschedule = DEFAULT_RETRANS;
03554 int xmitres = 0;
03555
03556 int64_t diff = pkt->retrans_stop_time - ast_tvdiff_ms(ast_tvnow(), pkt->time_sent);
03557
03558
03559
03560
03561 if ((diff <= 0) || (diff > pkt->retrans_stop_time)) {
03562 pkt->retrans_stop = 1;
03563 }
03564
03565
03566 sip_pvt_lock(pkt->owner);
03567
03568 if (!pkt->retrans_stop) {
03569 pkt->retrans++;
03570 if (!pkt->timer_t1) {
03571 if (sipdebug) {
03572 ast_debug(4, "SIP TIMER: Not rescheduling id #%d:%s (Method %d) (No timer T1)\n",
03573 pkt->retransid,
03574 sip_methods[pkt->method].text,
03575 pkt->method);
03576 }
03577 } else {
03578 int siptimer_a;
03579
03580 if (sipdebug) {
03581 ast_debug(4, "SIP TIMER: Rescheduling retransmission #%d (%d) %s - %d\n",
03582 pkt->retransid,
03583 pkt->retrans,
03584 sip_methods[pkt->method].text,
03585 pkt->method);
03586 }
03587 if (!pkt->timer_a) {
03588 pkt->timer_a = 2 ;
03589 } else {
03590 pkt->timer_a = 2 * pkt->timer_a;
03591 }
03592
03593
03594 siptimer_a = pkt->timer_t1 * pkt->timer_a;
03595 if (pkt->method != SIP_INVITE && siptimer_a > 4000) {
03596 siptimer_a = 4000;
03597 }
03598
03599
03600 reschedule = siptimer_a;
03601 ast_debug(4, "** SIP timers: Rescheduling retransmission %d to %d ms (t1 %d ms (Retrans id #%d)) \n",
03602 pkt->retrans + 1,
03603 siptimer_a,
03604 pkt->timer_t1,
03605 pkt->retransid);
03606 }
03607
03608 if (sip_debug_test_pvt(pkt->owner)) {
03609 const struct ast_sockaddr *dst = sip_real_dst(pkt->owner);
03610 ast_verbose("Retransmitting #%d (%s) to %s:\n%s\n---\n",
03611 pkt->retrans, sip_nat_mode(pkt->owner),
03612 ast_sockaddr_stringify(dst),
03613 pkt->data->str);
03614 }
03615
03616 append_history(pkt->owner, "ReTx", "%d %s", reschedule, pkt->data->str);
03617 xmitres = __sip_xmit(pkt->owner, pkt->data);
03618
03619
03620
03621
03622
03623
03624 if (xmitres != XMIT_ERROR) {
03625 if (reschedule >= diff) {
03626 pkt->retrans_stop = 1;
03627 reschedule = diff;
03628 }
03629 sip_pvt_unlock(pkt->owner);
03630 return reschedule;
03631 }
03632 }
03633
03634
03635
03636
03637 pkt->retransid = -1;
03638
03639 if (pkt->owner && pkt->method != SIP_OPTIONS && xmitres == 0) {
03640 if (pkt->is_fatal || sipdebug) {
03641 ast_log(LOG_WARNING, "Retransmission timeout reached on transmission %s for seqno %d (%s %s) -- See https://wiki.asterisk.org/wiki/display/AST/SIP+Retransmissions\n"
03642 "Packet timed out after %dms with no response\n",
03643 pkt->owner->callid,
03644 pkt->seqno,
03645 pkt->is_fatal ? "Critical" : "Non-critical",
03646 pkt->is_resp ? "Response" : "Request",
03647 (int) ast_tvdiff_ms(ast_tvnow(), pkt->time_sent));
03648 }
03649 } else if (pkt->method == SIP_OPTIONS && sipdebug) {
03650 ast_log(LOG_WARNING, "Cancelling retransmit of OPTIONs (call id %s) -- See https://wiki.asterisk.org/wiki/display/AST/SIP+Retransmissions\n", pkt->owner->callid);
03651 }
03652
03653 if (xmitres == XMIT_ERROR) {
03654 ast_log(LOG_WARNING, "Transmit error :: Cancelling transmission on Call ID %s\n", pkt->owner->callid);
03655 append_history(pkt->owner, "XmitErr", "%s", pkt->is_fatal ? "(Critical)" : "(Non-critical)");
03656 } else {
03657 append_history(pkt->owner, "MaxRetries", "%s", pkt->is_fatal ? "(Critical)" : "(Non-critical)");
03658 }
03659
03660 if (pkt->is_fatal) {
03661 while(pkt->owner->owner && ast_channel_trylock(pkt->owner->owner)) {
03662 sip_pvt_unlock(pkt->owner);
03663 usleep(1);
03664 sip_pvt_lock(pkt->owner);
03665 }
03666 if (pkt->owner->owner && !pkt->owner->owner->hangupcause) {
03667 pkt->owner->owner->hangupcause = AST_CAUSE_NO_USER_RESPONSE;
03668 }
03669 if (pkt->owner->owner) {
03670 ast_log(LOG_WARNING, "Hanging up call %s - no reply to our critical packet (see https://wiki.asterisk.org/wiki/display/AST/SIP+Retransmissions).\n", pkt->owner->callid);
03671
03672 if (pkt->is_resp &&
03673 (pkt->response_code >= 200) &&
03674 (pkt->response_code < 300) &&
03675 pkt->owner->pendinginvite &&
03676 ast_test_flag(&pkt->owner->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED)) {
03677
03678
03679
03680
03681
03682
03683
03684 pkt->owner->invitestate = INV_TERMINATED;
03685 pkt->owner->pendinginvite = 0;
03686 } else {
03687
03688 sip_alreadygone(pkt->owner);
03689 }
03690 ast_queue_hangup_with_cause(pkt->owner->owner, AST_CAUSE_PROTOCOL_ERROR);
03691 ast_channel_unlock(pkt->owner->owner);
03692 } else {
03693
03694
03695
03696 if (pkt->method != SIP_OPTIONS && pkt->method != SIP_REGISTER) {
03697 pvt_set_needdestroy(pkt->owner, "no response to critical packet");
03698 sip_alreadygone(pkt->owner);
03699 append_history(pkt->owner, "DialogKill", "Killing this failed dialog immediately");
03700 }
03701 }
03702 }
03703
03704 if (pkt->method == SIP_BYE) {
03705
03706 sip_alreadygone(pkt->owner);
03707 if (pkt->owner->owner) {
03708 ast_channel_unlock(pkt->owner->owner);
03709 }
03710 append_history(pkt->owner, "ByeFailure", "Remote peer doesn't respond to bye. Destroying call anyway.");
03711 pvt_set_needdestroy(pkt->owner, "no response to BYE");
03712 }
03713
03714
03715 for (prev = NULL, cur = pkt->owner->packets; cur; prev = cur, cur = cur->next) {
03716 if (cur == pkt) {
03717 UNLINK(cur, pkt->owner->packets, prev);
03718 sip_pvt_unlock(pkt->owner);
03719 if (pkt->owner) {
03720 pkt->owner = dialog_unref(pkt->owner,"pkt is being freed, its dialog ref is dead now");
03721 }
03722 if (pkt->data) {
03723 ast_free(pkt->data);
03724 }
03725 pkt->data = NULL;
03726 ast_free(pkt);
03727 return 0;
03728 }
03729 }
03730
03731 ast_log(LOG_WARNING, "Weird, couldn't find packet owner!\n");
03732 sip_pvt_unlock(pkt->owner);
03733 return 0;
03734 }
03735
03736
03737
03738
03739
03740
03741 static enum sip_result __sip_reliable_xmit(struct sip_pvt *p, int seqno, int resp, struct ast_str *data, int fatal, int sipmethod)
03742 {
03743 struct sip_pkt *pkt = NULL;
03744 int siptimer_a = DEFAULT_RETRANS;
03745 int xmitres = 0;
03746 int respid;
03747
03748 if (sipmethod == SIP_INVITE) {
03749
03750 p->pendinginvite = seqno;
03751 }
03752
03753
03754
03755
03756 if (!(p->socket.type & SIP_TRANSPORT_UDP)) {
03757 xmitres = __sip_xmit(p, data);
03758 if (xmitres == XMIT_ERROR) {
03759 append_history(p, "XmitErr", "%s", fatal ? "(Critical)" : "(Non-critical)");
03760 return AST_FAILURE;
03761 } else {
03762 return AST_SUCCESS;
03763 }
03764 }
03765
03766 if (!(pkt = ast_calloc(1, sizeof(*pkt)))) {
03767 return AST_FAILURE;
03768 }
03769
03770 if (!(pkt->data = ast_str_create(ast_str_strlen(data)))) {
03771 ast_free(pkt);
03772 return AST_FAILURE;
03773 }
03774 ast_str_set(&pkt->data, 0, "%s%s", data->str, "\0");
03775
03776 pkt->method = sipmethod;
03777 pkt->seqno = seqno;
03778 pkt->is_resp = resp;
03779 pkt->is_fatal = fatal;
03780 pkt->owner = dialog_ref(p, "__sip_reliable_xmit: setting pkt->owner");
03781 pkt->next = p->packets;
03782 p->packets = pkt;
03783 if (resp) {
03784
03785 if (sscanf(ast_str_buffer(pkt->data), "SIP/2.0 %30u", &respid) == 1) {
03786 pkt->response_code = respid;
03787 }
03788 }
03789 pkt->timer_t1 = p->timer_t1;
03790 pkt->retransid = -1;
03791 if (pkt->timer_t1) {
03792 siptimer_a = pkt->timer_t1;
03793 }
03794
03795 pkt->time_sent = ast_tvnow();
03796 pkt->retrans_stop_time = 64 * (pkt->timer_t1 ? pkt->timer_t1 : DEFAULT_TIMER_T1);
03797
03798
03799 AST_SCHED_REPLACE_VARIABLE(pkt->retransid, sched, siptimer_a, retrans_pkt, pkt, 1);
03800 if (sipdebug) {
03801 ast_debug(4, "*** SIP TIMER: Initializing retransmit timer on packet: Id #%d\n", pkt->retransid);
03802 }
03803
03804 xmitres = __sip_xmit(pkt->owner, pkt->data);
03805
03806 if (xmitres == XMIT_ERROR) {
03807 append_history(pkt->owner, "XmitErr", "%s", pkt->is_fatal ? "(Critical)" : "(Non-critical)");
03808 ast_log(LOG_ERROR, "Serious Network Trouble; __sip_xmit returns error for pkt data\n");
03809 AST_SCHED_DEL(sched, pkt->retransid);
03810 p->packets = pkt->next;
03811 pkt->owner = dialog_unref(pkt->owner,"pkt is being freed, its dialog ref is dead now");
03812 ast_free(pkt->data);
03813 ast_free(pkt);
03814 return AST_FAILURE;
03815 } else {
03816
03817
03818
03819
03820 if (monitor_thread != AST_PTHREADT_NULL) {
03821 pthread_kill(monitor_thread, SIGURG);
03822 }
03823 return AST_SUCCESS;
03824 }
03825 }
03826
03827
03828
03829
03830
03831
03832 static int __sip_autodestruct(const void *data)
03833 {
03834 struct sip_pvt *p = (struct sip_pvt *)data;
03835 struct ast_channel *owner;
03836
03837
03838 if (p->subscribed && p->subscribed != MWI_NOTIFICATION && p->subscribed != CALL_COMPLETION) {
03839 transmit_state_notify(p, AST_EXTENSION_DEACTIVATED, 1, TRUE);
03840 p->subscribed = NONE;
03841 append_history(p, "Subscribestatus", "timeout");
03842 ast_debug(3, "Re-scheduled destruction of SIP subscription %s\n", p->callid ? p->callid : "<unknown>");
03843 return 10000;
03844 }
03845
03846
03847 if (p->packets) {
03848 if (!p->needdestroy) {
03849 char method_str[31];
03850 ast_debug(3, "Re-scheduled destruction of SIP call %s\n", p->callid ? p->callid : "<unknown>");
03851 append_history(p, "ReliableXmit", "timeout");
03852 if (sscanf(p->lastmsg, "Tx: %30s", method_str) == 1 || sscanf(p->lastmsg, "Rx: %30s", method_str) == 1) {
03853 if (method_match(SIP_CANCEL, method_str) || method_match(SIP_BYE, method_str)) {
03854 pvt_set_needdestroy(p, "autodestruct");
03855 }
03856 }
03857 return 10000;
03858 } else {
03859
03860 __sip_pretend_ack(p);
03861 }
03862 }
03863
03864
03865 p->autokillid = -1;
03866
03867
03868
03869
03870
03871 owner = sip_pvt_lock_full(p);
03872 if (owner) {
03873 ast_log(LOG_WARNING, "Autodestruct on dialog '%s' with owner in place (Method: %s)\n", p->callid, sip_methods[p->method].text);
03874 ast_queue_hangup_with_cause(owner, AST_CAUSE_PROTOCOL_ERROR);
03875 ast_channel_unlock(owner);
03876 ast_channel_unref(owner);
03877 } else if (p->refer && !p->alreadygone) {
03878 ast_debug(3, "Finally hanging up channel after transfer: %s\n", p->callid);
03879 stop_media_flows(p);
03880 transmit_request_with_auth(p, SIP_BYE, 0, XMIT_RELIABLE, 1);
03881 append_history(p, "ReferBYE", "Sending BYE on transferer call leg %s", p->callid);
03882 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
03883 } else {
03884 append_history(p, "AutoDestroy", "%s", p->callid);
03885 ast_debug(3, "Auto destroying SIP dialog '%s'\n", p->callid);
03886 sip_pvt_unlock(p);
03887 dialog_unlink_all(p);
03888 sip_pvt_lock(p);
03889
03890
03891
03892 }
03893
03894 sip_pvt_unlock(p);
03895
03896 dialog_unref(p, "The ref to a dialog passed to this sched callback is going out of scope; unref it.");
03897
03898 return 0;
03899 }
03900
03901
03902
03903
03904 void sip_scheddestroy_final(struct sip_pvt *p, int ms)
03905 {
03906 if (p->final_destruction_scheduled) {
03907 return;
03908 }
03909
03910 sip_scheddestroy(p, ms);
03911 if (p->autokillid != -1) {
03912 p->final_destruction_scheduled = 1;
03913 }
03914 }
03915
03916
03917 void sip_scheddestroy(struct sip_pvt *p, int ms)
03918 {
03919 if (p->final_destruction_scheduled) {
03920 return;
03921 }
03922
03923 if (ms < 0) {
03924 if (p->timer_t1 == 0) {
03925 p->timer_t1 = global_t1;
03926 }
03927 if (p->timer_b == 0) {
03928 p->timer_b = global_timer_b;
03929 }
03930 ms = p->timer_t1 * 64;
03931 }
03932 if (sip_debug_test_pvt(p)) {
03933 ast_verbose("Scheduling destruction of SIP dialog '%s' in %d ms (Method: %s)\n", p->callid, ms, sip_methods[p->method].text);
03934 }
03935 if (sip_cancel_destroy(p)) {
03936 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
03937 }
03938
03939 if (p->do_history) {
03940 append_history(p, "SchedDestroy", "%d ms", ms);
03941 }
03942 p->autokillid = ast_sched_add(sched, ms, __sip_autodestruct, dialog_ref(p, "setting ref as passing into ast_sched_add for __sip_autodestruct"));
03943
03944 if (p->stimer && p->stimer->st_active == TRUE && p->stimer->st_schedid > 0) {
03945 stop_session_timer(p);
03946 }
03947 }
03948
03949
03950
03951
03952
03953 int sip_cancel_destroy(struct sip_pvt *p)
03954 {
03955 if (p->final_destruction_scheduled) {
03956 return 0;
03957 }
03958
03959 if (p->autokillid > -1) {
03960 append_history(p, "CancelDestroy", "");
03961 AST_SCHED_DEL_UNREF(sched, p->autokillid, dialog_unref(p, "remove ref for autokillid"));
03962 }
03963 return 0;
03964 }
03965
03966
03967
03968 int __sip_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
03969 {
03970 struct sip_pkt *cur, *prev = NULL;
03971 const char *msg = "Not Found";
03972 int res = FALSE;
03973
03974
03975
03976
03977
03978
03979 if (p->outboundproxy && !p->outboundproxy->force){
03980 ref_proxy(p, NULL);
03981 }
03982
03983 for (cur = p->packets; cur; prev = cur, cur = cur->next) {
03984 if (cur->seqno != seqno || cur->is_resp != resp) {
03985 continue;
03986 }
03987 if (cur->is_resp || cur->method == sipmethod) {
03988 res = TRUE;
03989 msg = "Found";
03990 if (!resp && (seqno == p->pendinginvite)) {
03991 ast_debug(1, "Acked pending invite %d\n", p->pendinginvite);
03992 p->pendinginvite = 0;
03993 }
03994 if (cur->retransid > -1) {
03995 if (sipdebug)
03996 ast_debug(4, "** SIP TIMER: Cancelling retransmit of packet (reply received) Retransid #%d\n", cur->retransid);
03997 }
03998
03999
04000
04001
04002
04003
04004
04005
04006
04007
04008
04009
04010
04011
04012
04013
04014 while (cur->retransid > -1 && ast_sched_del(sched, cur->retransid)) {
04015 sip_pvt_unlock(p);
04016 usleep(1);
04017 sip_pvt_lock(p);
04018 }
04019 UNLINK(cur, p->packets, prev);
04020 dialog_unref(cur->owner, "unref pkt cur->owner dialog from sip ack before freeing pkt");
04021 if (cur->data) {
04022 ast_free(cur->data);
04023 }
04024 ast_free(cur);
04025 break;
04026 }
04027 }
04028 ast_debug(1, "Stopping retransmission on '%s' of %s %d: Match %s\n",
04029 p->callid, resp ? "Response" : "Request", seqno, msg);
04030 return res;
04031 }
04032
04033
04034
04035 void __sip_pretend_ack(struct sip_pvt *p)
04036 {
04037 struct sip_pkt *cur = NULL;
04038
04039 while (p->packets) {
04040 int method;
04041 if (cur == p->packets) {
04042 ast_log(LOG_WARNING, "Have a packet that doesn't want to give up! %s\n", sip_methods[cur->method].text);
04043 return;
04044 }
04045 cur = p->packets;
04046 method = (cur->method) ? cur->method : find_sip_method(cur->data->str);
04047 __sip_ack(p, cur->seqno, cur->is_resp, method);
04048 }
04049 }
04050
04051
04052 int __sip_semi_ack(struct sip_pvt *p, int seqno, int resp, int sipmethod)
04053 {
04054 struct sip_pkt *cur;
04055 int res = FALSE;
04056
04057 for (cur = p->packets; cur; cur = cur->next) {
04058 if (cur->seqno == seqno && cur->is_resp == resp &&
04059 (cur->is_resp || method_match(sipmethod, cur->data->str))) {
04060
04061 if (cur->retransid > -1) {
04062 if (sipdebug)
04063 ast_debug(4, "*** SIP TIMER: Cancelling retransmission #%d - %s (got response)\n", cur->retransid, sip_methods[sipmethod].text);
04064 }
04065 AST_SCHED_DEL(sched, cur->retransid);
04066 res = TRUE;
04067 break;
04068 }
04069 }
04070 ast_debug(1, "(Provisional) Stopping retransmission (but retaining packet) on '%s' %s %d: %s\n", p->callid, resp ? "Response" : "Request", seqno, res == -1 ? "Not Found" : "Found");
04071 return res;
04072 }
04073
04074
04075
04076 static void parse_copy(struct sip_request *dst, const struct sip_request *src)
04077 {
04078 copy_request(dst, src);
04079 parse_request(dst);
04080 }
04081
04082
04083 static void add_blank(struct sip_request *req)
04084 {
04085 if (!req->lines) {
04086
04087 ast_str_append(&req->data, 0, "\r\n");
04088 }
04089 }
04090
04091 static int send_provisional_keepalive_full(struct sip_pvt *pvt, int with_sdp)
04092 {
04093 const char *msg = NULL;
04094 struct ast_channel *chan;
04095 int res = 0;
04096
04097 chan = sip_pvt_lock_full(pvt);
04098
04099 if (!pvt->last_provisional || !strncasecmp(pvt->last_provisional, "100", 3)) {
04100 msg = "183 Session Progress";
04101 }
04102
04103 if (pvt->invitestate < INV_COMPLETED) {
04104 if (with_sdp) {
04105 transmit_response_with_sdp(pvt, S_OR(msg, pvt->last_provisional), &pvt->initreq, XMIT_UNRELIABLE, FALSE, FALSE);
04106 } else {
04107 transmit_response(pvt, S_OR(msg, pvt->last_provisional), &pvt->initreq);
04108 }
04109 res = PROVIS_KEEPALIVE_TIMEOUT;
04110 }
04111
04112 if (chan) {
04113 ast_channel_unlock(chan);
04114 chan = ast_channel_unref(chan);
04115 }
04116
04117 if (!res) {
04118 pvt->provisional_keepalive_sched_id = -1;
04119 }
04120
04121 sip_pvt_unlock(pvt);
04122
04123 #if 0
04124
04125
04126
04127
04128
04129
04130
04131
04132 if (!res) {
04133 dialog_unref(pvt, "dialog ref for provisional keepalive");
04134 }
04135 #endif
04136
04137 return res;
04138 }
04139
04140 static int send_provisional_keepalive(const void *data) {
04141 struct sip_pvt *pvt = (struct sip_pvt *) data;
04142
04143 return send_provisional_keepalive_full(pvt, 0);
04144 }
04145
04146 static int send_provisional_keepalive_with_sdp(const void *data) {
04147 struct sip_pvt *pvt = (void *)data;
04148
04149 return send_provisional_keepalive_full(pvt, 1);
04150 }
04151
04152 static void update_provisional_keepalive(struct sip_pvt *pvt, int with_sdp)
04153 {
04154 AST_SCHED_DEL_UNREF(sched, pvt->provisional_keepalive_sched_id, dialog_unref(pvt, "when you delete the provisional_keepalive_sched_id, you should dec the refcount for the stored dialog ptr"));
04155
04156 pvt->provisional_keepalive_sched_id = ast_sched_add(sched, PROVIS_KEEPALIVE_TIMEOUT,
04157 with_sdp ? send_provisional_keepalive_with_sdp : send_provisional_keepalive, dialog_ref(pvt, "Increment refcount to pass dialog pointer to sched callback"));
04158 }
04159
04160
04161 static int send_response(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno)
04162 {
04163 int res;
04164
04165 finalize_content(req);
04166 add_blank(req);
04167 if (sip_debug_test_pvt(p)) {
04168 const struct ast_sockaddr *dst = sip_real_dst(p);
04169
04170 ast_verbose("\n<--- %sTransmitting (%s) to %s --->\n%s\n<------------>\n",
04171 reliable ? "Reliably " : "", sip_nat_mode(p),
04172 ast_sockaddr_stringify(dst),
04173 req->data->str);
04174 }
04175 if (p->do_history) {
04176 struct sip_request tmp = { .rlPart1 = 0, };
04177 parse_copy(&tmp, req);
04178 append_history(p, reliable ? "TxRespRel" : "TxResp", "%s / %s - %s", tmp.data->str, get_header(&tmp, "CSeq"),
04179 (tmp.method == SIP_RESPONSE || tmp.method == SIP_UNKNOWN) ? REQ_OFFSET_TO_STR(&tmp, rlPart2) : sip_methods[tmp.method].text);
04180 deinit_req(&tmp);
04181 }
04182
04183
04184 if (p->initreq.method == SIP_INVITE && reliable == XMIT_CRITICAL) {
04185 AST_SCHED_DEL_UNREF(sched, p->provisional_keepalive_sched_id, dialog_unref(p, "when you delete the provisional_keepalive_sched_id, you should dec the refcount for the stored dialog ptr"));
04186 }
04187
04188 res = (reliable) ?
04189 __sip_reliable_xmit(p, seqno, 1, req->data, (reliable == XMIT_CRITICAL), req->method) :
04190 __sip_xmit(p, req->data);
04191 deinit_req(req);
04192 if (res > 0) {
04193 return 0;
04194 }
04195 return res;
04196 }
04197
04198
04199
04200
04201
04202
04203 static int send_request(struct sip_pvt *p, struct sip_request *req, enum xmittype reliable, int seqno)
04204 {
04205 int res;
04206
04207
04208
04209
04210 if (p->outboundproxy) {
04211 p->sa = p->outboundproxy->ip;
04212 }
04213
04214 finalize_content(req);
04215 add_blank(req);
04216 if (sip_debug_test_pvt(p)) {
04217 if (ast_test_flag(&p->flags[0], SIP_NAT_FORCE_RPORT)) {
04218 ast_verbose("%sTransmitting (NAT) to %s:\n%s\n---\n", reliable ? "Reliably " : "", ast_sockaddr_stringify(&p->recv), req->data->str);
04219 } else {
04220 ast_verbose("%sTransmitting (no NAT) to %s:\n%s\n---\n", reliable ? "Reliably " : "", ast_sockaddr_stringify(&p->sa), req->data->str);
04221 }
04222 }
04223 if (p->do_history) {
04224 struct sip_request tmp = { .rlPart1 = 0, };
04225 parse_copy(&tmp, req);
04226 append_history(p, reliable ? "TxReqRel" : "TxReq", "%s / %s - %s", tmp.data->str, get_header(&tmp, "CSeq"), sip_methods[tmp.method].text);
04227 deinit_req(&tmp);
04228 }
04229 res = (reliable) ?
04230 __sip_reliable_xmit(p, seqno, 0, req->data, (reliable == XMIT_CRITICAL), req->method) :
04231 __sip_xmit(p, req->data);
04232 deinit_req(req);
04233 return res;
04234 }
04235
04236 static void enable_dsp_detect(struct sip_pvt *p)
04237 {
04238 int features = 0;
04239
04240 if (p->dsp) {
04241 return;
04242 }
04243
04244 if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_INBAND) ||
04245 (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO)) {
04246 if (p->rtp) {
04247 ast_rtp_instance_dtmf_mode_set(p->rtp, AST_RTP_DTMF_MODE_INBAND);
04248 }
04249 features |= DSP_FEATURE_DIGIT_DETECT;
04250 }
04251
04252 if (ast_test_flag(&p->flags[1], SIP_PAGE2_FAX_DETECT_CNG)) {
04253 features |= DSP_FEATURE_FAX_DETECT;
04254 }
04255
04256 if (!features) {
04257 return;
04258 }
04259
04260 if (!(p->dsp = ast_dsp_new())) {
04261 return;
04262 }
04263
04264 ast_dsp_set_features(p->dsp, features);
04265 if (global_relaxdtmf) {
04266 ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
04267 }
04268 }
04269
04270 static void disable_dsp_detect(struct sip_pvt *p)
04271 {
04272 if (p->dsp) {
04273 ast_dsp_free(p->dsp);
04274 p->dsp = NULL;
04275 }
04276 }
04277
04278
04279 static int sip_setoption(struct ast_channel *chan, int option, void *data, int datalen)
04280 {
04281 int res = -1;
04282 struct sip_pvt *p = chan->tech_pvt;
04283
04284 if (!p) {
04285 ast_log(LOG_ERROR, "Attempt to Ref a null pointer. sip private structure is gone!\n");
04286 return -1;
04287 }
04288
04289 sip_pvt_lock(p);
04290
04291 switch (option) {
04292 case AST_OPTION_FORMAT_READ:
04293 if (p->rtp) {
04294 res = ast_rtp_instance_set_read_format(p->rtp, *(int *) data);
04295 }
04296 break;
04297 case AST_OPTION_FORMAT_WRITE:
04298 if (p->rtp) {
04299 res = ast_rtp_instance_set_write_format(p->rtp, *(int *) data);
04300 }
04301 break;
04302 case AST_OPTION_MAKE_COMPATIBLE:
04303 if (p->rtp) {
04304 res = ast_rtp_instance_make_compatible(chan, p->rtp, (struct ast_channel *) data);
04305 }
04306 break;
04307 case AST_OPTION_DIGIT_DETECT:
04308 if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_INBAND) ||
04309 (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO)) {
04310 char *cp = (char *) data;
04311
04312 ast_debug(1, "%sabling digit detection on %s\n", *cp ? "En" : "Dis", chan->name);
04313 if (*cp) {
04314 enable_dsp_detect(p);
04315 } else {
04316 disable_dsp_detect(p);
04317 }
04318 res = 0;
04319 }
04320 break;
04321 case AST_OPTION_SECURE_SIGNALING:
04322 p->req_secure_signaling = *(unsigned int *) data;
04323 res = 0;
04324 break;
04325 case AST_OPTION_SECURE_MEDIA:
04326 ast_set2_flag(&p->flags[1], *(unsigned int *) data, SIP_PAGE2_USE_SRTP);
04327 res = 0;
04328 break;
04329 default:
04330 break;
04331 }
04332
04333 sip_pvt_unlock(p);
04334
04335 return res;
04336 }
04337
04338
04339 static int sip_queryoption(struct ast_channel *chan, int option, void *data, int *datalen)
04340 {
04341 int res = -1;
04342 enum ast_t38_state state = T38_STATE_UNAVAILABLE;
04343 struct sip_pvt *p = (struct sip_pvt *) chan->tech_pvt;
04344 char *cp;
04345
04346 sip_pvt_lock(p);
04347
04348 switch (option) {
04349 case AST_OPTION_T38_STATE:
04350
04351 if (*datalen != sizeof(enum ast_t38_state)) {
04352 ast_log(LOG_ERROR, "Invalid datalen for AST_OPTION_T38_STATE option. Expected %d, got %d\n", (int)sizeof(enum ast_t38_state), *datalen);
04353 break;
04354 }
04355
04356
04357 if (ast_test_flag(&p->flags[1], SIP_PAGE2_T38SUPPORT)) {
04358 switch (p->t38.state) {
04359 case T38_LOCAL_REINVITE:
04360 case T38_PEER_REINVITE:
04361 state = T38_STATE_NEGOTIATING;
04362 break;
04363 case T38_ENABLED:
04364 state = T38_STATE_NEGOTIATED;
04365 break;
04366 default:
04367 state = T38_STATE_UNKNOWN;
04368 }
04369 }
04370
04371 *((enum ast_t38_state *) data) = state;
04372 res = 0;
04373
04374 break;
04375 case AST_OPTION_DIGIT_DETECT:
04376 cp = (char *) data;
04377 *cp = p->dsp ? 1 : 0;
04378 ast_debug(1, "Reporting digit detection %sabled on %s\n", *cp ? "en" : "dis", chan->name);
04379 break;
04380 case AST_OPTION_SECURE_SIGNALING:
04381 *((unsigned int *) data) = p->req_secure_signaling;
04382 res = 0;
04383 break;
04384 case AST_OPTION_SECURE_MEDIA:
04385 *((unsigned int *) data) = ast_test_flag(&p->flags[1], SIP_PAGE2_USE_SRTP) ? 1 : 0;
04386 res = 0;
04387 break;
04388 case AST_OPTION_DEVICE_NAME:
04389 if (p && p->outgoing_call) {
04390 cp = (char *) data;
04391 ast_copy_string(cp, p->dialstring, *datalen);
04392 res = 0;
04393 }
04394
04395
04396
04397 break;
04398 default:
04399 break;
04400 }
04401
04402 sip_pvt_unlock(p);
04403
04404 return res;
04405 }
04406
04407
04408
04409
04410
04411 const char *find_closing_quote(const char *start, const char *lim)
04412 {
04413 char last_char = '\0';
04414 const char *s;
04415 for (s = start; *s && s != lim; last_char = *s++) {
04416 if (*s == '"' && last_char != '\\')
04417 break;
04418 }
04419 return s;
04420 }
04421
04422
04423 static int sip_sendhtml(struct ast_channel *chan, int subclass, const char *data, int datalen)
04424 {
04425 struct sip_pvt *p = chan->tech_pvt;
04426
04427 if (subclass != AST_HTML_URL)
04428 return -1;
04429
04430 ast_string_field_build(p, url, "<%s>;mode=active", data);
04431
04432 if (sip_debug_test_pvt(p))
04433 ast_debug(1, "Send URL %s, state = %d!\n", data, chan->_state);
04434
04435 switch (chan->_state) {
04436 case AST_STATE_RING:
04437 transmit_response(p, "100 Trying", &p->initreq);
04438 break;
04439 case AST_STATE_RINGING:
04440 transmit_response(p, "180 Ringing", &p->initreq);
04441 break;
04442 case AST_STATE_UP:
04443 if (!p->pendinginvite) {
04444 transmit_reinvite_with_sdp(p, FALSE, FALSE);
04445 } else if (!ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
04446 ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
04447 }
04448 break;
04449 default:
04450 ast_log(LOG_WARNING, "Don't know how to send URI when state is %d!\n", chan->_state);
04451 }
04452
04453 return 0;
04454 }
04455
04456
04457 static const char *sip_get_callid(struct ast_channel *chan)
04458 {
04459 return chan->tech_pvt ? ((struct sip_pvt *) chan->tech_pvt)->callid : "";
04460 }
04461
04462
04463
04464
04465
04466
04467 static int sip_sendtext(struct ast_channel *ast, const char *text)
04468 {
04469 struct sip_pvt *dialog = ast->tech_pvt;
04470 int debug;
04471
04472 if (!dialog) {
04473 return -1;
04474 }
04475
04476
04477 if (!text) {
04478 return 0;
04479 }
04480 if(!is_method_allowed(&dialog->allowed_methods, SIP_MESSAGE)) {
04481 ast_debug(2, "Trying to send MESSAGE to device that does not support it.\n");
04482 return(0);
04483 }
04484
04485 debug = sip_debug_test_pvt(dialog);
04486 if (debug) {
04487 ast_verbose("Sending text %s on %s\n", text, ast->name);
04488 }
04489
04490 transmit_message_with_text(dialog, text);
04491 return 0;
04492 }
04493
04494
04495
04496
04497
04498
04499 static void realtime_update_peer(const char *peername, struct ast_sockaddr *addr, const char *defaultuser, const char *fullcontact, const char *useragent, int expirey, unsigned short deprecated_username, int lastms)
04500 {
04501 char port[10];
04502 char ipaddr[INET6_ADDRSTRLEN];
04503 char regseconds[20];
04504 char *tablename = NULL;
04505 char str_lastms[20];
04506
04507 const char *sysname = ast_config_AST_SYSTEM_NAME;
04508 char *syslabel = NULL;
04509
04510 time_t nowtime = time(NULL) + expirey;
04511 const char *fc = fullcontact ? "fullcontact" : NULL;
04512
04513 int realtimeregs = ast_check_realtime("sipregs");
04514
04515 tablename = realtimeregs ? "sipregs" : "sippeers";
04516
04517
04518 snprintf(str_lastms, sizeof(str_lastms), "%d", lastms);
04519 snprintf(regseconds, sizeof(regseconds), "%d", (int)nowtime);
04520 ast_copy_string(ipaddr, ast_sockaddr_stringify_addr(addr), sizeof(ipaddr));
04521 ast_copy_string(port, ast_sockaddr_stringify_port(addr), sizeof(port));
04522
04523 if (ast_strlen_zero(sysname))
04524 sysname = NULL;
04525 else if (sip_cfg.rtsave_sysname)
04526 syslabel = "regserver";
04527
04528
04529
04530
04531
04532
04533
04534 if (fc) {
04535 ast_update_realtime(tablename, "name", peername, "ipaddr", ipaddr,
04536 "port", port, "regseconds", regseconds,
04537 deprecated_username ? "username" : "defaultuser", defaultuser,
04538 "useragent", useragent, "lastms", str_lastms,
04539 fc, fullcontact, syslabel, sysname, SENTINEL);
04540 } else {
04541 ast_update_realtime(tablename, "name", peername, "ipaddr", ipaddr,
04542 "port", port, "regseconds", regseconds,
04543 "useragent", useragent, "lastms", str_lastms,
04544 deprecated_username ? "username" : "defaultuser", defaultuser,
04545 syslabel, sysname, SENTINEL);
04546 }
04547 }
04548
04549
04550 static void register_peer_exten(struct sip_peer *peer, int onoff)
04551 {
04552 char multi[256];
04553 char *stringp, *ext, *context;
04554 struct pbx_find_info q = { .stacklen = 0 };
04555
04556
04557
04558
04559
04560 if (ast_strlen_zero(sip_cfg.regcontext))
04561 return;
04562
04563 ast_copy_string(multi, S_OR(peer->regexten, peer->name), sizeof(multi));
04564 stringp = multi;
04565 while ((ext = strsep(&stringp, "&"))) {
04566 if ((context = strchr(ext, '@'))) {
04567 *context++ = '\0';
04568 if (!ast_context_find(context)) {
04569 ast_log(LOG_WARNING, "Context %s must exist in regcontext= in sip.conf!\n", context);
04570 continue;
04571 }
04572 } else {
04573 context = sip_cfg.regcontext;
04574 }
04575 if (onoff) {
04576 if (!ast_exists_extension(NULL, context, ext, 1, NULL)) {
04577 ast_add_extension(context, 1, ext, 1, NULL, NULL, "Noop",
04578 ast_strdup(peer->name), ast_free_ptr, "SIP");
04579 }
04580 } else if (pbx_find_extension(NULL, NULL, &q, context, ext, 1, NULL, "", E_MATCH)) {
04581 ast_context_remove_extension(context, ext, 1, NULL);
04582 }
04583 }
04584 }
04585
04586
04587 static void destroy_mailbox(struct sip_mailbox *mailbox)
04588 {
04589 if (mailbox->event_sub)
04590 ast_event_unsubscribe(mailbox->event_sub);
04591 ast_free(mailbox);
04592 }
04593
04594
04595 static void clear_peer_mailboxes(struct sip_peer *peer)
04596 {
04597 struct sip_mailbox *mailbox;
04598
04599 while ((mailbox = AST_LIST_REMOVE_HEAD(&peer->mailboxes, entry)))
04600 destroy_mailbox(mailbox);
04601 }
04602
04603 static void sip_destroy_peer_fn(void *peer)
04604 {
04605 sip_destroy_peer(peer);
04606 }
04607
04608
04609 static void sip_destroy_peer(struct sip_peer *peer)
04610 {
04611 ast_debug(3, "Destroying SIP peer %s\n", peer->name);
04612
04613
04614
04615
04616
04617
04618 clear_peer_mailboxes(peer);
04619
04620 if (peer->outboundproxy) {
04621 ao2_ref(peer->outboundproxy, -1);
04622 peer->outboundproxy = NULL;
04623 }
04624
04625
04626 if (peer->call) {
04627 dialog_unlink_all(peer->call);
04628 peer->call = dialog_unref(peer->call, "peer->call is being unset");
04629 }
04630
04631 if (peer->mwipvt) {
04632 dialog_unlink_all(peer->mwipvt);
04633 peer->mwipvt = dialog_unref(peer->mwipvt, "unreffing peer->mwipvt");
04634 }
04635
04636 if (peer->chanvars) {
04637 ast_variables_destroy(peer->chanvars);
04638 peer->chanvars = NULL;
04639 }
04640
04641 register_peer_exten(peer, FALSE);
04642 ast_free_ha(peer->ha);
04643 ast_free_ha(peer->directmediaha);
04644 if (peer->selfdestruct)
04645 ast_atomic_fetchadd_int(&apeerobjs, -1);
04646 else if (!ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS) && peer->is_realtime) {
04647 ast_atomic_fetchadd_int(&rpeerobjs, -1);
04648 ast_debug(3, "-REALTIME- peer Destroyed. Name: %s. Realtime Peer objects: %d\n", peer->name, rpeerobjs);
04649 } else
04650 ast_atomic_fetchadd_int(&speerobjs, -1);
04651 if (peer->auth) {
04652 ao2_t_ref(peer->auth, -1, "Removing peer authentication");
04653 peer->auth = NULL;
04654 }
04655
04656 if (peer->socket.tcptls_session) {
04657 ao2_ref(peer->socket.tcptls_session, -1);
04658 peer->socket.tcptls_session = NULL;
04659 }
04660
04661 ast_cc_config_params_destroy(peer->cc_params);
04662
04663 ast_string_field_free_memory(peer);
04664 }
04665
04666
04667 static void update_peer(struct sip_peer *p, int expire)
04668 {
04669 int rtcachefriends = ast_test_flag(&p->flags[1], SIP_PAGE2_RTCACHEFRIENDS);
04670 if (sip_cfg.peer_rtupdate &&
04671 (p->is_realtime || rtcachefriends)) {
04672 realtime_update_peer(p->name, &p->addr, p->username, p->fullcontact, p->useragent, expire, p->deprecated_username, p->lastms);
04673 }
04674 }
04675
04676 static struct ast_variable *get_insecure_variable_from_config(struct ast_config *cfg)
04677 {
04678 struct ast_variable *var = NULL;
04679 struct ast_flags flags = {0};
04680 char *cat = NULL;
04681 const char *insecure;
04682 while ((cat = ast_category_browse(cfg, cat))) {
04683 insecure = ast_variable_retrieve(cfg, cat, "insecure");
04684 set_insecure_flags(&flags, insecure, -1);
04685 if (ast_test_flag(&flags, SIP_INSECURE_PORT)) {
04686 var = ast_category_root(cfg, cat);
04687 break;
04688 }
04689 }
04690 return var;
04691 }
04692
04693 static struct ast_variable *get_insecure_variable_from_sippeers(const char *column, const char *value)
04694 {
04695 struct ast_config *peerlist;
04696 struct ast_variable *var = NULL;
04697 if ((peerlist = ast_load_realtime_multientry("sippeers", column, value, "insecure LIKE", "%port%", SENTINEL))) {
04698 if ((var = get_insecure_variable_from_config(peerlist))) {
04699
04700
04701 var = ast_variables_dup(var);
04702 }
04703 ast_config_destroy(peerlist);
04704 }
04705 return var;
04706 }
04707
04708
04709
04710
04711
04712
04713 static struct ast_variable *get_insecure_variable_from_sipregs(const char *column, const char *value, struct ast_variable **var)
04714 {
04715 struct ast_variable *varregs = NULL;
04716 struct ast_config *regs, *peers;
04717 char *regscat;
04718 const char *regname;
04719
04720 if (!(regs = ast_load_realtime_multientry("sipregs", column, value, SENTINEL))) {
04721 return NULL;
04722 }
04723
04724
04725 if (!(peers = ast_load_realtime_multientry("sippeers", "insecure LIKE", "%port%", SENTINEL))) {
04726 ast_config_destroy(regs);
04727 return NULL;
04728 }
04729
04730
04731
04732 regscat = NULL;
04733 while ((regscat = ast_category_browse(regs, regscat)) && (regname = ast_variable_retrieve(regs, regscat, "name"))) {
04734 char *peerscat;
04735 const char *peername;
04736
04737 peerscat = NULL;
04738 while ((peerscat = ast_category_browse(peers, peerscat)) && (peername = ast_variable_retrieve(peers, peerscat, "name"))) {
04739 if (!strcasecmp(regname, peername)) {
04740
04741
04742 const char *insecure = ast_variable_retrieve(peers, peerscat, "insecure");
04743 struct ast_flags flags = {0};
04744 set_insecure_flags(&flags, insecure, -1);
04745 if (ast_test_flag(&flags, SIP_INSECURE_PORT)) {
04746
04747 if ((varregs = ast_variables_dup(ast_category_root(regs, regscat)))) {
04748 if (!(*var = ast_variables_dup(ast_category_root(peers, peerscat)))) {
04749 ast_variables_destroy(varregs);
04750 varregs = NULL;
04751 }
04752 }
04753 goto done;
04754 }
04755 }
04756 }
04757 }
04758
04759 done:
04760 ast_config_destroy(regs);
04761 ast_config_destroy(peers);
04762 return varregs;
04763 }
04764
04765 static const char *get_name_from_variable(const struct ast_variable *var)
04766 {
04767
04768
04769
04770
04771
04772
04773
04774
04775 const struct ast_variable *tmp;
04776 for (tmp = var; tmp; tmp = tmp->next) {
04777 if (!strcasecmp(tmp->name, "name")) {
04778 if (!ast_strlen_zero(tmp->value)) {
04779 return tmp->value;
04780 }
04781 break;
04782 }
04783 }
04784 return NULL;
04785 }
04786
04787
04788
04789 static int realtime_peer_by_name(const char *const *name, struct ast_sockaddr *addr, const char *ipaddr, struct ast_variable **var, struct ast_variable **varregs)
04790 {
04791
04792 if ((*var = ast_load_realtime("sippeers", "name", *name, "host", "dynamic", SENTINEL))) {
04793 ;
04794
04795 } else if (addr && !(*var = ast_load_realtime("sippeers", "name", *name, "host", ipaddr, SENTINEL))) {
04796 ;
04797
04798 } else if ((*var = ast_load_realtime("sippeers", "name", *name, SENTINEL))) {
04799
04800
04801
04802
04803
04804
04805 if (addr) {
04806 struct ast_variable *tmp;
04807 for (tmp = *var; tmp; tmp = tmp->next) {
04808 if (!strcasecmp(tmp->name, "host")) {
04809 struct ast_sockaddr *addrs = NULL;
04810
04811 if (ast_sockaddr_resolve(&addrs,
04812 tmp->value,
04813 PARSE_PORT_FORBID,
04814 get_address_family_filter(&bindaddr)) <= 0 ||
04815 ast_sockaddr_cmp(&addrs[0], addr)) {
04816
04817 ast_variables_destroy(*var);
04818 *var = NULL;
04819 }
04820 ast_free(addrs);
04821 break;
04822 }
04823 }
04824 }
04825 }
04826
04827
04828 if (*var) {
04829 if (varregs) {
04830 *varregs = ast_load_realtime("sipregs", "name", *name, SENTINEL);
04831 }
04832 return 1;
04833 }
04834 return 0;
04835 }
04836
04837
04838
04839
04840
04841
04842
04843 static struct ast_variable *realtime_peer_get_sippeer_helper(const char **name, struct ast_variable **varregs) {
04844 struct ast_variable *var = NULL;
04845 const char *old_name = *name;
04846 *name = get_name_from_variable(*varregs);
04847 if (!*name || !(var = ast_load_realtime("sippeers", "name", *name, SENTINEL))) {
04848 if (!*name) {
04849 ast_log(LOG_WARNING, "Found sipreg but it has no name\n");
04850 }
04851 ast_variables_destroy(*varregs);
04852 *varregs = NULL;
04853 *name = old_name;
04854 }
04855 return var;
04856 }
04857
04858
04859
04860
04861 static int realtime_peer_by_addr(const char **name, struct ast_sockaddr *addr, const char *ipaddr, struct ast_variable **var, struct ast_variable **varregs)
04862 {
04863 char portstring[6];
04864 ast_copy_string(portstring, ast_sockaddr_stringify_port(addr), sizeof(portstring));
04865
04866
04867 *name = NULL;
04868
04869
04870 if ((*var = ast_load_realtime("sippeers", "host", ipaddr, "port", portstring, SENTINEL))) {
04871 ;
04872
04873 } else if (varregs && (*varregs = ast_load_realtime("sipregs", "ipaddr", ipaddr, "port", portstring, SENTINEL)) &&
04874 (*var = realtime_peer_get_sippeer_helper(name, varregs))) {
04875 ;
04876
04877 } else if (!varregs && (*var = ast_load_realtime("sippeers", "ipaddr", ipaddr, "port", portstring, SENTINEL))) {
04878 ;
04879
04880 } else if ((*var = get_insecure_variable_from_sippeers("host", ipaddr))) {
04881 ;
04882
04883
04884
04885
04886 } else if (varregs && (*varregs = get_insecure_variable_from_sipregs("ipaddr", ipaddr, var))) {
04887 ;
04888
04889 } else if (!varregs && (*var = get_insecure_variable_from_sippeers("ipaddr", ipaddr))) {
04890 ;
04891 }
04892
04893
04894 if (!*var) {
04895 return 0;
04896 }
04897
04898
04899
04900
04901 if (!*name && !(*name = get_name_from_variable(*var))) {
04902 ast_log(LOG_WARNING, "Found peer for IP %s but it has no name\n", ipaddr);
04903 ast_variables_destroy(*var);
04904 *var = NULL;
04905 if (varregs && *varregs) {
04906 ast_variables_destroy(*varregs);
04907 *varregs = NULL;
04908 }
04909 return 0;
04910 }
04911
04912
04913
04914
04915 if (varregs && !*varregs) {
04916 *varregs = ast_load_realtime("sipregs", "name", *name, SENTINEL);
04917 }
04918 return 1;
04919 }
04920
04921
04922
04923
04924
04925
04926
04927
04928
04929
04930 static struct sip_peer *realtime_peer(const char *newpeername, struct ast_sockaddr *addr, int devstate_only, int which_objects)
04931 {
04932 struct sip_peer *peer = NULL;
04933 struct ast_variable *var = NULL;
04934 struct ast_variable *varregs = NULL;
04935 char ipaddr[INET6_ADDRSTRLEN];
04936 int realtimeregs = ast_check_realtime("sipregs");
04937
04938 if (addr) {
04939 ast_copy_string(ipaddr, ast_sockaddr_stringify_addr(addr), sizeof(ipaddr));
04940 } else {
04941 ipaddr[0] = '\0';
04942 }
04943
04944 if (newpeername && realtime_peer_by_name(&newpeername, addr, ipaddr, &var, realtimeregs ? &varregs : NULL)) {
04945 ;
04946 } else if (addr && realtime_peer_by_addr(&newpeername, addr, ipaddr, &var, realtimeregs ? &varregs : NULL)) {
04947 ;
04948 } else {
04949 return NULL;
04950 }
04951
04952
04953
04954 if (which_objects == FINDUSERS) {
04955 struct ast_variable *tmp;
04956 for (tmp = var; tmp; tmp = tmp->next) {
04957 if (!strcasecmp(tmp->name, "type") && (!strcasecmp(tmp->value, "peer"))) {
04958 goto cleanup;
04959 }
04960 }
04961 }
04962
04963
04964 peer = build_peer(newpeername, var, varregs, TRUE, devstate_only);
04965 if (!peer) {
04966 goto cleanup;
04967 }
04968
04969 ast_debug(3, "-REALTIME- loading peer from database to memory. Name: %s. Peer objects: %d\n", peer->name, rpeerobjs);
04970
04971 if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS) && !devstate_only) {
04972
04973 ast_copy_flags(&peer->flags[1], &global_flags[1], SIP_PAGE2_RTAUTOCLEAR|SIP_PAGE2_RTCACHEFRIENDS);
04974 if (ast_test_flag(&global_flags[1], SIP_PAGE2_RTAUTOCLEAR)) {
04975 AST_SCHED_REPLACE_UNREF(peer->expire, sched, sip_cfg.rtautoclear * 1000, expire_register, peer,
04976 unref_peer(_data, "remove registration ref"),
04977 unref_peer(peer, "remove registration ref"),
04978 ref_peer(peer, "add registration ref"));
04979 }
04980 ao2_t_link(peers, peer, "link peer into peers table");
04981 if (!ast_sockaddr_isnull(&peer->addr)) {
04982 ao2_t_link(peers_by_ip, peer, "link peer into peers_by_ip table");
04983 }
04984 }
04985 peer->is_realtime = 1;
04986
04987 cleanup:
04988 ast_variables_destroy(var);
04989 ast_variables_destroy(varregs);
04990 return peer;
04991 }
04992
04993
04994 static int find_by_name(void *obj, void *arg, void *data, int flags)
04995 {
04996 struct sip_peer *search = obj, *match = arg;
04997 int *which_objects = data;
04998
04999
05000 if (strcmp(search->name, match->name)) {
05001 return 0;
05002 }
05003
05004 switch (*which_objects) {
05005 case FINDUSERS:
05006 if (!(search->type & SIP_TYPE_USER)) {
05007 return 0;
05008 }
05009 break;
05010 case FINDPEERS:
05011 if (!(search->type & SIP_TYPE_PEER)) {
05012 return 0;
05013 }
05014 break;
05015 case FINDALLDEVICES:
05016 break;
05017 }
05018
05019 return CMP_MATCH | CMP_STOP;
05020 }
05021
05022
05023
05024
05025
05026
05027
05028
05029
05030
05031
05032
05033
05034
05035 static struct sip_peer *find_peer(const char *peer, struct ast_sockaddr *addr, int realtime, int which_objects, int devstate_only, int transport)
05036 {
05037 struct sip_peer *p = NULL;
05038 struct sip_peer tmp_peer;
05039
05040 if (peer) {
05041 ast_copy_string(tmp_peer.name, peer, sizeof(tmp_peer.name));
05042 p = ao2_t_callback_data(peers, OBJ_POINTER, find_by_name, &tmp_peer, &which_objects, "ao2_find in peers table");
05043 } else if (addr) {
05044 ast_sockaddr_copy(&tmp_peer.addr, addr);
05045 tmp_peer.flags[0].flags = 0;
05046 tmp_peer.transports = transport;
05047 p = ao2_t_find(peers_by_ip, &tmp_peer, OBJ_POINTER, "ao2_find in peers_by_ip table");
05048 if (!p) {
05049 ast_set_flag(&tmp_peer.flags[0], SIP_INSECURE_PORT);
05050 p = ao2_t_find(peers_by_ip, &tmp_peer, OBJ_POINTER, "ao2_find in peers_by_ip table 2");
05051 if (p) {
05052 return p;
05053 }
05054 }
05055 }
05056
05057 if (!p && (realtime || devstate_only)) {
05058 p = realtime_peer(peer, addr, devstate_only, which_objects);
05059 if (p) {
05060 switch (which_objects) {
05061 case FINDUSERS:
05062 if (!(p->type & SIP_TYPE_USER)) {
05063 unref_peer(p, "Wrong type of realtime SIP endpoint");
05064 return NULL;
05065 }
05066 break;
05067 case FINDPEERS:
05068 if (!(p->type & SIP_TYPE_PEER)) {
05069 unref_peer(p, "Wrong type of realtime SIP endpoint");
05070 return NULL;
05071 }
05072 break;
05073 case FINDALLDEVICES:
05074 break;
05075 }
05076 }
05077 }
05078
05079 return p;
05080 }
05081
05082
05083 static void do_setnat(struct sip_pvt *p)
05084 {
05085 const char *mode;
05086 int natflags;
05087
05088 natflags = ast_test_flag(&p->flags[1], SIP_PAGE2_SYMMETRICRTP);
05089 mode = natflags ? "On" : "Off";
05090
05091 if (p->rtp) {
05092 ast_debug(1, "Setting NAT on RTP to %s\n", mode);
05093 ast_rtp_instance_set_prop(p->rtp, AST_RTP_PROPERTY_NAT, natflags);
05094 }
05095 if (p->vrtp) {
05096 ast_debug(1, "Setting NAT on VRTP to %s\n", mode);
05097 ast_rtp_instance_set_prop(p->vrtp, AST_RTP_PROPERTY_NAT, natflags);
05098 }
05099 if (p->udptl) {
05100 ast_debug(1, "Setting NAT on UDPTL to %s\n", mode);
05101 ast_udptl_setnat(p->udptl, natflags);
05102 }
05103 if (p->trtp) {
05104 ast_debug(1, "Setting NAT on TRTP to %s\n", mode);
05105 ast_rtp_instance_set_prop(p->trtp, AST_RTP_PROPERTY_NAT, natflags);
05106 }
05107 }
05108
05109
05110 static void change_t38_state(struct sip_pvt *p, int state)
05111 {
05112 int old = p->t38.state;
05113 struct ast_channel *chan = p->owner;
05114 struct ast_control_t38_parameters parameters = { .request_response = 0 };
05115
05116
05117 if (old == state)
05118 return;
05119
05120 p->t38.state = state;
05121 ast_debug(2, "T38 state changed to %d on channel %s\n", p->t38.state, chan ? chan->name : "<none>");
05122
05123
05124 if (!chan)
05125 return;
05126
05127
05128 switch (state) {
05129 case T38_PEER_REINVITE:
05130 parameters = p->t38.their_parms;
05131 parameters.max_ifp = ast_udptl_get_far_max_ifp(p->udptl);
05132 parameters.request_response = AST_T38_REQUEST_NEGOTIATE;
05133 ast_udptl_set_tag(p->udptl, "%s", chan->name);
05134 break;
05135 case T38_ENABLED:
05136 parameters = p->t38.their_parms;
05137 parameters.max_ifp = ast_udptl_get_far_max_ifp(p->udptl);
05138 parameters.request_response = AST_T38_NEGOTIATED;
05139 ast_udptl_set_tag(p->udptl, "%s", chan->name);
05140 break;
05141 case T38_DISABLED:
05142 if (old == T38_ENABLED) {
05143 parameters.request_response = AST_T38_TERMINATED;
05144 } else if (old == T38_LOCAL_REINVITE) {
05145 parameters.request_response = AST_T38_REFUSED;
05146 }
05147 break;
05148 case T38_LOCAL_REINVITE:
05149
05150 break;
05151 }
05152
05153
05154 if (parameters.request_response)
05155 ast_queue_control_data(chan, AST_CONTROL_T38_PARAMETERS, ¶meters, sizeof(parameters));
05156 }
05157
05158
05159 static void set_t38_capabilities(struct sip_pvt *p)
05160 {
05161 if (p->udptl) {
05162 if (ast_test_flag(&p->flags[1], SIP_PAGE2_T38SUPPORT) == SIP_PAGE2_T38SUPPORT_UDPTL_REDUNDANCY) {
05163 ast_udptl_set_error_correction_scheme(p->udptl, UDPTL_ERROR_CORRECTION_REDUNDANCY);
05164 } else if (ast_test_flag(&p->flags[1], SIP_PAGE2_T38SUPPORT) == SIP_PAGE2_T38SUPPORT_UDPTL_FEC) {
05165 ast_udptl_set_error_correction_scheme(p->udptl, UDPTL_ERROR_CORRECTION_FEC);
05166 } else if (ast_test_flag(&p->flags[1], SIP_PAGE2_T38SUPPORT) == SIP_PAGE2_T38SUPPORT_UDPTL) {
05167 ast_udptl_set_error_correction_scheme(p->udptl, UDPTL_ERROR_CORRECTION_NONE);
05168 }
05169 }
05170 }
05171
05172 static void copy_socket_data(struct sip_socket *to_sock, const struct sip_socket *from_sock)
05173 {
05174 if (to_sock->tcptls_session) {
05175 ao2_ref(to_sock->tcptls_session, -1);
05176 to_sock->tcptls_session = NULL;
05177 }
05178
05179 if (from_sock->tcptls_session) {
05180 ao2_ref(from_sock->tcptls_session, +1);
05181 }
05182
05183 *to_sock = *from_sock;
05184 }
05185
05186
05187
05188
05189 static int dialog_initialize_rtp(struct sip_pvt *dialog)
05190 {
05191 struct ast_sockaddr bindaddr_tmp;
05192
05193 if (!sip_methods[dialog->method].need_rtp) {
05194 return 0;
05195 }
05196
05197 ast_sockaddr_copy(&bindaddr_tmp, &bindaddr);
05198 if (!(dialog->rtp = ast_rtp_instance_new(dialog->engine, sched, &bindaddr_tmp, NULL))) {
05199 return -1;
05200 }
05201
05202 if (ast_test_flag(&dialog->flags[1], SIP_PAGE2_VIDEOSUPPORT_ALWAYS) ||
05203 (ast_test_flag(&dialog->flags[1], SIP_PAGE2_VIDEOSUPPORT) && (dialog->capability & AST_FORMAT_VIDEO_MASK))) {
05204 if (!(dialog->vrtp = ast_rtp_instance_new(dialog->engine, sched, &bindaddr_tmp, NULL))) {
05205 return -1;
05206 }
05207 ast_rtp_instance_set_timeout(dialog->vrtp, dialog->rtptimeout);
05208 ast_rtp_instance_set_hold_timeout(dialog->vrtp, dialog->rtpholdtimeout);
05209 ast_rtp_instance_set_keepalive(dialog->vrtp, dialog->rtpkeepalive);
05210
05211 ast_rtp_instance_set_prop(dialog->vrtp, AST_RTP_PROPERTY_RTCP, 1);
05212 }
05213
05214 if (ast_test_flag(&dialog->flags[1], SIP_PAGE2_TEXTSUPPORT)) {
05215 if (!(dialog->trtp = ast_rtp_instance_new(dialog->engine, sched, &bindaddr_tmp, NULL))) {
05216 return -1;
05217 }
05218
05219 ast_rtp_instance_set_keepalive(dialog->trtp, dialog->rtpkeepalive);
05220
05221 ast_rtp_instance_set_prop(dialog->trtp, AST_RTP_PROPERTY_RTCP, 1);
05222 }
05223
05224 ast_rtp_instance_set_timeout(dialog->rtp, dialog->rtptimeout);
05225 ast_rtp_instance_set_hold_timeout(dialog->rtp, dialog->rtpholdtimeout);
05226 ast_rtp_instance_set_keepalive(dialog->rtp, dialog->rtpkeepalive);
05227
05228 ast_rtp_instance_set_prop(dialog->rtp, AST_RTP_PROPERTY_RTCP, 1);
05229 ast_rtp_instance_set_prop(dialog->rtp, AST_RTP_PROPERTY_DTMF, ast_test_flag(&dialog->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833);
05230 ast_rtp_instance_set_prop(dialog->rtp, AST_RTP_PROPERTY_DTMF_COMPENSATE, ast_test_flag(&dialog->flags[1], SIP_PAGE2_RFC2833_COMPENSATE));
05231
05232 ast_rtp_instance_set_qos(dialog->rtp, global_tos_audio, global_cos_audio, "SIP RTP");
05233
05234 do_setnat(dialog);
05235
05236 return 0;
05237 }
05238
05239
05240
05241
05242
05243
05244
05245
05246 static int create_addr_from_peer(struct sip_pvt *dialog, struct sip_peer *peer)
05247 {
05248 struct sip_auth_container *credentials;
05249
05250
05251
05252
05253 if (dialog->socket.type && check_request_transport(peer, dialog))
05254 return -1;
05255 copy_socket_data(&dialog->socket, &peer->socket);
05256
05257 if (!(ast_sockaddr_isnull(&peer->addr) && ast_sockaddr_isnull(&peer->defaddr)) &&
05258 (!peer->maxms || ((peer->lastms >= 0) && (peer->lastms <= peer->maxms)))) {
05259 dialog->sa = ast_sockaddr_isnull(&peer->addr) ? peer->defaddr : peer->addr;
05260 dialog->recv = dialog->sa;
05261 } else
05262 return -1;
05263
05264
05265 ast_copy_flags(&dialog->flags[0], &peer->flags[0], SIP_FLAGS_TO_COPY);
05266 ast_copy_flags(&dialog->flags[1], &peer->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
05267 ast_copy_flags(&dialog->flags[2], &peer->flags[2], SIP_PAGE3_FLAGS_TO_COPY);
05268 dialog->capability = peer->capability;
05269 dialog->prefs = peer->prefs;
05270 dialog->amaflags = peer->amaflags;
05271
05272 ast_string_field_set(dialog, engine, peer->engine);
05273
05274 dialog->rtptimeout = peer->rtptimeout;
05275 dialog->rtpholdtimeout = peer->rtpholdtimeout;
05276 dialog->rtpkeepalive = peer->rtpkeepalive;
05277 if (dialog_initialize_rtp(dialog)) {
05278 return -1;
05279 }
05280
05281 if (dialog->rtp) {
05282 ast_rtp_instance_set_prop(dialog->rtp, AST_RTP_PROPERTY_DTMF, ast_test_flag(&dialog->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833);
05283 ast_rtp_instance_set_prop(dialog->rtp, AST_RTP_PROPERTY_DTMF_COMPENSATE, ast_test_flag(&dialog->flags[1], SIP_PAGE2_RFC2833_COMPENSATE));
05284
05285 ast_rtp_codecs_packetization_set(ast_rtp_instance_get_codecs(dialog->rtp), dialog->rtp, &dialog->prefs);
05286 dialog->autoframing = peer->autoframing;
05287 }
05288
05289
05290 ast_string_field_set(dialog, peername, peer->name);
05291 ast_string_field_set(dialog, authname, peer->username);
05292 ast_string_field_set(dialog, username, peer->username);
05293 ast_string_field_set(dialog, peersecret, peer->secret);
05294 ast_string_field_set(dialog, peermd5secret, peer->md5secret);
05295 ast_string_field_set(dialog, mohsuggest, peer->mohsuggest);
05296 ast_string_field_set(dialog, mohinterpret, peer->mohinterpret);
05297 ast_string_field_set(dialog, tohost, peer->tohost);
05298 ast_string_field_set(dialog, fullcontact, peer->fullcontact);
05299 ast_string_field_set(dialog, accountcode, peer->accountcode);
05300 ast_string_field_set(dialog, context, peer->context);
05301 ast_string_field_set(dialog, cid_num, peer->cid_num);
05302 ast_string_field_set(dialog, cid_name, peer->cid_name);
05303 ast_string_field_set(dialog, cid_tag, peer->cid_tag);
05304 ast_string_field_set(dialog, mwi_from, peer->mwi_from);
05305 if (!ast_strlen_zero(peer->parkinglot)) {
05306 ast_string_field_set(dialog, parkinglot, peer->parkinglot);
05307 }
05308 ast_string_field_set(dialog, engine, peer->engine);
05309 ref_proxy(dialog, obproxy_get(dialog, peer));
05310 dialog->callgroup = peer->callgroup;
05311 dialog->pickupgroup = peer->pickupgroup;
05312 dialog->allowtransfer = peer->allowtransfer;
05313 dialog->jointnoncodeccapability = dialog->noncodeccapability;
05314
05315
05316 ao2_lock(peer);
05317 credentials = peer->auth;
05318 if (credentials) {
05319 ao2_t_ref(credentials, +1, "Ref peer auth for dialog");
05320 }
05321 ao2_unlock(peer);
05322 ao2_lock(dialog);
05323 if (dialog->peerauth) {
05324 ao2_t_ref(dialog->peerauth, -1, "Unref old dialog peer auth");
05325 }
05326 dialog->peerauth = credentials;
05327 ao2_unlock(dialog);
05328
05329 dialog->maxcallbitrate = peer->maxcallbitrate;
05330 dialog->disallowed_methods = peer->disallowed_methods;
05331 ast_cc_copy_config_params(dialog->cc_params, peer->cc_params);
05332 if (ast_strlen_zero(dialog->tohost))
05333 ast_string_field_set(dialog, tohost, ast_sockaddr_stringify_host_remote(&dialog->sa));
05334 if (!ast_strlen_zero(peer->fromdomain)) {
05335 ast_string_field_set(dialog, fromdomain, peer->fromdomain);
05336 if (!dialog->initreq.headers) {
05337 char *new_callid;
05338 char *tmpcall = ast_strdupa(dialog->callid);
05339
05340 new_callid = strchr(tmpcall, '@');
05341 if (new_callid) {
05342 int callid_size;
05343
05344 *new_callid = '\0';
05345
05346
05347 callid_size = strlen(tmpcall) + strlen(peer->fromdomain) + 2;
05348 new_callid = alloca(callid_size);
05349 snprintf(new_callid, callid_size, "%s@%s", tmpcall, peer->fromdomain);
05350 change_callid_pvt(dialog, new_callid);
05351 }
05352 }
05353 }
05354 if (!ast_strlen_zero(peer->fromuser))
05355 ast_string_field_set(dialog, fromuser, peer->fromuser);
05356 if (!ast_strlen_zero(peer->language))
05357 ast_string_field_set(dialog, language, peer->language);
05358
05359
05360
05361
05362 if (peer->maxms && peer->lastms)
05363 dialog->timer_t1 = peer->lastms < global_t1min ? global_t1min : peer->lastms;
05364 else
05365 dialog->timer_t1 = peer->timer_t1;
05366
05367
05368
05369 if (peer->timer_b)
05370 dialog->timer_b = peer->timer_b;
05371 else
05372 dialog->timer_b = 64 * dialog->timer_t1;
05373
05374 if ((ast_test_flag(&dialog->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
05375 (ast_test_flag(&dialog->flags[0], SIP_DTMF) == SIP_DTMF_AUTO))
05376 dialog->noncodeccapability |= AST_RTP_DTMF;
05377 else
05378 dialog->noncodeccapability &= ~AST_RTP_DTMF;
05379 dialog->directmediaha = ast_duplicate_ha_list(peer->directmediaha);
05380 if (peer->call_limit)
05381 ast_set_flag(&dialog->flags[0], SIP_CALL_LIMIT);
05382 if (!dialog->portinuri)
05383 dialog->portinuri = peer->portinuri;
05384 dialog->chanvars = copy_vars(peer->chanvars);
05385 if (peer->fromdomainport)
05386 dialog->fromdomainport = peer->fromdomainport;
05387
05388 return 0;
05389 }
05390
05391
05392 static inline int default_sip_port(enum sip_transport type)
05393 {
05394 return type == SIP_TRANSPORT_TLS ? STANDARD_TLS_PORT : STANDARD_SIP_PORT;
05395 }
05396
05397
05398
05399
05400 static int create_addr(struct sip_pvt *dialog, const char *opeer, struct ast_sockaddr *addr, int newdialog, struct ast_sockaddr *remote_address)
05401 {
05402 struct sip_peer *peer;
05403 char *peername, *peername2, *hostn;
05404 char host[MAXHOSTNAMELEN];
05405 char service[MAXHOSTNAMELEN];
05406 int srv_ret = 0;
05407 int tportno;
05408
05409 AST_DECLARE_APP_ARGS(hostport,
05410 AST_APP_ARG(host);
05411 AST_APP_ARG(port);
05412 );
05413
05414 peername = ast_strdupa(opeer);
05415 peername2 = ast_strdupa(opeer);
05416 AST_NONSTANDARD_RAW_ARGS(hostport, peername2, ':');
05417
05418 if (hostport.port)
05419 dialog->portinuri = 1;
05420
05421 dialog->timer_t1 = global_t1;
05422 dialog->timer_b = global_timer_b;
05423 peer = find_peer(peername, NULL, TRUE, FINDPEERS, FALSE, 0);
05424
05425 if (peer) {
05426 int res;
05427 if (newdialog) {
05428 set_socket_transport(&dialog->socket, 0);
05429 }
05430 res = create_addr_from_peer(dialog, peer);
05431 if (!ast_sockaddr_isnull(remote_address)) {
05432 ast_sockaddr_copy(&dialog->sa, remote_address);
05433 }
05434 dialog->relatedpeer = ref_peer(peer, "create_addr: setting dialog's relatedpeer pointer");
05435 unref_peer(peer, "create_addr: unref peer from find_peer hashtab lookup");
05436 return res;
05437 } else if (ast_check_digits(peername)) {
05438
05439
05440
05441 ast_log(LOG_WARNING, "Purely numeric hostname (%s), and not a peer--rejecting!\n", peername);
05442 return -1;
05443 } else {
05444 dialog->rtptimeout = global_rtptimeout;
05445 dialog->rtpholdtimeout = global_rtpholdtimeout;
05446 dialog->rtpkeepalive = global_rtpkeepalive;
05447 if (dialog_initialize_rtp(dialog)) {
05448 return -1;
05449 }
05450 }
05451
05452 ast_string_field_set(dialog, tohost, hostport.host);
05453 dialog->allowed_methods &= ~sip_cfg.disallowed_methods;
05454
05455
05456 ref_proxy(dialog, obproxy_get(dialog, NULL));
05457
05458 if (addr) {
05459
05460 ast_sockaddr_copy(&dialog->sa, addr);
05461 } else {
05462
05463
05464
05465
05466
05467
05468 hostn = peername;
05469
05470
05471
05472 if (!hostport.port && sip_cfg.srvlookup) {
05473 snprintf(service, sizeof(service), "_%s._%s.%s",
05474 get_srv_service(dialog->socket.type),
05475 get_srv_protocol(dialog->socket.type), peername);
05476 if ((srv_ret = ast_get_srv(NULL, host, sizeof(host), &tportno,
05477 service)) > 0) {
05478 hostn = host;
05479 }
05480 }
05481
05482 if (ast_sockaddr_resolve_first(&dialog->sa, hostn, 0)) {
05483 ast_log(LOG_WARNING, "No such host: %s\n", peername);
05484 return -1;
05485 }
05486
05487 if (srv_ret > 0) {
05488 ast_sockaddr_set_port(&dialog->sa, tportno);
05489 }
05490 }
05491
05492 if (!dialog->socket.type)
05493 set_socket_transport(&dialog->socket, SIP_TRANSPORT_UDP);
05494 if (!dialog->socket.port) {
05495 dialog->socket.port = htons(ast_sockaddr_port(&bindaddr));
05496 }
05497
05498 if (!ast_sockaddr_port(&dialog->sa)) {
05499 ast_sockaddr_set_port(&dialog->sa, default_sip_port(dialog->socket.type));
05500 }
05501 ast_sockaddr_copy(&dialog->recv, &dialog->sa);
05502 return 0;
05503 }
05504
05505
05506
05507
05508 static int auto_congest(const void *arg)
05509 {
05510 struct sip_pvt *p = (struct sip_pvt *)arg;
05511
05512 sip_pvt_lock(p);
05513 p->initid = -1;
05514 if (p->owner) {
05515
05516 if (!ast_channel_trylock(p->owner)) {
05517 append_history(p, "Cong", "Auto-congesting (timer)");
05518 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
05519 ast_channel_unlock(p->owner);
05520 }
05521
05522
05523 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
05524 }
05525 sip_pvt_unlock(p);
05526 dialog_unref(p, "unreffing arg passed into auto_congest callback (p->initid)");
05527 return 0;
05528 }
05529
05530
05531
05532
05533 static int sip_call(struct ast_channel *ast, char *dest, int timeout)
05534 {
05535 int res;
05536 struct sip_pvt *p = ast->tech_pvt;
05537 struct varshead *headp;
05538 struct ast_var_t *current;
05539 const char *referer = NULL;
05540 int cc_core_id;
05541 char uri[SIPBUFSIZE] = "";
05542
05543 if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
05544 ast_log(LOG_WARNING, "sip_call called on %s, neither down nor reserved\n", ast->name);
05545 return -1;
05546 }
05547
05548 if (ast_cc_is_recall(ast, &cc_core_id, "SIP")) {
05549 char device_name[AST_CHANNEL_NAME];
05550 struct ast_cc_monitor *recall_monitor;
05551 struct sip_monitor_instance *monitor_instance;
05552 ast_channel_get_device_name(ast, device_name, sizeof(device_name));
05553 if ((recall_monitor = ast_cc_get_monitor_by_recall_core_id(cc_core_id, device_name))) {
05554 monitor_instance = recall_monitor->private_data;
05555 ast_copy_string(uri, monitor_instance->notify_uri, sizeof(uri));
05556 ao2_t_ref(recall_monitor, -1, "Got the URI we need so unreffing monitor");
05557 }
05558 }
05559
05560
05561 headp=&ast->varshead;
05562 AST_LIST_TRAVERSE(headp, current, entries) {
05563
05564 if (!p->options->vxml_url && !strcasecmp(ast_var_name(current), "VXML_URL")) {
05565 p->options->vxml_url = ast_var_value(current);
05566 } else if (!p->options->uri_options && !strcasecmp(ast_var_name(current), "SIP_URI_OPTIONS")) {
05567 p->options->uri_options = ast_var_value(current);
05568 } else if (!p->options->addsipheaders && !strncasecmp(ast_var_name(current), "SIPADDHEADER", strlen("SIPADDHEADER"))) {
05569
05570 p->options->addsipheaders = 1;
05571 } else if (!strcasecmp(ast_var_name(current), "SIPFROMDOMAIN")) {
05572 ast_string_field_set(p, fromdomain, ast_var_value(current));
05573 } else if (!strcasecmp(ast_var_name(current), "SIPTRANSFER")) {
05574
05575 p->options->transfer = 1;
05576 } else if (!strcasecmp(ast_var_name(current), "SIPTRANSFER_REFERER")) {
05577
05578 referer = ast_var_value(current);
05579 } else if (!strcasecmp(ast_var_name(current), "SIPTRANSFER_REPLACES")) {
05580
05581 p->options->replaces = ast_var_value(current);
05582 } else if (!strcasecmp(ast_var_name(current), "SIP_MAX_FORWARDS")) {
05583 if (sscanf(ast_var_value(current), "%d", &(p->maxforwards)) != 1) {
05584 ast_log(LOG_WARNING, "The SIP_MAX_FORWARDS channel variable is not a valid integer.");
05585 }
05586 }
05587 }
05588
05589
05590 if (p->req_secure_signaling && p->socket.type != SIP_TRANSPORT_TLS) {
05591 ast_log(LOG_WARNING, "Encrypted signaling is required\n");
05592 ast->hangupcause = AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
05593 return -1;
05594 }
05595
05596 if (ast_test_flag(&p->flags[1], SIP_PAGE2_USE_SRTP)) {
05597 if (ast_test_flag(&p->flags[0], SIP_REINVITE)) {
05598 ast_debug(1, "Direct media not possible when using SRTP, ignoring canreinvite setting\n");
05599 ast_clear_flag(&p->flags[0], SIP_REINVITE);
05600 }
05601
05602 if (p->rtp && !p->srtp && setup_srtp(&p->srtp) < 0) {
05603 ast_log(LOG_WARNING, "SRTP audio setup failed\n");
05604 return -1;
05605 }
05606
05607 if (p->vrtp && !p->vsrtp && setup_srtp(&p->vsrtp) < 0) {
05608 ast_log(LOG_WARNING, "SRTP video setup failed\n");
05609 return -1;
05610 }
05611
05612 if (p->trtp && !p->tsrtp && setup_srtp(&p->tsrtp) < 0) {
05613 ast_log(LOG_WARNING, "SRTP text setup failed\n");
05614 return -1;
05615 }
05616 }
05617
05618 res = 0;
05619 ast_set_flag(&p->flags[0], SIP_OUTGOING);
05620
05621
05622
05623
05624 ast_clear_flag(&p->flags[1], SIP_PAGE2_FAX_DETECT_T38);
05625
05626 if (p->options->transfer) {
05627 char buf[SIPBUFSIZE/2];
05628
05629 if (referer) {
05630 if (sipdebug)
05631 ast_debug(3, "Call for %s transfered by %s\n", p->username, referer);
05632 snprintf(buf, sizeof(buf)-1, "-> %s (via %s)", p->cid_name, referer);
05633 } else
05634 snprintf(buf, sizeof(buf)-1, "-> %s", p->cid_name);
05635 ast_string_field_set(p, cid_name, buf);
05636 }
05637 ast_debug(1, "Outgoing Call for %s\n", p->username);
05638
05639 res = update_call_counter(p, INC_CALL_RINGING);
05640
05641 if (res == -1) {
05642 ast->hangupcause = AST_CAUSE_USER_BUSY;
05643 return res;
05644 }
05645 p->callingpres = ast_party_id_presentation(&ast->caller.id);
05646 p->jointcapability = ast_rtp_instance_available_formats(p->rtp, p->capability, p->prefcodec);
05647 p->jointnoncodeccapability = p->noncodeccapability;
05648
05649
05650 if (!(p->jointcapability & AST_FORMAT_AUDIO_MASK)) {
05651 ast_log(LOG_WARNING, "No audio format found to offer. Cancelling call to %s\n", p->username);
05652 res = -1;
05653 } else {
05654 int xmitres;
05655 struct ast_party_connected_line connected;
05656 struct ast_set_party_connected_line update_connected;
05657
05658 sip_pvt_lock(p);
05659
05660
05661 memset(&update_connected, 0, sizeof(update_connected));
05662 ast_party_connected_line_init(&connected);
05663 if (!ast_strlen_zero(p->cid_num)
05664 || (p->callingpres & AST_PRES_RESTRICTION) != AST_PRES_ALLOWED) {
05665 update_connected.id.number = 1;
05666 connected.id.number.valid = 1;
05667 connected.id.number.str = (char *) p->cid_num;
05668 connected.id.number.presentation = p->callingpres;
05669 }
05670 if (!ast_strlen_zero(p->cid_name)
05671 || (p->callingpres & AST_PRES_RESTRICTION) != AST_PRES_ALLOWED) {
05672 update_connected.id.name = 1;
05673 connected.id.name.valid = 1;
05674 connected.id.name.str = (char *) p->cid_name;
05675 connected.id.name.presentation = p->callingpres;
05676 }
05677 if (update_connected.id.number || update_connected.id.name) {
05678 connected.id.tag = (char *) p->cid_tag;
05679 connected.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
05680 ast_channel_queue_connected_line_update(ast, &connected, &update_connected);
05681 }
05682
05683 xmitres = transmit_invite(p, SIP_INVITE, 1, 2, uri);
05684 sip_pvt_unlock(p);
05685 if (xmitres == XMIT_ERROR)
05686 return -1;
05687 p->invitestate = INV_CALLING;
05688
05689
05690 AST_SCHED_REPLACE_UNREF(p->initid, sched, p->timer_b, auto_congest, p,
05691 dialog_unref(_data, "dialog ptr dec when SCHED_REPLACE del op succeeded"),
05692 dialog_unref(p, "dialog ptr dec when SCHED_REPLACE add failed"),
05693 dialog_ref(p, "dialog ptr inc when SCHED_REPLACE add succeeded") );
05694 }
05695 return res;
05696 }
05697
05698
05699
05700 static void sip_registry_destroy(struct sip_registry *reg)
05701 {
05702
05703 ast_debug(3, "Destroying registry entry for %s@%s\n", reg->username, reg->hostname);
05704
05705 if (reg->call) {
05706
05707
05708 reg->call->registry = registry_unref(reg->call->registry, "destroy reg->call->registry");
05709 ast_debug(3, "Destroying active SIP dialog for registry %s@%s\n", reg->username, reg->hostname);
05710 dialog_unlink_all(reg->call);
05711 reg->call = dialog_unref(reg->call, "unref reg->call");
05712
05713 }
05714 AST_SCHED_DEL(sched, reg->expire);
05715 AST_SCHED_DEL(sched, reg->timeout);
05716
05717 ast_string_field_free_memory(reg);
05718 ast_atomic_fetchadd_int(®objs, -1);
05719 ast_free(reg);
05720 }
05721
05722
05723 static void sip_subscribe_mwi_destroy(struct sip_subscription_mwi *mwi)
05724 {
05725 if (mwi->call) {
05726 mwi->call->mwi = NULL;
05727 sip_destroy(mwi->call);
05728 }
05729
05730 AST_SCHED_DEL(sched, mwi->resub);
05731 ast_string_field_free_memory(mwi);
05732 ast_free(mwi);
05733 }
05734
05735
05736 void __sip_destroy(struct sip_pvt *p, int lockowner, int lockdialoglist)
05737 {
05738 struct sip_request *req;
05739
05740
05741 if (p->stimer) {
05742 p->stimer->quit_flag = 1;
05743 stop_session_timer(p);
05744 ast_free(p->stimer);
05745 p->stimer = NULL;
05746 }
05747
05748 if (sip_debug_test_pvt(p))
05749 ast_verbose("Really destroying SIP dialog '%s' Method: %s\n", p->callid, sip_methods[p->method].text);
05750
05751 if (ast_test_flag(&p->flags[0], SIP_INC_COUNT) || ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD)) {
05752 update_call_counter(p, DEC_CALL_LIMIT);
05753 ast_debug(2, "This call did not properly clean up call limits. Call ID %s\n", p->callid);
05754 }
05755
05756
05757 if (p->owner) {
05758 if (lockowner)
05759 ast_channel_lock(p->owner);
05760 ast_debug(1, "Detaching from %s\n", p->owner->name);
05761 p->owner->tech_pvt = NULL;
05762
05763 p->owner->_softhangup |= AST_SOFTHANGUP_DEV;
05764 if (lockowner)
05765 ast_channel_unlock(p->owner);
05766
05767 usleep(1);
05768 }
05769
05770
05771 if (p->relatedpeer && p->relatedpeer->mwipvt)
05772 p->relatedpeer->mwipvt = dialog_unref(p->relatedpeer->mwipvt, "delete ->relatedpeer->mwipvt");
05773 if (p->relatedpeer && p->relatedpeer->call == p)
05774 p->relatedpeer->call = dialog_unref(p->relatedpeer->call, "unset the relatedpeer->call field in tandem with relatedpeer field itself");
05775
05776 if (p->relatedpeer)
05777 p->relatedpeer = unref_peer(p->relatedpeer,"unsetting a dialog relatedpeer field in sip_destroy");
05778
05779 if (p->registry) {
05780 if (p->registry->call == p)
05781 p->registry->call = dialog_unref(p->registry->call, "nulling out the registry's call dialog field in unlink_all");
05782 p->registry = registry_unref(p->registry, "delete p->registry");
05783 }
05784
05785 if (p->mwi) {
05786 p->mwi->call = NULL;
05787 }
05788
05789 if (dumphistory)
05790 sip_dump_history(p);
05791
05792 if (p->options)
05793 ast_free(p->options);
05794
05795 if (p->notify) {
05796 ast_variables_destroy(p->notify->headers);
05797 ast_free(p->notify->content);
05798 ast_free(p->notify);
05799 }
05800 if (p->rtp) {
05801 ast_rtp_instance_destroy(p->rtp);
05802 }
05803 if (p->vrtp) {
05804 ast_rtp_instance_destroy(p->vrtp);
05805 }
05806 if (p->trtp) {
05807 ast_rtp_instance_destroy(p->trtp);
05808 }
05809 if (p->udptl)
05810 ast_udptl_destroy(p->udptl);
05811 if (p->refer)
05812 ast_free(p->refer);
05813 if (p->route) {
05814 free_old_route(p->route);
05815 p->route = NULL;
05816 }
05817 deinit_req(&p->initreq);
05818
05819
05820 if (p->history) {
05821 struct sip_history *hist;
05822 while ( (hist = AST_LIST_REMOVE_HEAD(p->history, list)) ) {
05823 ast_free(hist);
05824 p->history_entries--;
05825 }
05826 ast_free(p->history);
05827 p->history = NULL;
05828 }
05829
05830 while ((req = AST_LIST_REMOVE_HEAD(&p->request_queue, next))) {
05831 ast_free(req);
05832 }
05833
05834 if (p->chanvars) {
05835 ast_variables_destroy(p->chanvars);
05836 p->chanvars = NULL;
05837 }
05838
05839 if (p->srtp) {
05840 sip_srtp_destroy(p->srtp);
05841 p->srtp = NULL;
05842 }
05843
05844 if (p->vsrtp) {
05845 sip_srtp_destroy(p->vsrtp);
05846 p->vsrtp = NULL;
05847 }
05848
05849 if (p->tsrtp) {
05850 sip_srtp_destroy(p->tsrtp);
05851 p->tsrtp = NULL;
05852 }
05853
05854 if (p->directmediaha) {
05855 ast_free_ha(p->directmediaha);
05856 p->directmediaha = NULL;
05857 }
05858
05859 ast_string_field_free_memory(p);
05860
05861 ast_cc_config_params_destroy(p->cc_params);
05862
05863 if (p->epa_entry) {
05864 ao2_ref(p->epa_entry, -1);
05865 p->epa_entry = NULL;
05866 }
05867
05868 if (p->socket.tcptls_session) {
05869 ao2_ref(p->socket.tcptls_session, -1);
05870 p->socket.tcptls_session = NULL;
05871 }
05872
05873 if (p->peerauth) {
05874 ao2_t_ref(p->peerauth, -1, "Removing active peer authentication");
05875 p->peerauth = NULL;
05876 }
05877 }
05878
05879
05880
05881
05882
05883
05884
05885
05886
05887
05888
05889
05890
05891
05892
05893 static int update_call_counter(struct sip_pvt *fup, int event)
05894 {
05895 char name[256];
05896 int *inuse = NULL, *call_limit = NULL, *inringing = NULL;
05897 int outgoing = fup->outgoing_call;
05898 struct sip_peer *p = NULL;
05899
05900 ast_debug(3, "Updating call counter for %s call\n", outgoing ? "outgoing" : "incoming");
05901
05902
05903
05904
05905 if (!ast_test_flag(&fup->flags[0], SIP_CALL_LIMIT) && !ast_test_flag(&fup->flags[1], SIP_PAGE2_CALL_ONHOLD))
05906 return 0;
05907
05908 ast_copy_string(name, fup->username, sizeof(name));
05909
05910
05911 if (fup->relatedpeer) {
05912 p = ref_peer(fup->relatedpeer, "ref related peer for update_call_counter");
05913 inuse = &p->inUse;
05914 call_limit = &p->call_limit;
05915 inringing = &p->inRinging;
05916 ast_copy_string(name, fup->peername, sizeof(name));
05917 }
05918 if (!p) {
05919 ast_debug(2, "%s is not a local device, no call limit\n", name);
05920 return 0;
05921 }
05922
05923 switch(event) {
05924
05925 case DEC_CALL_LIMIT:
05926
05927 if (inuse) {
05928 sip_pvt_lock(fup);
05929 ao2_lock(p);
05930 if (*inuse > 0) {
05931 if (ast_test_flag(&fup->flags[0], SIP_INC_COUNT)) {
05932 (*inuse)--;
05933 ast_clear_flag(&fup->flags[0], SIP_INC_COUNT);
05934 }
05935 } else {
05936 *inuse = 0;
05937 }
05938 ao2_unlock(p);
05939 sip_pvt_unlock(fup);
05940 }
05941
05942
05943 if (inringing) {
05944 sip_pvt_lock(fup);
05945 ao2_lock(p);
05946 if (*inringing > 0) {
05947 if (ast_test_flag(&fup->flags[0], SIP_INC_RINGING)) {
05948 (*inringing)--;
05949 ast_clear_flag(&fup->flags[0], SIP_INC_RINGING);
05950 }
05951 } else {
05952 *inringing = 0;
05953 }
05954 ao2_unlock(p);
05955 sip_pvt_unlock(fup);
05956 }
05957
05958
05959 sip_pvt_lock(fup);
05960 ao2_lock(p);
05961 if (ast_test_flag(&fup->flags[1], SIP_PAGE2_CALL_ONHOLD) && sip_cfg.notifyhold) {
05962 ast_clear_flag(&fup->flags[1], SIP_PAGE2_CALL_ONHOLD);
05963 ao2_unlock(p);
05964 sip_pvt_unlock(fup);
05965 sip_peer_hold(fup, FALSE);
05966 } else {
05967 ao2_unlock(p);
05968 sip_pvt_unlock(fup);
05969 }
05970 if (sipdebug)
05971 ast_debug(2, "Call %s %s '%s' removed from call limit %d\n", outgoing ? "to" : "from", "peer", name, *call_limit);
05972 break;
05973
05974 case INC_CALL_RINGING:
05975 case INC_CALL_LIMIT:
05976
05977 if (*call_limit > 0 ) {
05978 if (*inuse >= *call_limit) {
05979 ast_log(LOG_NOTICE, "Call %s %s '%s' rejected due to usage limit of %d\n", outgoing ? "to" : "from", "peer", name, *call_limit);
05980 unref_peer(p, "update_call_counter: unref peer p, call limit exceeded");
05981 return -1;
05982 }
05983 }
05984 if (inringing && (event == INC_CALL_RINGING)) {
05985 sip_pvt_lock(fup);
05986 ao2_lock(p);
05987 if (!ast_test_flag(&fup->flags[0], SIP_INC_RINGING)) {
05988 (*inringing)++;
05989 ast_set_flag(&fup->flags[0], SIP_INC_RINGING);
05990 }
05991 ao2_unlock(p);
05992 sip_pvt_unlock(fup);
05993 }
05994 if (inuse) {
05995 sip_pvt_lock(fup);
05996 ao2_lock(p);
05997 if (!ast_test_flag(&fup->flags[0], SIP_INC_COUNT)) {
05998 (*inuse)++;
05999 ast_set_flag(&fup->flags[0], SIP_INC_COUNT);
06000 }
06001 ao2_unlock(p);
06002 sip_pvt_unlock(fup);
06003 }
06004 if (sipdebug) {
06005 ast_debug(2, "Call %s %s '%s' is %d out of %d\n", outgoing ? "to" : "from", "peer", name, *inuse, *call_limit);
06006 }
06007 break;
06008
06009 case DEC_CALL_RINGING:
06010 if (inringing) {
06011 sip_pvt_lock(fup);
06012 ao2_lock(p);
06013 if (ast_test_flag(&fup->flags[0], SIP_INC_RINGING)) {
06014 if (*inringing > 0) {
06015 (*inringing)--;
06016 }
06017 ast_clear_flag(&fup->flags[0], SIP_INC_RINGING);
06018 }
06019 ao2_unlock(p);
06020 sip_pvt_unlock(fup);
06021 }
06022 break;
06023
06024 default:
06025 ast_log(LOG_ERROR, "update_call_counter(%s, %d) called with no event!\n", name, event);
06026 }
06027
06028 if (p) {
06029 ast_devstate_changed(AST_DEVICE_UNKNOWN, "SIP/%s", p->name);
06030 unref_peer(p, "update_call_counter: unref_peer from call counter");
06031 }
06032 return 0;
06033 }
06034
06035
06036 static void sip_destroy_fn(void *p)
06037 {
06038 sip_destroy(p);
06039 }
06040
06041
06042
06043
06044
06045
06046 struct sip_pvt *sip_destroy(struct sip_pvt *p)
06047 {
06048 ast_debug(3, "Destroying SIP dialog %s\n", p->callid);
06049 __sip_destroy(p, TRUE, TRUE);
06050 return NULL;
06051 }
06052
06053
06054 int hangup_sip2cause(int cause)
06055 {
06056
06057
06058 switch(cause) {
06059 case 401:
06060 return AST_CAUSE_CALL_REJECTED;
06061 case 403:
06062 return AST_CAUSE_CALL_REJECTED;
06063 case 404:
06064 return AST_CAUSE_UNALLOCATED;
06065 case 405:
06066 return AST_CAUSE_INTERWORKING;
06067 case 407:
06068 return AST_CAUSE_CALL_REJECTED;
06069 case 408:
06070 return AST_CAUSE_NO_USER_RESPONSE;
06071 case 409:
06072 return AST_CAUSE_NORMAL_TEMPORARY_FAILURE;
06073 case 410:
06074 return AST_CAUSE_NUMBER_CHANGED;
06075 case 411:
06076 return AST_CAUSE_INTERWORKING;
06077 case 413:
06078 return AST_CAUSE_INTERWORKING;
06079 case 414:
06080 return AST_CAUSE_INTERWORKING;
06081 case 415:
06082 return AST_CAUSE_INTERWORKING;
06083 case 420:
06084 return AST_CAUSE_NO_ROUTE_DESTINATION;
06085 case 480:
06086 return AST_CAUSE_NO_ANSWER;
06087 case 481:
06088 return AST_CAUSE_INTERWORKING;
06089 case 482:
06090 return AST_CAUSE_INTERWORKING;
06091 case 483:
06092 return AST_CAUSE_NO_ANSWER;
06093 case 484:
06094 return AST_CAUSE_INVALID_NUMBER_FORMAT;
06095 case 485:
06096 return AST_CAUSE_UNALLOCATED;
06097 case 486:
06098 return AST_CAUSE_BUSY;
06099 case 487:
06100 return AST_CAUSE_INTERWORKING;
06101 case 488:
06102 return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
06103 case 491:
06104 return AST_CAUSE_INTERWORKING;
06105 case 493:
06106 return AST_CAUSE_INTERWORKING;
06107 case 500:
06108 return AST_CAUSE_FAILURE;
06109 case 501:
06110 return AST_CAUSE_FACILITY_REJECTED;
06111 case 502:
06112 return AST_CAUSE_DESTINATION_OUT_OF_ORDER;
06113 case 503:
06114 return AST_CAUSE_CONGESTION;
06115 case 504:
06116 return AST_CAUSE_RECOVERY_ON_TIMER_EXPIRE;
06117 case 505:
06118 return AST_CAUSE_INTERWORKING;
06119 case 600:
06120 return AST_CAUSE_USER_BUSY;
06121 case 603:
06122 return AST_CAUSE_CALL_REJECTED;
06123 case 604:
06124 return AST_CAUSE_UNALLOCATED;
06125 case 606:
06126 return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
06127 default:
06128 if (cause < 500 && cause >= 400) {
06129
06130 return AST_CAUSE_INTERWORKING;
06131 } else if (cause < 600 && cause >= 500) {
06132
06133 return AST_CAUSE_CONGESTION;
06134 } else if (cause < 700 && cause >= 600) {
06135
06136 return AST_CAUSE_INTERWORKING;
06137 }
06138 return AST_CAUSE_NORMAL;
06139 }
06140
06141 return 0;
06142 }
06143
06144
06145
06146
06147
06148
06149
06150
06151
06152
06153
06154
06155
06156
06157
06158
06159
06160
06161
06162
06163
06164
06165
06166
06167
06168
06169
06170
06171
06172
06173
06174
06175
06176 const char *hangup_cause2sip(int cause)
06177 {
06178 switch (cause) {
06179 case AST_CAUSE_UNALLOCATED:
06180 case AST_CAUSE_NO_ROUTE_DESTINATION:
06181 case AST_CAUSE_NO_ROUTE_TRANSIT_NET:
06182 return "404 Not Found";
06183 case AST_CAUSE_CONGESTION:
06184 case AST_CAUSE_SWITCH_CONGESTION:
06185 return "503 Service Unavailable";
06186 case AST_CAUSE_NO_USER_RESPONSE:
06187 return "408 Request Timeout";
06188 case AST_CAUSE_NO_ANSWER:
06189 case AST_CAUSE_UNREGISTERED:
06190 return "480 Temporarily unavailable";
06191 case AST_CAUSE_CALL_REJECTED:
06192 return "403 Forbidden";
06193 case AST_CAUSE_NUMBER_CHANGED:
06194 return "410 Gone";
06195 case AST_CAUSE_NORMAL_UNSPECIFIED:
06196 return "480 Temporarily unavailable";
06197 case AST_CAUSE_INVALID_NUMBER_FORMAT:
06198 return "484 Address incomplete";
06199 case AST_CAUSE_USER_BUSY:
06200 return "486 Busy here";
06201 case AST_CAUSE_FAILURE:
06202 return "500 Server internal failure";
06203 case AST_CAUSE_FACILITY_REJECTED:
06204 return "501 Not Implemented";
06205 case AST_CAUSE_CHAN_NOT_IMPLEMENTED:
06206 return "503 Service Unavailable";
06207
06208 case AST_CAUSE_DESTINATION_OUT_OF_ORDER:
06209 return "502 Bad Gateway";
06210 case AST_CAUSE_BEARERCAPABILITY_NOTAVAIL:
06211 return "488 Not Acceptable Here";
06212
06213 case AST_CAUSE_NOTDEFINED:
06214 default:
06215 ast_debug(1, "AST hangup cause %d (no match found in SIP)\n", cause);
06216 return NULL;
06217 }
06218
06219
06220 return 0;
06221 }
06222
06223
06224
06225 static int sip_hangup(struct ast_channel *ast)
06226 {
06227 struct sip_pvt *p = ast->tech_pvt;
06228 int needcancel = FALSE;
06229 int needdestroy = 0;
06230 struct ast_channel *oldowner = ast;
06231
06232 if (!p) {
06233 ast_debug(1, "Asked to hangup channel that was not connected\n");
06234 return 0;
06235 }
06236 if (ast_test_flag(ast, AST_FLAG_ANSWERED_ELSEWHERE) || ast->hangupcause == AST_CAUSE_ANSWERED_ELSEWHERE) {
06237 ast_debug(1, "This call was answered elsewhere");
06238 if (ast->hangupcause == AST_CAUSE_ANSWERED_ELSEWHERE) {
06239 ast_debug(1, "####### It's the cause code, buddy. The cause code!!!\n");
06240 }
06241 append_history(p, "Cancel", "Call answered elsewhere");
06242 p->answered_elsewhere = TRUE;
06243 }
06244
06245
06246 if (p->owner)
06247 p->hangupcause = p->owner->hangupcause;
06248
06249 if (ast_test_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER)) {
06250 if (ast_test_flag(&p->flags[0], SIP_INC_COUNT) || ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD)) {
06251 if (sipdebug)
06252 ast_debug(1, "update_call_counter(%s) - decrement call limit counter on hangup\n", p->username);
06253 update_call_counter(p, DEC_CALL_LIMIT);
06254 }
06255 ast_debug(4, "SIP Transfer: Not hanging up right now... Rescheduling hangup for %s.\n", p->callid);
06256 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
06257 ast_clear_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER);
06258 p->needdestroy = 0;
06259 p->owner->tech_pvt = dialog_unref(p->owner->tech_pvt, "unref p->owner->tech_pvt");
06260 sip_pvt_lock(p);
06261 p->owner = NULL;
06262 sip_pvt_unlock(p);
06263 ast_module_unref(ast_module_info->self);
06264 return 0;
06265 }
06266
06267 if (ast_test_flag(ast, AST_FLAG_ZOMBIE)) {
06268 if (p->refer)
06269 ast_debug(1, "SIP Transfer: Hanging up Zombie channel %s after transfer ... Call-ID: %s\n", ast->name, p->callid);
06270 else
06271 ast_debug(1, "Hanging up zombie call. Be scared.\n");
06272 } else
06273 ast_debug(1, "Hangup call %s, SIP callid %s\n", ast->name, p->callid);
06274
06275 sip_pvt_lock(p);
06276 if (ast_test_flag(&p->flags[0], SIP_INC_COUNT) || ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD)) {
06277 if (sipdebug)
06278 ast_debug(1, "update_call_counter(%s) - decrement call limit counter on hangup\n", p->username);
06279 update_call_counter(p, DEC_CALL_LIMIT);
06280 }
06281
06282
06283 if (p->owner != ast) {
06284 ast_log(LOG_WARNING, "Huh? We aren't the owner? Can't hangup call.\n");
06285 sip_pvt_unlock(p);
06286 return 0;
06287 }
06288
06289
06290 if (p->invitestate < INV_COMPLETED && p->owner->_state != AST_STATE_UP) {
06291 needcancel = TRUE;
06292 ast_debug(4, "Hanging up channel in state %s (not UP)\n", ast_state2str(ast->_state));
06293 }
06294
06295 stop_media_flows(p);
06296
06297 append_history(p, needcancel ? "Cancel" : "Hangup", "Cause %s", p->owner ? ast_cause2str(p->hangupcause) : "Unknown");
06298
06299
06300 disable_dsp_detect(p);
06301
06302 p->owner = NULL;
06303 ast->tech_pvt = dialog_unref(ast->tech_pvt, "unref ast->tech_pvt");
06304
06305 ast_module_unref(ast_module_info->self);
06306
06307
06308
06309
06310
06311
06312 if (p->alreadygone)
06313 needdestroy = 1;
06314 else if (p->invitestate != INV_CALLING)
06315 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
06316
06317
06318 if (!p->alreadygone && p->initreq.data && !ast_strlen_zero(p->initreq.data->str)) {
06319 if (needcancel) {
06320 if (ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
06321
06322 if (p->invitestate == INV_CALLING) {
06323
06324 ast_set_flag(&p->flags[0], SIP_PENDINGBYE);
06325
06326 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
06327 append_history(p, "DELAY", "Not sending cancel, waiting for timeout");
06328 } else {
06329 struct sip_pkt *cur;
06330
06331 for (cur = p->packets; cur; cur = cur->next) {
06332 __sip_semi_ack(p, cur->seqno, cur->is_resp, cur->method ? cur->method : find_sip_method(cur->data->str));
06333 }
06334 p->invitestate = INV_CANCELLED;
06335
06336 transmit_request(p, SIP_CANCEL, p->lastinvite, XMIT_RELIABLE, FALSE);
06337
06338
06339 needdestroy = 0;
06340 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
06341 }
06342 } else {
06343 const char *res;
06344 AST_SCHED_DEL_UNREF(sched, p->provisional_keepalive_sched_id, dialog_unref(p, "when you delete the provisional_keepalive_sched_id, you should dec the refcount for the stored dialog ptr"));
06345 if (p->hangupcause && (res = hangup_cause2sip(p->hangupcause)))
06346 transmit_response_reliable(p, res, &p->initreq);
06347 else
06348 transmit_response_reliable(p, "603 Declined", &p->initreq);
06349 p->invitestate = INV_TERMINATED;
06350 }
06351 } else {
06352 if (p->stimer->st_active == TRUE) {
06353 stop_session_timer(p);
06354 }
06355
06356 if (!p->pendinginvite) {
06357 struct ast_channel *bridge = ast_bridged_channel(oldowner);
06358 char quality_buf[AST_MAX_USER_FIELD], *quality;
06359
06360
06361
06362
06363 while (bridge && ast_channel_trylock(bridge)) {
06364 sip_pvt_unlock(p);
06365 do {
06366 CHANNEL_DEADLOCK_AVOIDANCE(oldowner);
06367 } while (sip_pvt_trylock(p));
06368 bridge = ast_bridged_channel(oldowner);
06369 }
06370
06371 if (p->rtp) {
06372 ast_rtp_instance_set_stats_vars(oldowner, p->rtp);
06373 }
06374
06375 if (bridge) {
06376 struct sip_pvt *q = bridge->tech_pvt;
06377
06378 if (IS_SIP_TECH(bridge->tech) && q && q->rtp) {
06379 ast_rtp_instance_set_stats_vars(bridge, q->rtp);
06380 }
06381 ast_channel_unlock(bridge);
06382 }
06383
06384 if (p->do_history || oldowner) {
06385 if (p->rtp && (quality = ast_rtp_instance_get_quality(p->rtp, AST_RTP_INSTANCE_STAT_FIELD_QUALITY, quality_buf, sizeof(quality_buf)))) {
06386 if (p->do_history) {
06387 append_history(p, "RTCPaudio", "Quality:%s", quality);
06388 }
06389 if (oldowner) {
06390 pbx_builtin_setvar_helper(oldowner, "RTPAUDIOQOS", quality);
06391 }
06392 }
06393 if (p->vrtp && (quality = ast_rtp_instance_get_quality(p->vrtp, AST_RTP_INSTANCE_STAT_FIELD_QUALITY, quality_buf, sizeof(quality_buf)))) {
06394 if (p->do_history) {
06395 append_history(p, "RTCPvideo", "Quality:%s", quality);
06396 }
06397 if (oldowner) {
06398 pbx_builtin_setvar_helper(oldowner, "RTPVIDEOQOS", quality);
06399 }
06400 }
06401 if (p->trtp && (quality = ast_rtp_instance_get_quality(p->trtp, AST_RTP_INSTANCE_STAT_FIELD_QUALITY, quality_buf, sizeof(quality_buf)))) {
06402 if (p->do_history) {
06403 append_history(p, "RTCPtext", "Quality:%s", quality);
06404 }
06405 if (oldowner) {
06406 pbx_builtin_setvar_helper(oldowner, "RTPTEXTQOS", quality);
06407 }
06408 }
06409 }
06410
06411
06412 if (oldowner->_state == AST_STATE_UP) {
06413 transmit_request_with_auth(p, SIP_BYE, 0, XMIT_RELIABLE, 1);
06414 }
06415
06416 } else {
06417
06418
06419 ast_set_flag(&p->flags[0], SIP_PENDINGBYE);
06420 ast_clear_flag(&p->flags[0], SIP_NEEDREINVITE);
06421 AST_SCHED_DEL_UNREF(sched, p->waitid, dialog_unref(p, "when you delete the waitid sched, you should dec the refcount for the stored dialog ptr"));
06422 if (sip_cancel_destroy(p))
06423 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
06424 }
06425 }
06426 }
06427 if (needdestroy) {
06428 pvt_set_needdestroy(p, "hangup");
06429 }
06430 sip_pvt_unlock(p);
06431 return 0;
06432 }
06433
06434
06435 static void try_suggested_sip_codec(struct sip_pvt *p)
06436 {
06437 format_t fmt;
06438 const char *codec;
06439
06440 if (p->outgoing_call) {
06441 codec = pbx_builtin_getvar_helper(p->owner, "SIP_CODEC_OUTBOUND");
06442 } else if (!(codec = pbx_builtin_getvar_helper(p->owner, "SIP_CODEC_INBOUND"))) {
06443 codec = pbx_builtin_getvar_helper(p->owner, "SIP_CODEC");
06444 }
06445
06446 if (!codec)
06447 return;
06448
06449 fmt = ast_getformatbyname(codec);
06450 if (fmt) {
06451 ast_log(LOG_NOTICE, "Changing codec to '%s' for this call because of ${SIP_CODEC} variable\n", codec);
06452 if (p->jointcapability & fmt) {
06453 p->jointcapability &= fmt;
06454 p->capability &= fmt;
06455 } else
06456 ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because it is not shared by both ends.\n");
06457 } else
06458 ast_log(LOG_NOTICE, "Ignoring ${SIP_CODEC} variable because of unrecognized/not configured codec (check allow/disallow in sip.conf): %s\n", codec);
06459 return;
06460 }
06461
06462
06463
06464 static int sip_answer(struct ast_channel *ast)
06465 {
06466 int res = 0;
06467 struct sip_pvt *p = ast->tech_pvt;
06468
06469 sip_pvt_lock(p);
06470 if (ast->_state != AST_STATE_UP) {
06471 try_suggested_sip_codec(p);
06472
06473 ast_setstate(ast, AST_STATE_UP);
06474 ast_debug(1, "SIP answering channel: %s\n", ast->name);
06475 ast_rtp_instance_update_source(p->rtp);
06476 res = transmit_response_with_sdp(p, "200 OK", &p->initreq, XMIT_CRITICAL, FALSE, TRUE);
06477 ast_set_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
06478 }
06479 sip_pvt_unlock(p);
06480 return res;
06481 }
06482
06483
06484 static int sip_write(struct ast_channel *ast, struct ast_frame *frame)
06485 {
06486 struct sip_pvt *p = ast->tech_pvt;
06487 int res = 0;
06488
06489 switch (frame->frametype) {
06490 case AST_FRAME_VOICE:
06491 if (!(frame->subclass.codec & ast->nativeformats)) {
06492 char s1[512], s2[512], s3[512];
06493 ast_log(LOG_WARNING, "Asked to transmit frame type %s, while native formats is %s read/write = %s/%s\n",
06494 ast_getformatname(frame->subclass.codec),
06495 ast_getformatname_multiple(s1, sizeof(s1), ast->nativeformats & AST_FORMAT_AUDIO_MASK),
06496 ast_getformatname_multiple(s2, sizeof(s2), ast->readformat),
06497 ast_getformatname_multiple(s3, sizeof(s3), ast->writeformat));
06498 return 0;
06499 }
06500 if (p) {
06501 sip_pvt_lock(p);
06502 if (p->t38.state == T38_ENABLED) {
06503
06504 sip_pvt_unlock(p);
06505 break;
06506 } else if (p->rtp) {
06507
06508 if ((ast->_state != AST_STATE_UP) &&
06509 !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
06510 !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
06511 ast_rtp_instance_update_source(p->rtp);
06512 if (!global_prematuremediafilter) {
06513 p->invitestate = INV_EARLY_MEDIA;
06514 transmit_provisional_response(p, "183 Session Progress", &p->initreq, TRUE);
06515 ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);
06516 }
06517 }
06518 p->lastrtptx = time(NULL);
06519 res = ast_rtp_instance_write(p->rtp, frame);
06520 }
06521 sip_pvt_unlock(p);
06522 }
06523 break;
06524 case AST_FRAME_VIDEO:
06525 if (p) {
06526 sip_pvt_lock(p);
06527 if (p->vrtp) {
06528
06529 if ((ast->_state != AST_STATE_UP) &&
06530 !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
06531 !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
06532 p->invitestate = INV_EARLY_MEDIA;
06533 transmit_provisional_response(p, "183 Session Progress", &p->initreq, TRUE);
06534 ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);
06535 }
06536 p->lastrtptx = time(NULL);
06537 res = ast_rtp_instance_write(p->vrtp, frame);
06538 }
06539 sip_pvt_unlock(p);
06540 }
06541 break;
06542 case AST_FRAME_TEXT:
06543 if (p) {
06544 sip_pvt_lock(p);
06545 if (p->red) {
06546 ast_rtp_red_buffer(p->trtp, frame);
06547 } else {
06548 if (p->trtp) {
06549
06550 if ((ast->_state != AST_STATE_UP) &&
06551 !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
06552 !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
06553 p->invitestate = INV_EARLY_MEDIA;
06554 transmit_provisional_response(p, "183 Session Progress", &p->initreq, TRUE);
06555 ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);
06556 }
06557 p->lastrtptx = time(NULL);
06558 res = ast_rtp_instance_write(p->trtp, frame);
06559 }
06560 }
06561 sip_pvt_unlock(p);
06562 }
06563 break;
06564 case AST_FRAME_IMAGE:
06565 return 0;
06566 break;
06567 case AST_FRAME_MODEM:
06568 if (p) {
06569 sip_pvt_lock(p);
06570
06571
06572
06573
06574 if ((ast->_state == AST_STATE_UP) &&
06575 p->udptl &&
06576 (p->t38.state == T38_ENABLED)) {
06577 res = ast_udptl_write(p->udptl, frame);
06578 }
06579 sip_pvt_unlock(p);
06580 }
06581 break;
06582 default:
06583 ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", frame->frametype);
06584 return 0;
06585 }
06586
06587 return res;
06588 }
06589
06590
06591
06592 static int sip_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
06593 {
06594 int ret = -1;
06595 struct sip_pvt *p;
06596
06597 if (newchan && ast_test_flag(newchan, AST_FLAG_ZOMBIE))
06598 ast_debug(1, "New channel is zombie\n");
06599 if (oldchan && ast_test_flag(oldchan, AST_FLAG_ZOMBIE))
06600 ast_debug(1, "Old channel is zombie\n");
06601
06602 if (!newchan || !newchan->tech_pvt) {
06603 if (!newchan)
06604 ast_log(LOG_WARNING, "No new channel! Fixup of %s failed.\n", oldchan->name);
06605 else
06606 ast_log(LOG_WARNING, "No SIP tech_pvt! Fixup of %s failed.\n", oldchan->name);
06607 return -1;
06608 }
06609 p = newchan->tech_pvt;
06610
06611 sip_pvt_lock(p);
06612 append_history(p, "Masq", "Old channel: %s\n", oldchan->name);
06613 append_history(p, "Masq (cont)", "...new owner: %s\n", newchan->name);
06614 if (p->owner != oldchan)
06615 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, p->owner);
06616 else {
06617 p->owner = newchan;
06618
06619
06620
06621
06622
06623
06624 sip_set_rtp_peer(newchan, NULL, NULL, 0, 0, 0);
06625 ret = 0;
06626 }
06627 ast_debug(3, "SIP Fixup: New owner for dialogue %s: %s (Old parent: %s)\n", p->callid, p->owner->name, oldchan->name);
06628
06629 sip_pvt_unlock(p);
06630 return ret;
06631 }
06632
06633 static int sip_senddigit_begin(struct ast_channel *ast, char digit)
06634 {
06635 struct sip_pvt *p = ast->tech_pvt;
06636 int res = 0;
06637
06638 sip_pvt_lock(p);
06639 switch (ast_test_flag(&p->flags[0], SIP_DTMF)) {
06640 case SIP_DTMF_INBAND:
06641 res = -1;
06642 break;
06643 case SIP_DTMF_RFC2833:
06644 if (p->rtp)
06645 ast_rtp_instance_dtmf_begin(p->rtp, digit);
06646 break;
06647 default:
06648 break;
06649 }
06650 sip_pvt_unlock(p);
06651
06652 return res;
06653 }
06654
06655
06656
06657 static int sip_senddigit_end(struct ast_channel *ast, char digit, unsigned int duration)
06658 {
06659 struct sip_pvt *p = ast->tech_pvt;
06660 int res = 0;
06661
06662 sip_pvt_lock(p);
06663 switch (ast_test_flag(&p->flags[0], SIP_DTMF)) {
06664 case SIP_DTMF_INFO:
06665 case SIP_DTMF_SHORTINFO:
06666 transmit_info_with_digit(p, digit, duration);
06667 break;
06668 case SIP_DTMF_RFC2833:
06669 if (p->rtp)
06670 ast_rtp_instance_dtmf_end_with_duration(p->rtp, digit, duration);
06671 break;
06672 case SIP_DTMF_INBAND:
06673 res = -1;
06674 break;
06675 }
06676 sip_pvt_unlock(p);
06677
06678 return res;
06679 }
06680
06681
06682 static int sip_transfer(struct ast_channel *ast, const char *dest)
06683 {
06684 struct sip_pvt *p = ast->tech_pvt;
06685 int res;
06686
06687 if (dest == NULL)
06688 dest = "";
06689 sip_pvt_lock(p);
06690 if (ast->_state == AST_STATE_RING)
06691 res = sip_sipredirect(p, dest);
06692 else
06693 res = transmit_refer(p, dest);
06694 sip_pvt_unlock(p);
06695 return res;
06696 }
06697
06698
06699 static int interpret_t38_parameters(struct sip_pvt *p, const struct ast_control_t38_parameters *parameters)
06700 {
06701 int res = 0;
06702
06703 if (!ast_test_flag(&p->flags[1], SIP_PAGE2_T38SUPPORT) || !p->udptl) {
06704 return -1;
06705 }
06706 switch (parameters->request_response) {
06707 case AST_T38_NEGOTIATED:
06708 case AST_T38_REQUEST_NEGOTIATE:
06709
06710 if (!parameters->max_ifp) {
06711 change_t38_state(p, T38_DISABLED);
06712 if (p->t38.state == T38_PEER_REINVITE) {
06713 AST_SCHED_DEL_UNREF(sched, p->t38id, dialog_unref(p, "when you delete the t38id sched, you should dec the refcount for the stored dialog ptr"));
06714 transmit_response_reliable(p, "488 Not acceptable here", &p->initreq);
06715 }
06716 break;
06717 } else if (p->t38.state == T38_PEER_REINVITE) {
06718 AST_SCHED_DEL_UNREF(sched, p->t38id, dialog_unref(p, "when you delete the t38id sched, you should dec the refcount for the stored dialog ptr"));
06719 p->t38.our_parms = *parameters;
06720
06721
06722
06723 if (!p->t38.their_parms.fill_bit_removal) {
06724 p->t38.our_parms.fill_bit_removal = FALSE;
06725 }
06726 if (!p->t38.their_parms.transcoding_mmr) {
06727 p->t38.our_parms.transcoding_mmr = FALSE;
06728 }
06729 if (!p->t38.their_parms.transcoding_jbig) {
06730 p->t38.our_parms.transcoding_jbig = FALSE;
06731 }
06732 p->t38.our_parms.version = MIN(p->t38.our_parms.version, p->t38.their_parms.version);
06733 p->t38.our_parms.rate_management = p->t38.their_parms.rate_management;
06734 ast_udptl_set_local_max_ifp(p->udptl, p->t38.our_parms.max_ifp);
06735 change_t38_state(p, T38_ENABLED);
06736 transmit_response_with_t38_sdp(p, "200 OK", &p->initreq, XMIT_CRITICAL);
06737 } else if (p->t38.state != T38_ENABLED) {
06738 p->t38.our_parms = *parameters;
06739 ast_udptl_set_local_max_ifp(p->udptl, p->t38.our_parms.max_ifp);
06740 change_t38_state(p, T38_LOCAL_REINVITE);
06741 if (!p->pendinginvite) {
06742 transmit_reinvite_with_sdp(p, TRUE, FALSE);
06743 } else if (!ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
06744 ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
06745 }
06746 }
06747 break;
06748 case AST_T38_TERMINATED:
06749 case AST_T38_REFUSED:
06750 case AST_T38_REQUEST_TERMINATE:
06751 if (p->t38.state == T38_PEER_REINVITE) {
06752 AST_SCHED_DEL_UNREF(sched, p->t38id, dialog_unref(p, "when you delete the t38id sched, you should dec the refcount for the stored dialog ptr"));
06753 change_t38_state(p, T38_DISABLED);
06754 transmit_response_reliable(p, "488 Not acceptable here", &p->initreq);
06755 } else if (p->t38.state == T38_ENABLED)
06756 transmit_reinvite_with_sdp(p, FALSE, FALSE);
06757 break;
06758 case AST_T38_REQUEST_PARMS: {
06759 struct ast_control_t38_parameters parameters = p->t38.their_parms;
06760
06761 if (p->t38.state == T38_PEER_REINVITE) {
06762 AST_SCHED_DEL_UNREF(sched, p->t38id, dialog_unref(p, "when you delete the t38id sched, you should dec the refcount for the stored dialog ptr"));
06763 parameters.max_ifp = ast_udptl_get_far_max_ifp(p->udptl);
06764 parameters.request_response = AST_T38_REQUEST_NEGOTIATE;
06765 ast_queue_control_data(p->owner, AST_CONTROL_T38_PARAMETERS, ¶meters, sizeof(parameters));
06766
06767
06768
06769
06770 res = AST_T38_REQUEST_PARMS;
06771 }
06772 break;
06773 }
06774 default:
06775 res = -1;
06776 break;
06777 }
06778
06779 return res;
06780 }
06781
06782
06783
06784
06785
06786
06787
06788
06789
06790
06791 static int initialize_udptl(struct sip_pvt *p)
06792 {
06793 int natflags = ast_test_flag(&p->flags[1], SIP_PAGE2_SYMMETRICRTP);
06794
06795 if (!ast_test_flag(&p->flags[1], SIP_PAGE2_T38SUPPORT)) {
06796 return 1;
06797 }
06798
06799
06800 if (p->udptl) {
06801 return 0;
06802 }
06803
06804
06805 if ((p->udptl = ast_udptl_new_with_bindaddr(sched, io, 0, &bindaddr))) {
06806 if (p->owner) {
06807 ast_channel_set_fd(p->owner, 5, ast_udptl_fd(p->udptl));
06808 }
06809
06810 ast_udptl_setqos(p->udptl, global_tos_audio, global_cos_audio);
06811 p->t38_maxdatagram = p->relatedpeer ? p->relatedpeer->t38_maxdatagram : global_t38_maxdatagram;
06812 set_t38_capabilities(p);
06813
06814 ast_debug(1, "Setting NAT on UDPTL to %s\n", natflags ? "On" : "Off");
06815 ast_udptl_setnat(p->udptl, natflags);
06816 } else {
06817 ast_log(AST_LOG_WARNING, "UDPTL creation failed - disabling T38 for this dialog\n");
06818 ast_clear_flag(&p->flags[1], SIP_PAGE2_T38SUPPORT);
06819 return 1;
06820 }
06821
06822 return 0;
06823 }
06824
06825
06826
06827
06828
06829
06830 static int sip_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen)
06831 {
06832 struct sip_pvt *p = ast->tech_pvt;
06833 int res = 0;
06834
06835 sip_pvt_lock(p);
06836 switch(condition) {
06837 case AST_CONTROL_RINGING:
06838 if (ast->_state == AST_STATE_RING) {
06839 p->invitestate = INV_EARLY_MEDIA;
06840 if (!ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) ||
06841 (ast_test_flag(&p->flags[0], SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER)) {
06842
06843 transmit_provisional_response(p, "180 Ringing", &p->initreq, 0);
06844 ast_set_flag(&p->flags[0], SIP_RINGING);
06845 if (ast_test_flag(&p->flags[0], SIP_PROG_INBAND) != SIP_PROG_INBAND_YES)
06846 break;
06847 } else {
06848
06849 }
06850 }
06851 res = -1;
06852 break;
06853 case AST_CONTROL_BUSY:
06854 if (ast->_state != AST_STATE_UP) {
06855 transmit_response_reliable(p, "486 Busy Here", &p->initreq);
06856 p->invitestate = INV_COMPLETED;
06857 sip_alreadygone(p);
06858 ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
06859 break;
06860 }
06861 res = -1;
06862 break;
06863 case AST_CONTROL_CONGESTION:
06864 if (ast->_state != AST_STATE_UP) {
06865 transmit_response_reliable(p, "503 Service Unavailable", &p->initreq);
06866 p->invitestate = INV_COMPLETED;
06867 sip_alreadygone(p);
06868 ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
06869 break;
06870 }
06871 res = -1;
06872 break;
06873 case AST_CONTROL_INCOMPLETE:
06874 if (ast->_state != AST_STATE_UP) {
06875 switch (ast_test_flag(&p->flags[1], SIP_PAGE2_ALLOWOVERLAP)) {
06876 case SIP_PAGE2_ALLOWOVERLAP_YES:
06877 transmit_response_reliable(p, "484 Address Incomplete", &p->initreq);
06878 p->invitestate = INV_COMPLETED;
06879 sip_alreadygone(p);
06880 ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
06881 break;
06882 case SIP_PAGE2_ALLOWOVERLAP_DTMF:
06883
06884 break;
06885 default:
06886
06887 transmit_response_reliable(p, "404 Not Found", &p->initreq);
06888 p->invitestate = INV_COMPLETED;
06889 sip_alreadygone(p);
06890 ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
06891 break;
06892 }
06893 }
06894 break;
06895 case AST_CONTROL_PROCEEDING:
06896 if ((ast->_state != AST_STATE_UP) &&
06897 !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
06898 !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
06899 transmit_response(p, "100 Trying", &p->initreq);
06900 p->invitestate = INV_PROCEEDING;
06901 break;
06902 }
06903 res = -1;
06904 break;
06905 case AST_CONTROL_PROGRESS:
06906 if ((ast->_state != AST_STATE_UP) &&
06907 !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT) &&
06908 !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
06909 p->invitestate = INV_EARLY_MEDIA;
06910 transmit_provisional_response(p, "183 Session Progress", &p->initreq, TRUE);
06911 ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);
06912 break;
06913 }
06914 res = -1;
06915 break;
06916 case AST_CONTROL_HOLD:
06917 ast_rtp_instance_update_source(p->rtp);
06918 ast_moh_start(ast, data, p->mohinterpret);
06919 break;
06920 case AST_CONTROL_UNHOLD:
06921 ast_rtp_instance_update_source(p->rtp);
06922 ast_moh_stop(ast);
06923 break;
06924 case AST_CONTROL_VIDUPDATE:
06925 if (p->vrtp && !p->novideo) {
06926 transmit_info_with_vidupdate(p);
06927
06928 } else
06929 res = -1;
06930 break;
06931 case AST_CONTROL_T38_PARAMETERS:
06932 res = -1;
06933 if (datalen != sizeof(struct ast_control_t38_parameters)) {
06934 ast_log(LOG_ERROR, "Invalid datalen for AST_CONTROL_T38_PARAMETERS. Expected %d, got %d\n", (int) sizeof(struct ast_control_t38_parameters), (int) datalen);
06935 } else {
06936 const struct ast_control_t38_parameters *parameters = data;
06937 if (!initialize_udptl(p)) {
06938 res = interpret_t38_parameters(p, parameters);
06939 }
06940 }
06941 break;
06942 case AST_CONTROL_SRCUPDATE:
06943 ast_rtp_instance_update_source(p->rtp);
06944 break;
06945 case AST_CONTROL_SRCCHANGE:
06946 ast_rtp_instance_change_source(p->rtp);
06947 break;
06948 case AST_CONTROL_CONNECTED_LINE:
06949 update_connectedline(p, data, datalen);
06950 break;
06951 case AST_CONTROL_REDIRECTING:
06952 update_redirecting(p, data, datalen);
06953 break;
06954 case AST_CONTROL_AOC:
06955 {
06956 struct ast_aoc_decoded *decoded = ast_aoc_decode((struct ast_aoc_encoded *) data, datalen, ast);
06957 if (!decoded) {
06958 ast_log(LOG_ERROR, "Error decoding indicated AOC data\n");
06959 res = -1;
06960 break;
06961 }
06962 switch (ast_aoc_get_msg_type(decoded)) {
06963 case AST_AOC_REQUEST:
06964 if (ast_aoc_get_termination_request(decoded)) {
06965
06966
06967
06968
06969
06970
06971
06972 ast_debug(1, "AOC-E termination request received on %s. This is not yet supported on sip. Continue with hangup \n", p->owner->name);
06973 ast_softhangup_nolock(p->owner, AST_SOFTHANGUP_DEV);
06974 }
06975 break;
06976 case AST_AOC_D:
06977 case AST_AOC_E:
06978 if (ast_test_flag(&p->flags[2], SIP_PAGE3_SNOM_AOC)) {
06979 transmit_info_with_aoc(p, decoded);
06980 }
06981 break;
06982 case AST_AOC_S:
06983 default:
06984 break;
06985 }
06986 ast_aoc_destroy_decoded(decoded);
06987 }
06988 break;
06989 case AST_CONTROL_UPDATE_RTP_PEER:
06990 break;
06991 case -1:
06992 res = -1;
06993 break;
06994 default:
06995 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", condition);
06996 res = -1;
06997 break;
06998 }
06999 sip_pvt_unlock(p);
07000 return res;
07001 }
07002
07003
07004
07005
07006
07007
07008
07009
07010
07011
07012
07013
07014 static struct ast_channel *sip_new(struct sip_pvt *i, int state, const char *title, const char *linkedid)
07015 {
07016 struct ast_channel *tmp;
07017 struct ast_variable *v = NULL;
07018 format_t fmt;
07019 format_t what;
07020 format_t video;
07021 format_t text;
07022 format_t needvideo = 0;
07023 int needtext = 0;
07024 char buf[SIPBUFSIZE];
07025 char *exten;
07026
07027 {
07028 const char *my_name;
07029
07030 if (title) {
07031 my_name = title;
07032 } else {
07033 my_name = ast_strdupa(i->fromdomain);
07034 }
07035
07036 sip_pvt_unlock(i);
07037
07038 tmp = ast_channel_alloc(1, state, i->cid_num, i->cid_name, i->accountcode, i->exten, i->context, linkedid, i->amaflags, "SIP/%s-%08x", my_name, ast_atomic_fetchadd_int((int *)&chan_idx, +1));
07039 }
07040 if (!tmp) {
07041 ast_log(LOG_WARNING, "Unable to allocate AST channel structure for SIP channel\n");
07042 sip_pvt_lock(i);
07043 return NULL;
07044 }
07045 ast_channel_lock(tmp);
07046 sip_pvt_lock(i);
07047 ast_channel_cc_params_init(tmp, i->cc_params);
07048 tmp->caller.id.tag = ast_strdup(i->cid_tag);
07049
07050 tmp->tech = ( ast_test_flag(&i->flags[0], SIP_DTMF) == SIP_DTMF_INFO || ast_test_flag(&i->flags[0], SIP_DTMF) == SIP_DTMF_SHORTINFO) ? &sip_tech_info : &sip_tech;
07051
07052
07053
07054 if (i->jointcapability) {
07055 what = i->jointcapability;
07056 video = i->jointcapability & AST_FORMAT_VIDEO_MASK;
07057 text = i->jointcapability & AST_FORMAT_TEXT_MASK;
07058 } else if (i->capability) {
07059 what = i->capability;
07060 video = i->capability & AST_FORMAT_VIDEO_MASK;
07061 text = i->capability & AST_FORMAT_TEXT_MASK;
07062 } else {
07063 what = sip_cfg.capability;
07064 video = sip_cfg.capability & AST_FORMAT_VIDEO_MASK;
07065 text = sip_cfg.capability & AST_FORMAT_TEXT_MASK;
07066 }
07067
07068
07069 tmp->nativeformats = ast_codec_choose(&i->prefs, what, 1) | video | text;
07070 ast_debug(3, "*** Our native formats are %s \n", ast_getformatname_multiple(buf, SIPBUFSIZE, tmp->nativeformats));
07071 ast_debug(3, "*** Joint capabilities are %s \n", ast_getformatname_multiple(buf, SIPBUFSIZE, i->jointcapability));
07072 ast_debug(3, "*** Our capabilities are %s \n", ast_getformatname_multiple(buf, SIPBUFSIZE, i->capability));
07073 ast_debug(3, "*** AST_CODEC_CHOOSE formats are %s \n", ast_getformatname_multiple(buf, SIPBUFSIZE, ast_codec_choose(&i->prefs, what, 1)));
07074 if (i->prefcodec)
07075 ast_debug(3, "*** Our preferred formats from the incoming channel are %s \n", ast_getformatname_multiple(buf, SIPBUFSIZE, i->prefcodec));
07076
07077
07078 fmt = ast_best_codec(tmp->nativeformats);
07079
07080
07081
07082
07083
07084 if (i->vrtp) {
07085 if (ast_test_flag(&i->flags[1], SIP_PAGE2_VIDEOSUPPORT))
07086 needvideo = AST_FORMAT_VIDEO_MASK;
07087 else if (i->prefcodec)
07088 needvideo = i->prefcodec & AST_FORMAT_VIDEO_MASK;
07089 else
07090 needvideo = i->jointcapability & AST_FORMAT_VIDEO_MASK;
07091 }
07092
07093 if (i->trtp) {
07094 if (i->prefcodec)
07095 needtext = i->prefcodec & AST_FORMAT_TEXT_MASK;
07096 else
07097 needtext = i->jointcapability & AST_FORMAT_TEXT_MASK;
07098 }
07099
07100 if (needvideo)
07101 ast_debug(3, "This channel can handle video! HOLLYWOOD next!\n");
07102 else
07103 ast_debug(3, "This channel will not be able to handle video.\n");
07104
07105 enable_dsp_detect(i);
07106
07107 if ((ast_test_flag(&i->flags[0], SIP_DTMF) == SIP_DTMF_INBAND) ||
07108 (ast_test_flag(&i->flags[0], SIP_DTMF) == SIP_DTMF_AUTO)) {
07109 if (i->rtp) {
07110 ast_rtp_instance_dtmf_mode_set(i->rtp, AST_RTP_DTMF_MODE_INBAND);
07111 }
07112 } else if (ast_test_flag(&i->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) {
07113 if (i->rtp) {
07114 ast_rtp_instance_dtmf_mode_set(i->rtp, AST_RTP_DTMF_MODE_RFC2833);
07115 }
07116 }
07117
07118
07119
07120
07121 if (i->rtp) {
07122 ast_channel_set_fd(tmp, 0, ast_rtp_instance_fd(i->rtp, 0));
07123 ast_channel_set_fd(tmp, 1, ast_rtp_instance_fd(i->rtp, 1));
07124 }
07125 if (needvideo && i->vrtp) {
07126 ast_channel_set_fd(tmp, 2, ast_rtp_instance_fd(i->vrtp, 0));
07127 ast_channel_set_fd(tmp, 3, ast_rtp_instance_fd(i->vrtp, 1));
07128 }
07129 if (needtext && i->trtp) {
07130 ast_channel_set_fd(tmp, 4, ast_rtp_instance_fd(i->trtp, 0));
07131 }
07132 if (i->udptl) {
07133 ast_channel_set_fd(tmp, 5, ast_udptl_fd(i->udptl));
07134 }
07135
07136 if (state == AST_STATE_RING)
07137 tmp->rings = 1;
07138 tmp->adsicpe = AST_ADSI_UNAVAILABLE;
07139
07140 tmp->writeformat = fmt;
07141 tmp->rawwriteformat = fmt;
07142 ast_rtp_instance_set_write_format(i->rtp, fmt);
07143
07144 tmp->readformat = fmt;
07145 tmp->rawreadformat = fmt;
07146 ast_rtp_instance_set_read_format(i->rtp, fmt);
07147
07148 tmp->tech_pvt = dialog_ref(i, "sip_new: set chan->tech_pvt to i");
07149
07150 tmp->callgroup = i->callgroup;
07151 tmp->pickupgroup = i->pickupgroup;
07152 tmp->caller.id.name.presentation = i->callingpres;
07153 tmp->caller.id.number.presentation = i->callingpres;
07154 if (!ast_strlen_zero(i->parkinglot))
07155 ast_string_field_set(tmp, parkinglot, i->parkinglot);
07156 if (!ast_strlen_zero(i->accountcode))
07157 ast_string_field_set(tmp, accountcode, i->accountcode);
07158 if (i->amaflags)
07159 tmp->amaflags = i->amaflags;
07160 if (!ast_strlen_zero(i->language))
07161 ast_string_field_set(tmp, language, i->language);
07162 i->owner = tmp;
07163 ast_module_ref(ast_module_info->self);
07164 ast_copy_string(tmp->context, i->context, sizeof(tmp->context));
07165
07166
07167
07168
07169 exten = ast_strdupa(i->exten);
07170 sip_pvt_unlock(i);
07171 ast_channel_unlock(tmp);
07172 if (!ast_exists_extension(NULL, i->context, i->exten, 1, i->cid_num)) {
07173 ast_uri_decode(exten);
07174 }
07175 ast_channel_lock(tmp);
07176 sip_pvt_lock(i);
07177 ast_copy_string(tmp->exten, exten, sizeof(tmp->exten));
07178
07179
07180
07181 if (!ast_strlen_zero(i->cid_num)) {
07182 tmp->caller.ani.number.valid = 1;
07183 tmp->caller.ani.number.str = ast_strdup(i->cid_num);
07184 }
07185 if (!ast_strlen_zero(i->rdnis)) {
07186 tmp->redirecting.from.number.valid = 1;
07187 tmp->redirecting.from.number.str = ast_strdup(i->rdnis);
07188 }
07189
07190 if (!ast_strlen_zero(i->exten) && strcmp(i->exten, "s")) {
07191 tmp->dialed.number.str = ast_strdup(i->exten);
07192 }
07193
07194 tmp->priority = 1;
07195 if (!ast_strlen_zero(i->uri))
07196 pbx_builtin_setvar_helper(tmp, "SIPURI", i->uri);
07197 if (!ast_strlen_zero(i->domain))
07198 pbx_builtin_setvar_helper(tmp, "SIPDOMAIN", i->domain);
07199 if (!ast_strlen_zero(i->callid))
07200 pbx_builtin_setvar_helper(tmp, "SIPCALLID", i->callid);
07201 if (i->rtp)
07202 ast_jb_configure(tmp, &global_jbconf);
07203
07204
07205 for (v = i->chanvars ; v ; v = v->next) {
07206 char valuebuf[1024];
07207 pbx_builtin_setvar_helper(tmp, v->name, ast_get_encoded_str(v->value, valuebuf, sizeof(valuebuf)));
07208 }
07209
07210 if (i->do_history)
07211 append_history(i, "NewChan", "Channel %s - from %s", tmp->name, i->callid);
07212
07213
07214 if (sip_cfg.callevents)
07215 manager_event(EVENT_FLAG_SYSTEM, "ChannelUpdate",
07216 "Channel: %s\r\nUniqueid: %s\r\nChanneltype: %s\r\nSIPcallid: %s\r\nSIPfullcontact: %s\r\n",
07217 tmp->name, tmp->uniqueid, "SIP", i->callid, i->fullcontact);
07218
07219 return tmp;
07220 }
07221
07222
07223 static char *get_body_by_line(const char *line, const char *name, int nameLen, char delimiter)
07224 {
07225 if (!strncasecmp(line, name, nameLen) && line[nameLen] == delimiter)
07226 return ast_skip_blanks(line + nameLen + 1);
07227
07228 return "";
07229 }
07230
07231
07232
07233
07234
07235 static const char *get_sdp_iterate(int *start, struct sip_request *req, const char *name)
07236 {
07237 int len = strlen(name);
07238
07239 while (*start < (req->sdp_start + req->sdp_count)) {
07240 const char *r = get_body_by_line(REQ_OFFSET_TO_STR(req, line[(*start)++]), name, len, '=');
07241 if (r[0] != '\0')
07242 return r;
07243 }
07244
07245
07246 (*start)++;
07247
07248 return "";
07249 }
07250
07251
07252
07253
07254
07255
07256 static char get_sdp_line(int *start, int stop, struct sip_request *req, const char **value)
07257 {
07258 char type = '\0';
07259 const char *line = NULL;
07260
07261 if (stop > (req->sdp_start + req->sdp_count)) {
07262 stop = req->sdp_start + req->sdp_count;
07263 }
07264
07265 while (*start < stop) {
07266 line = REQ_OFFSET_TO_STR(req, line[(*start)++]);
07267 if (line[1] == '=') {
07268 type = line[0];
07269 *value = ast_skip_blanks(line + 2);
07270 break;
07271 }
07272 }
07273
07274 return type;
07275 }
07276
07277
07278 static char *get_body(struct sip_request *req, char *name, char delimiter)
07279 {
07280 int x;
07281 int len = strlen(name);
07282 char *r;
07283
07284 for (x = 0; x < req->lines; x++) {
07285 r = get_body_by_line(REQ_OFFSET_TO_STR(req, line[x]), name, len, delimiter);
07286 if (r[0] != '\0')
07287 return r;
07288 }
07289
07290 return "";
07291 }
07292
07293
07294 static const char *find_alias(const char *name, const char *_default)
07295 {
07296
07297 static const struct cfalias {
07298 char * const fullname;
07299 char * const shortname;
07300 } aliases[] = {
07301 { "Content-Type", "c" },
07302 { "Content-Encoding", "e" },
07303 { "From", "f" },
07304 { "Call-ID", "i" },
07305 { "Contact", "m" },
07306 { "Content-Length", "l" },
07307 { "Subject", "s" },
07308 { "To", "t" },
07309 { "Supported", "k" },
07310 { "Refer-To", "r" },
07311 { "Referred-By", "b" },
07312 { "Allow-Events", "u" },
07313 { "Event", "o" },
07314 { "Via", "v" },
07315 { "Accept-Contact", "a" },
07316 { "Reject-Contact", "j" },
07317 { "Request-Disposition", "d" },
07318 { "Session-Expires", "x" },
07319 { "Identity", "y" },
07320 { "Identity-Info", "n" },
07321 };
07322 int x;
07323
07324 for (x = 0; x < ARRAY_LEN(aliases); x++) {
07325 if (!strcasecmp(aliases[x].fullname, name))
07326 return aliases[x].shortname;
07327 }
07328
07329 return _default;
07330 }
07331
07332 static const char *__get_header(const struct sip_request *req, const char *name, int *start)
07333 {
07334 int pass;
07335
07336
07337
07338
07339
07340
07341
07342
07343
07344
07345 for (pass = 0; name && pass < 2;pass++) {
07346 int x, len = strlen(name);
07347 for (x = *start; x < req->headers; x++) {
07348 const char *header = REQ_OFFSET_TO_STR(req, header[x]);
07349 if (!strncasecmp(header, name, len)) {
07350 const char *r = header + len;
07351 if (sip_cfg.pedanticsipchecking)
07352 r = ast_skip_blanks(r);
07353
07354 if (*r == ':') {
07355 *start = x+1;
07356 return ast_skip_blanks(r+1);
07357 }
07358 }
07359 }
07360 if (pass == 0)
07361 name = find_alias(name, NULL);
07362 }
07363
07364
07365 return "";
07366 }
07367
07368
07369
07370
07371 static const char *get_header(const struct sip_request *req, const char *name)
07372 {
07373 int start = 0;
07374 return __get_header(req, name, &start);
07375 }
07376
07377
07378 static struct ast_frame *sip_rtp_read(struct ast_channel *ast, struct sip_pvt *p, int *faxdetect)
07379 {
07380
07381 struct ast_frame *f;
07382
07383 if (!p->rtp) {
07384
07385 return &ast_null_frame;
07386 }
07387
07388 switch(ast->fdno) {
07389 case 0:
07390 f = ast_rtp_instance_read(p->rtp, 0);
07391 break;
07392 case 1:
07393 f = ast_rtp_instance_read(p->rtp, 1);
07394 break;
07395 case 2:
07396 f = ast_rtp_instance_read(p->vrtp, 0);
07397 break;
07398 case 3:
07399 f = ast_rtp_instance_read(p->vrtp, 1);
07400 break;
07401 case 4:
07402 f = ast_rtp_instance_read(p->trtp, 0);
07403 if (sipdebug_text) {
07404 int i;
07405 unsigned char* arr = f->data.ptr;
07406 for (i=0; i < f->datalen; i++)
07407 ast_verbose("%c", (arr[i] > ' ' && arr[i] < '}') ? arr[i] : '.');
07408 ast_verbose(" -> ");
07409 for (i=0; i < f->datalen; i++)
07410 ast_verbose("%02X ", arr[i]);
07411 ast_verbose("\n");
07412 }
07413 break;
07414 case 5:
07415 f = ast_udptl_read(p->udptl);
07416 break;
07417 default:
07418 f = &ast_null_frame;
07419 }
07420
07421 if (f && (f->frametype == AST_FRAME_DTMF_BEGIN || f->frametype == AST_FRAME_DTMF_END) &&
07422 (ast_test_flag(&p->flags[0], SIP_DTMF) != SIP_DTMF_RFC2833)) {
07423 ast_debug(1, "Ignoring DTMF (%c) RTP frame because dtmfmode is not RFC2833\n", f->subclass.integer);
07424 return &ast_null_frame;
07425 }
07426
07427
07428 if (!p->owner || (f && f->frametype != AST_FRAME_VOICE))
07429 return f;
07430
07431 if (f && f->subclass.codec != (p->owner->nativeformats & AST_FORMAT_AUDIO_MASK)) {
07432 if (!(f->subclass.codec & p->jointcapability)) {
07433 ast_debug(1, "Bogus frame of format '%s' received from '%s'!\n",
07434 ast_getformatname(f->subclass.codec), p->owner->name);
07435 return &ast_null_frame;
07436 }
07437 ast_debug(1, "Oooh, format changed to %s\n",
07438 ast_getformatname(f->subclass.codec));
07439 p->owner->nativeformats = (p->owner->nativeformats & (AST_FORMAT_VIDEO_MASK | AST_FORMAT_TEXT_MASK)) | f->subclass.codec;
07440 ast_set_read_format(p->owner, p->owner->readformat);
07441 ast_set_write_format(p->owner, p->owner->writeformat);
07442 }
07443
07444 if (f && p->dsp) {
07445 f = ast_dsp_process(p->owner, p->dsp, f);
07446 if (f && f->frametype == AST_FRAME_DTMF) {
07447 if (f->subclass.integer == 'f') {
07448 ast_debug(1, "Fax CNG detected on %s\n", ast->name);
07449 *faxdetect = 1;
07450
07451 if (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_INBAND) {
07452 ast_dsp_set_features(p->dsp, DSP_FEATURE_DIGIT_DETECT);
07453 } else {
07454 ast_dsp_free(p->dsp);
07455 p->dsp = NULL;
07456 }
07457 } else {
07458 ast_debug(1, "* Detected inband DTMF '%c'\n", f->subclass.integer);
07459 }
07460 }
07461 }
07462
07463 return f;
07464 }
07465
07466
07467 static struct ast_frame *sip_read(struct ast_channel *ast)
07468 {
07469 struct ast_frame *fr;
07470 struct sip_pvt *p = ast->tech_pvt;
07471 int faxdetected = FALSE;
07472
07473 sip_pvt_lock(p);
07474 fr = sip_rtp_read(ast, p, &faxdetected);
07475 p->lastrtprx = time(NULL);
07476
07477
07478 if (faxdetected && ast_test_flag(&p->flags[1], SIP_PAGE2_FAX_DETECT_CNG)) {
07479 if (strcmp(ast->exten, "fax")) {
07480 const char *target_context = S_OR(ast->macrocontext, ast->context);
07481
07482
07483
07484
07485
07486 sip_pvt_unlock(p);
07487 ast_channel_unlock(ast);
07488 if (ast_exists_extension(ast, target_context, "fax", 1,
07489 S_COR(ast->caller.id.number.valid, ast->caller.id.number.str, NULL))) {
07490 ast_channel_lock(ast);
07491 sip_pvt_lock(p);
07492 ast_verbose(VERBOSE_PREFIX_2 "Redirecting '%s' to fax extension due to CNG detection\n", ast->name);
07493 pbx_builtin_setvar_helper(ast, "FAXEXTEN", ast->exten);
07494 if (ast_async_goto(ast, target_context, "fax", 1)) {
07495 ast_log(LOG_NOTICE, "Failed to async goto '%s' into fax of '%s'\n", ast->name, target_context);
07496 }
07497 fr = &ast_null_frame;
07498 } else {
07499 ast_channel_lock(ast);
07500 sip_pvt_lock(p);
07501 ast_log(LOG_NOTICE, "FAX CNG detected but no fax extension\n");
07502 }
07503 }
07504 }
07505
07506
07507 if (fr && fr->frametype == AST_FRAME_VOICE && p->invitestate != INV_EARLY_MEDIA && ast->_state != AST_STATE_UP) {
07508 fr = &ast_null_frame;
07509 }
07510
07511 sip_pvt_unlock(p);
07512
07513 return fr;
07514 }
07515
07516
07517
07518 static char *generate_random_string(char *buf, size_t size)
07519 {
07520 long val[4];
07521 int x;
07522
07523 for (x=0; x<4; x++)
07524 val[x] = ast_random();
07525 snprintf(buf, size, "%08lx%08lx%08lx%08lx", val[0], val[1], val[2], val[3]);
07526
07527 return buf;
07528 }
07529
07530 static char *generate_uri(struct sip_pvt *pvt, char *buf, size_t size)
07531 {
07532 struct ast_str *uri = ast_str_alloca(size);
07533 ast_str_set(&uri, 0, "%s", pvt->socket.type == SIP_TRANSPORT_TLS ? "sips:" : "sip:");
07534
07535
07536
07537 ast_str_append(&uri, 0, "%s", generate_random_string(buf, size));
07538 ast_str_append(&uri, 0, "@%s", ast_sockaddr_stringify_remote(&pvt->ourip));
07539 ast_copy_string(buf, ast_str_buffer(uri), size);
07540 return buf;
07541 }
07542
07543
07544
07545
07546
07547
07548
07549
07550 static void build_callid_pvt(struct sip_pvt *pvt)
07551 {
07552 char buf[33];
07553 const char *host = S_OR(pvt->fromdomain, ast_sockaddr_stringify_remote(&pvt->ourip));
07554
07555 ast_string_field_build(pvt, callid, "%s@%s", generate_random_string(buf, sizeof(buf)), host);
07556 }
07557
07558
07559 #define CONTAINER_UNLINK(container, obj, tag) \
07560 ({ \
07561 int found = 0; \
07562 typeof((obj)) __removed_obj; \
07563 __removed_obj = ao2_t_callback((container), \
07564 OBJ_UNLINK | OBJ_POINTER, ao2_match_by_addr, (obj), (tag)); \
07565 if (__removed_obj) { \
07566 ao2_ref(__removed_obj, -1); \
07567 found = 1; \
07568 } \
07569 found; \
07570 })
07571
07572
07573
07574
07575
07576
07577
07578
07579
07580
07581 static void change_callid_pvt(struct sip_pvt *pvt, const char *callid)
07582 {
07583 int in_dialog_container;
07584
07585 ao2_lock(dialogs);
07586 in_dialog_container = CONTAINER_UNLINK(dialogs, pvt,
07587 "About to change the callid -- remove the old name");
07588 if (callid) {
07589 ast_string_field_set(pvt, callid, callid);
07590 } else {
07591 build_callid_pvt(pvt);
07592 }
07593 if (in_dialog_container) {
07594 ao2_t_link(dialogs, pvt, "New dialog callid -- inserted back into table");
07595 }
07596 ao2_unlock(dialogs);
07597 }
07598
07599
07600 static void build_callid_registry(struct sip_registry *reg, const struct ast_sockaddr *ourip, const char *fromdomain)
07601 {
07602 char buf[33];
07603
07604 const char *host = S_OR(fromdomain, ast_sockaddr_stringify_host_remote(ourip));
07605
07606 ast_string_field_build(reg, callid, "%s@%s", generate_random_string(buf, sizeof(buf)), host);
07607 }
07608
07609
07610 static void make_our_tag(char *tagbuf, size_t len)
07611 {
07612 snprintf(tagbuf, len, "as%08lx", ast_random());
07613 }
07614
07615
07616 static struct sip_st_dlg* sip_st_alloc(struct sip_pvt *const p)
07617 {
07618 struct sip_st_dlg *stp;
07619
07620 if (p->stimer) {
07621 ast_log(LOG_ERROR, "Session-Timer struct already allocated\n");
07622 return p->stimer;
07623 }
07624
07625 if (!(stp = ast_calloc(1, sizeof(struct sip_st_dlg))))
07626 return NULL;
07627
07628 p->stimer = stp;
07629
07630 stp->st_schedid = -1;
07631
07632 return p->stimer;
07633 }
07634
07635
07636
07637
07638
07639 struct sip_pvt *sip_alloc(ast_string_field callid, struct ast_sockaddr *addr,
07640 int useglobal_nat, const int intended_method, struct sip_request *req)
07641 {
07642 struct sip_pvt *p;
07643
07644 if (!(p = ao2_t_alloc(sizeof(*p), sip_destroy_fn, "allocate a dialog(pvt) struct")))
07645 return NULL;
07646
07647 if (ast_string_field_init(p, 512)) {
07648 ao2_t_ref(p, -1, "failed to string_field_init, drop p");
07649 return NULL;
07650 }
07651
07652 if (!(p->cc_params = ast_cc_config_params_init())) {
07653 ao2_t_ref(p, -1, "Yuck, couldn't allocate cc_params struct. Get rid o' p");
07654 return NULL;
07655 }
07656
07657
07658
07659 if (req) {
07660 struct sip_via *via;
07661 const char *cseq = get_header(req, "Cseq");
07662 unsigned int seqno;
07663
07664
07665 via = parse_via(get_header(req, "Via"));
07666 if (via) {
07667
07668
07669 if (!ast_strlen_zero(via->branch) && !strncasecmp(via->branch, "z9hG4bK", 7)) {
07670 ast_string_field_set(p, initviabranch, via->branch);
07671 ast_string_field_set(p, initviasentby, via->sent_by);
07672 }
07673 free_via(via);
07674 }
07675
07676
07677
07678 if (!ast_strlen_zero(cseq) && (sscanf(cseq, "%30u", &seqno) == 1)) {
07679 p->init_icseq = seqno;
07680 }
07681
07682 set_socket_transport(&p->socket, req->socket.type);
07683 } else {
07684 set_socket_transport(&p->socket, SIP_TRANSPORT_UDP);
07685 }
07686
07687 p->socket.fd = -1;
07688 p->method = intended_method;
07689 p->initid = -1;
07690 p->waitid = -1;
07691 p->autokillid = -1;
07692 p->request_queue_sched_id = -1;
07693 p->provisional_keepalive_sched_id = -1;
07694 p->t38id = -1;
07695 p->subscribed = NONE;
07696 p->stateid = -1;
07697 p->sessionversion_remote = -1;
07698 p->session_modify = TRUE;
07699 p->stimer = NULL;
07700 p->prefs = default_prefs;
07701 p->maxforwards = sip_cfg.default_max_forwards;
07702
07703 if (intended_method != SIP_OPTIONS) {
07704 p->timer_t1 = global_t1;
07705 p->timer_b = global_timer_b;
07706 }
07707
07708 if (!addr) {
07709 p->ourip = internip;
07710 } else {
07711 ast_sockaddr_copy(&p->sa, addr);
07712 ast_sip_ouraddrfor(&p->sa, &p->ourip, p);
07713 }
07714
07715
07716 ast_copy_flags(&p->flags[0], &global_flags[0], SIP_FLAGS_TO_COPY);
07717 ast_copy_flags(&p->flags[1], &global_flags[1], SIP_PAGE2_FLAGS_TO_COPY);
07718 ast_copy_flags(&p->flags[2], &global_flags[2], SIP_PAGE3_FLAGS_TO_COPY);
07719
07720 p->do_history = recordhistory;
07721
07722 p->branch = ast_random();
07723 make_our_tag(p->tag, sizeof(p->tag));
07724 p->ocseq = INITIAL_CSEQ;
07725 p->allowed_methods = UINT_MAX;
07726
07727 if (sip_methods[intended_method].need_rtp) {
07728 p->maxcallbitrate = default_maxcallbitrate;
07729 p->autoframing = global_autoframing;
07730 }
07731
07732 if (useglobal_nat && addr) {
07733
07734 ast_copy_flags(&p->flags[0], &global_flags[0], SIP_NAT_FORCE_RPORT);
07735 ast_sockaddr_copy(&p->recv, addr);
07736
07737 do_setnat(p);
07738 }
07739
07740 if (p->method != SIP_REGISTER) {
07741 ast_string_field_set(p, fromdomain, default_fromdomain);
07742 p->fromdomainport = default_fromdomainport;
07743 }
07744 build_via(p);
07745 if (!callid)
07746 build_callid_pvt(p);
07747 else
07748 ast_string_field_set(p, callid, callid);
07749
07750 ast_string_field_set(p, mohinterpret, default_mohinterpret);
07751 ast_string_field_set(p, mohsuggest, default_mohsuggest);
07752 p->capability = sip_cfg.capability;
07753 p->allowtransfer = sip_cfg.allowtransfer;
07754 if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
07755 (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO)) {
07756 p->noncodeccapability |= AST_RTP_DTMF;
07757 }
07758 ast_string_field_set(p, context, sip_cfg.default_context);
07759 ast_string_field_set(p, parkinglot, default_parkinglot);
07760 ast_string_field_set(p, engine, default_engine);
07761
07762 AST_LIST_HEAD_INIT_NOLOCK(&p->request_queue);
07763
07764
07765
07766 ao2_t_link(dialogs, p, "link pvt into dialogs table");
07767
07768 ast_debug(1, "Allocating new SIP dialog for %s - %s (%s)\n", callid ? callid : p->callid, sip_methods[intended_method].text, p->rtp ? "With RTP" : "No RTP");
07769 return p;
07770 }
07771
07772
07773
07774
07775
07776
07777
07778
07779 static int addr_is_multicast(const struct ast_sockaddr *addr)
07780 {
07781 return ((ast_sockaddr_ipv4(addr) & 0xf0000000) == 0xe0000000);
07782 }
07783
07784
07785
07786
07787
07788
07789
07790
07791
07792
07793
07794
07795
07796
07797
07798
07799 static int process_via(struct sip_pvt *p, const struct sip_request *req)
07800 {
07801 struct sip_via *via = parse_via(get_header(req, "Via"));
07802
07803 if (!via) {
07804 ast_log(LOG_ERROR, "error processing via header\n");
07805 return -1;
07806 }
07807
07808 if (via->maddr) {
07809 if (ast_sockaddr_resolve_first(&p->sa, via->maddr, PARSE_PORT_FORBID)) {
07810 ast_log(LOG_WARNING, "Can't find address for maddr '%s'\n", via->maddr);
07811 ast_log(LOG_ERROR, "error processing via header\n");
07812 free_via(via);
07813 return -1;
07814 }
07815
07816 if (addr_is_multicast(&p->sa)) {
07817 setsockopt(sipsock, IPPROTO_IP, IP_MULTICAST_TTL, &via->ttl, sizeof(via->ttl));
07818 }
07819 }
07820
07821 ast_sockaddr_set_port(&p->sa, via->port ? via->port : STANDARD_SIP_PORT);
07822
07823 free_via(via);
07824 return 0;
07825 }
07826
07827
07828 struct match_req_args {
07829 int method;
07830 const char *callid;
07831 const char *totag;
07832 const char *fromtag;
07833 unsigned int seqno;
07834
07835
07836 const char *ruri;
07837 const char *viabranch;
07838 const char *viasentby;
07839
07840
07841 int authentication_present;
07842 };
07843
07844 enum match_req_res {
07845 SIP_REQ_MATCH,
07846 SIP_REQ_NOT_MATCH,
07847 SIP_REQ_LOOP_DETECTED,
07848 };
07849
07850
07851
07852
07853
07854
07855 static enum match_req_res match_req_to_dialog(struct sip_pvt *sip_pvt_ptr, struct match_req_args *arg)
07856 {
07857 const char *init_ruri = NULL;
07858 if (sip_pvt_ptr->initreq.headers) {
07859 init_ruri = REQ_OFFSET_TO_STR(&sip_pvt_ptr->initreq, rlPart2);
07860 }
07861
07862
07863
07864
07865 if (!ast_strlen_zero(arg->callid) && strcmp(sip_pvt_ptr->callid, arg->callid)) {
07866
07867 return SIP_REQ_NOT_MATCH;
07868 }
07869 if (arg->method == SIP_RESPONSE) {
07870
07871
07872 if (!ast_strlen_zero(sip_pvt_ptr->theirtag) && ast_test_flag(&sip_pvt_ptr->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED)) {
07873 if (ast_strlen_zero(arg->totag)) {
07874
07875 return SIP_REQ_NOT_MATCH;
07876 }
07877 if (strcmp(arg->totag, sip_pvt_ptr->theirtag)) {
07878
07879 return SIP_REQ_NOT_MATCH;
07880 }
07881 }
07882
07883 if (strcmp(arg->fromtag, sip_pvt_ptr->tag)) {
07884
07885 return SIP_REQ_NOT_MATCH;
07886 }
07887 } else {
07888
07889
07890
07891 if (!arg->authentication_present && strcmp(arg->fromtag, sip_pvt_ptr->theirtag)) {
07892
07893 return SIP_REQ_NOT_MATCH;
07894 }
07895
07896 if (!ast_strlen_zero(arg->totag) && (strcmp(arg->totag, sip_pvt_ptr->tag))) {
07897
07898 return SIP_REQ_NOT_MATCH;
07899 }
07900 }
07901
07902
07903
07904
07905
07906
07907
07908
07909
07910
07911
07912
07913
07914
07915
07916
07917
07918 if ((arg->method != SIP_RESPONSE) &&
07919 ast_strlen_zero(arg->totag) &&
07920 (sip_pvt_ptr->init_icseq == arg->seqno) &&
07921 !ast_strlen_zero(sip_pvt_ptr->initviabranch) &&
07922 init_ruri) {
07923
07924
07925 if (ast_strlen_zero(arg->viabranch) ||
07926 strcmp(arg->viabranch, sip_pvt_ptr->initviabranch) ||
07927 ast_strlen_zero(arg->viasentby) ||
07928 strcmp(arg->viasentby, sip_pvt_ptr->initviasentby)) {
07929
07930
07931
07932 if ((sip_pvt_ptr->method != arg->method)) {
07933 return SIP_REQ_NOT_MATCH;
07934 }
07935
07936
07937
07938 if (sip_uri_cmp(init_ruri, arg->ruri)) {
07939
07940 return SIP_REQ_NOT_MATCH;
07941 }
07942
07943
07944
07945
07946
07947
07948
07949
07950
07951
07952
07953
07954
07955
07956
07957
07958
07959
07960
07961 return SIP_REQ_LOOP_DETECTED;
07962 }
07963 }
07964
07965
07966
07967
07968
07969
07970 if ((arg->method != SIP_RESPONSE) &&
07971 ast_strlen_zero(arg->totag) &&
07972 arg->authentication_present &&
07973 sip_uri_cmp(init_ruri, arg->ruri)) {
07974
07975
07976 return SIP_REQ_NOT_MATCH;
07977 }
07978
07979 return SIP_REQ_MATCH;
07980 }
07981
07982
07983
07984
07985
07986
07987
07988
07989
07990
07991
07992
07993
07994
07995
07996
07997
07998
07999 static struct ast_channel *sip_pvt_lock_full(struct sip_pvt *pvt)
08000 {
08001 struct ast_channel *chan;
08002
08003
08004
08005
08006 for (;;) {
08007
08008 sip_pvt_lock(pvt);
08009 chan = pvt->owner;
08010 if (chan) {
08011
08012
08013
08014 ast_channel_ref(chan);
08015 } else {
08016
08017 return NULL;
08018 }
08019
08020
08021
08022
08023 sip_pvt_unlock(pvt);
08024
08025
08026 ast_channel_lock(chan);
08027 sip_pvt_lock(pvt);
08028
08029 if (pvt->owner == chan) {
08030
08031 break;
08032 }
08033
08034
08035
08036
08037
08038
08039 ast_channel_unlock(chan);
08040 ast_channel_unref(chan);
08041 sip_pvt_unlock(pvt);
08042 }
08043
08044
08045 return pvt->owner;
08046 }
08047
08048
08049
08050
08051
08052
08053 static struct sip_pvt *find_call(struct sip_request *req, struct ast_sockaddr *addr, const int intended_method)
08054 {
08055 char totag[128];
08056 char fromtag[128];
08057 const char *callid = get_header(req, "Call-ID");
08058 const char *from = get_header(req, "From");
08059 const char *to = get_header(req, "To");
08060 const char *cseq = get_header(req, "Cseq");
08061 struct sip_pvt *sip_pvt_ptr;
08062 unsigned int seqno;
08063
08064
08065 if (ast_strlen_zero(callid) || ast_strlen_zero(to) ||
08066 ast_strlen_zero(from) || ast_strlen_zero(cseq) ||
08067 (sscanf(cseq, "%30u", &seqno) != 1)) {
08068
08069
08070 if (intended_method != SIP_RESPONSE && intended_method != SIP_ACK) {
08071 transmit_response_using_temp(callid, addr, 1, intended_method,
08072 req, "400 Bad Request");
08073 }
08074 return NULL;
08075 }
08076
08077 if (sip_cfg.pedanticsipchecking) {
08078
08079
08080
08081
08082
08083
08084 if (gettag(req, "To", totag, sizeof(totag)))
08085 req->has_to_tag = 1;
08086 gettag(req, "From", fromtag, sizeof(fromtag));
08087
08088 ast_debug(5, "= Looking for Call ID: %s (Checking %s) --From tag %s --To-tag %s \n", callid, req->method==SIP_RESPONSE ? "To" : "From", fromtag, totag);
08089
08090
08091 if (ast_strlen_zero(fromtag)) {
08092 ast_debug(5, "%s request has no from tag, dropping callid: %s from: %s\n", sip_methods[req->method].text , callid, from );
08093 return NULL;
08094 }
08095
08096 if (ast_strlen_zero(totag) && (req->method == SIP_ACK || req->method == SIP_BYE || req->method == SIP_INFO )) {
08097 ast_debug(5, "%s must have a to tag. dropping callid: %s from: %s\n", sip_methods[req->method].text , callid, from );
08098 return NULL;
08099 }
08100 }
08101
08102 if (!sip_cfg.pedanticsipchecking) {
08103 struct sip_pvt tmp_dialog = {
08104 .callid = callid,
08105 };
08106 sip_pvt_ptr = ao2_t_find(dialogs, &tmp_dialog, OBJ_POINTER, "ao2_find in dialogs");
08107 if (sip_pvt_ptr) {
08108
08109 return sip_pvt_ptr;
08110 }
08111 } else {
08112 struct sip_pvt tmp_dialog = {
08113 .callid = callid,
08114 };
08115 struct match_req_args args = { 0, };
08116 int found;
08117 struct ao2_iterator *iterator = ao2_t_callback(dialogs,
08118 OBJ_POINTER | OBJ_MULTIPLE,
08119 dialog_find_multiple,
08120 &tmp_dialog,
08121 "pedantic ao2_find in dialogs");
08122 struct sip_via *via = NULL;
08123
08124 args.method = req->method;
08125 args.callid = NULL;
08126 args.totag = totag;
08127 args.fromtag = fromtag;
08128 args.seqno = seqno;
08129
08130
08131 if (req->method != SIP_RESPONSE) {
08132 args.ruri = REQ_OFFSET_TO_STR(req, rlPart2);
08133 via = parse_via(get_header(req, "Via"));
08134 if (via) {
08135 args.viasentby = via->sent_by;
08136 args.viabranch = via->branch;
08137 }
08138 if (!ast_strlen_zero(get_header(req, "Authorization")) ||
08139 !ast_strlen_zero(get_header(req, "Proxy-Authorization"))) {
08140 args.authentication_present = 1;
08141 }
08142 }
08143
08144
08145 while (iterator && (sip_pvt_ptr = ao2_iterator_next(iterator))) {
08146 found = match_req_to_dialog(sip_pvt_ptr, &args);
08147
08148 switch (found) {
08149 case SIP_REQ_MATCH:
08150 ao2_iterator_destroy(iterator);
08151 free_via(via);
08152 return sip_pvt_ptr;
08153 case SIP_REQ_LOOP_DETECTED:
08154
08155
08156 transmit_response_using_temp(callid, addr, 1, intended_method, req, "482 (Loop Detected)");
08157 dialog_unref(sip_pvt_ptr, "pvt did not match incoming SIP msg, unref from search.");
08158 ao2_iterator_destroy(iterator);
08159 free_via(via);
08160 return NULL;
08161 case SIP_REQ_NOT_MATCH:
08162 default:
08163 dialog_unref(sip_pvt_ptr, "pvt did not match incoming SIP msg, unref from search");
08164 }
08165 }
08166 if (iterator) {
08167 ao2_iterator_destroy(iterator);
08168 }
08169
08170 free_via(via);
08171 }
08172
08173
08174 if (sip_methods[intended_method].can_create == CAN_CREATE_DIALOG) {
08175 struct sip_pvt *p = NULL;
08176
08177 if (intended_method == SIP_REFER) {
08178
08179 transmit_response_using_temp(callid, addr, 1, intended_method, req, "603 Declined (no dialog)");
08180
08181
08182 } else if (!(p = sip_alloc(callid, addr, 1, intended_method, req))) {
08183
08184
08185
08186
08187
08188
08189
08190
08191 transmit_response_using_temp(callid, addr, 1, intended_method, req, "500 Server internal error");
08192 ast_debug(4, "Failed allocating SIP dialog, sending 500 Server internal error and giving up\n");
08193 }
08194 return p;
08195 } else if( sip_methods[intended_method].can_create == CAN_CREATE_DIALOG_UNSUPPORTED_METHOD) {
08196
08197 transmit_response_using_temp(callid, addr, 1, intended_method, req, "501 Method Not Implemented");
08198 ast_debug(2, "Got a request with unsupported SIP method.\n");
08199 } else if (intended_method != SIP_RESPONSE && intended_method != SIP_ACK) {
08200
08201 transmit_response_using_temp(callid, addr, 1, intended_method, req, "481 Call leg/transaction does not exist");
08202 ast_debug(2, "That's odd... Got a request in unknown dialog. Callid %s\n", callid ? callid : "<unknown>");
08203 }
08204
08205
08206 if (intended_method == SIP_RESPONSE)
08207 ast_debug(2, "That's odd... Got a response on a call we don't know about. Callid %s\n", callid ? callid : "<unknown>");
08208
08209 return NULL;
08210 }
08211
08212
08213 static int sip_register(const char *value, int lineno)
08214 {
08215 struct sip_registry *reg;
08216
08217 if (!(reg = ast_calloc_with_stringfields(1, struct sip_registry, 256))) {
08218 ast_log(LOG_ERROR, "Out of memory. Can't allocate SIP registry entry\n");
08219 return -1;
08220 }
08221
08222 ast_atomic_fetchadd_int(®objs, 1);
08223 ASTOBJ_INIT(reg);
08224
08225 if (sip_parse_register_line(reg, default_expiry, value, lineno)) {
08226 registry_unref(reg, "failure to parse, unref the reg pointer");
08227 return -1;
08228 }
08229
08230
08231 if (reg->refresh && !reg->expiry && !reg->configured_expiry) {
08232 reg->refresh = reg->expiry = reg->configured_expiry = default_expiry;
08233 }
08234
08235
08236 ASTOBJ_CONTAINER_LINK(®l, reg);
08237
08238
08239 registry_unref(reg, "unref the reg pointer");
08240
08241 return 0;
08242 }
08243
08244
08245 static int sip_subscribe_mwi(const char *value, int lineno)
08246 {
08247 struct sip_subscription_mwi *mwi;
08248 int portnum = 0;
08249 enum sip_transport transport = SIP_TRANSPORT_UDP;
08250 char buf[256] = "";
08251 char *username = NULL, *hostname = NULL, *secret = NULL, *authuser = NULL, *porta = NULL, *mailbox = NULL, *at = NULL;
08252
08253 if (!value) {
08254 return -1;
08255 }
08256
08257 ast_copy_string(buf, value, sizeof(buf));
08258
08259 if (!(at = strstr(buf, "@"))) {
08260 return -1;
08261 }
08262
08263 if ((hostname = strrchr(buf, '@'))) {
08264 *hostname++ = '\0';
08265 username = buf;
08266 }
08267
08268 if ((secret = strchr(username, ':'))) {
08269 *secret++ = '\0';
08270 if ((authuser = strchr(secret, ':'))) {
08271 *authuser++ = '\0';
08272 }
08273 }
08274
08275 if ((mailbox = strchr(hostname, '/'))) {
08276 *mailbox++ = '\0';
08277 }
08278
08279 if (ast_strlen_zero(username) || ast_strlen_zero(hostname) || ast_strlen_zero(mailbox)) {
08280 ast_log(LOG_WARNING, "Format for MWI subscription is user[:secret[:authuser]]@host[:port]/mailbox at line %d\n", lineno);
08281 return -1;
08282 }
08283
08284 if ((porta = strchr(hostname, ':'))) {
08285 *porta++ = '\0';
08286 if (!(portnum = atoi(porta))) {
08287 ast_log(LOG_WARNING, "%s is not a valid port number at line %d\n", porta, lineno);
08288 return -1;
08289 }
08290 }
08291
08292 if (!(mwi = ast_calloc_with_stringfields(1, struct sip_subscription_mwi, 256))) {
08293 return -1;
08294 }
08295
08296 ASTOBJ_INIT(mwi);
08297 ast_string_field_set(mwi, username, username);
08298 if (secret) {
08299 ast_string_field_set(mwi, secret, secret);
08300 }
08301 if (authuser) {
08302 ast_string_field_set(mwi, authuser, authuser);
08303 }
08304 ast_string_field_set(mwi, hostname, hostname);
08305 ast_string_field_set(mwi, mailbox, mailbox);
08306 mwi->resub = -1;
08307 mwi->portno = portnum;
08308 mwi->transport = transport;
08309
08310 ASTOBJ_CONTAINER_LINK(&submwil, mwi);
08311 ASTOBJ_UNREF(mwi, sip_subscribe_mwi_destroy);
08312
08313 return 0;
08314 }
08315
08316 static void mark_method_allowed(unsigned int *allowed_methods, enum sipmethod method)
08317 {
08318 (*allowed_methods) |= (1 << method);
08319 }
08320
08321 static void mark_method_unallowed(unsigned int *allowed_methods, enum sipmethod method)
08322 {
08323 (*allowed_methods) &= ~(1 << method);
08324 }
08325
08326
08327 static int is_method_allowed(unsigned int *allowed_methods, enum sipmethod method)
08328 {
08329 return ((*allowed_methods) >> method) & 1;
08330 }
08331
08332 static void mark_parsed_methods(unsigned int *methods, char *methods_str)
08333 {
08334 char *method;
08335 for (method = strsep(&methods_str, ","); !ast_strlen_zero(method); method = strsep(&methods_str, ",")) {
08336 int id = find_sip_method(ast_skip_blanks(method));
08337 if (id == SIP_UNKNOWN) {
08338 continue;
08339 }
08340 mark_method_allowed(methods, id);
08341 }
08342 }
08343
08344
08345
08346
08347
08348
08349
08350
08351
08352
08353
08354
08355
08356
08357
08358
08359 static unsigned int parse_allowed_methods(struct sip_request *req)
08360 {
08361 char *allow = ast_strdupa(get_header(req, "Allow"));
08362 unsigned int allowed_methods = SIP_UNKNOWN;
08363
08364 if (ast_strlen_zero(allow)) {
08365
08366
08367
08368
08369 char *contact = ast_strdupa(get_header(req, "Contact"));
08370 char *methods = strstr(contact, ";methods=");
08371
08372 if (ast_strlen_zero(methods)) {
08373
08374
08375
08376
08377
08378
08379
08380
08381
08382
08383
08384 return UINT_MAX;
08385 }
08386 allow = ast_strip_quoted(methods + 9, "\"", "\"");
08387 }
08388 mark_parsed_methods(&allowed_methods, allow);
08389 return allowed_methods;
08390 }
08391
08392
08393
08394
08395
08396
08397
08398
08399
08400
08401 static unsigned int set_pvt_allowed_methods(struct sip_pvt *pvt, struct sip_request *req)
08402 {
08403 pvt->allowed_methods = parse_allowed_methods(req);
08404
08405 if (ast_test_flag(&pvt->flags[1], SIP_PAGE2_RPID_UPDATE)) {
08406 mark_method_allowed(&pvt->allowed_methods, SIP_UPDATE);
08407 }
08408 pvt->allowed_methods &= ~(pvt->disallowed_methods);
08409
08410 return pvt->allowed_methods;
08411 }
08412
08413
08414
08415 static void lws2sws(struct ast_str *data)
08416 {
08417 char *msgbuf = data->str;
08418 int len = ast_str_strlen(data);
08419 int h = 0, t = 0;
08420 int lws = 0;
08421
08422 for (; h < len;) {
08423
08424 if (msgbuf[h] == '\r') {
08425 h++;
08426 continue;
08427 }
08428
08429 if (msgbuf[h] == '\n') {
08430
08431 if (h + 1 == len)
08432 break;
08433
08434 if (msgbuf[h + 1] == ' ' || msgbuf[h + 1] == '\t') {
08435
08436 h++;
08437 continue;
08438 }
08439
08440 msgbuf[t++] = msgbuf[h++];
08441 lws = 0;
08442 continue;
08443 }
08444 if (msgbuf[h] == ' ' || msgbuf[h] == '\t') {
08445 if (lws) {
08446 h++;
08447 continue;
08448 }
08449 msgbuf[t++] = msgbuf[h++];
08450 lws = 1;
08451 continue;
08452 }
08453 msgbuf[t++] = msgbuf[h++];
08454 if (lws)
08455 lws = 0;
08456 }
08457 msgbuf[t] = '\0';
08458 data->used = t;
08459 }
08460
08461
08462
08463
08464 static int parse_request(struct sip_request *req)
08465 {
08466 char *c = req->data->str;
08467 ptrdiff_t *dst = req->header;
08468 int i = 0, lim = SIP_MAX_HEADERS - 1;
08469 unsigned int skipping_headers = 0;
08470 ptrdiff_t current_header_offset = 0;
08471 char *previous_header = "";
08472
08473 req->header[0] = 0;
08474 req->headers = -1;
08475 for (; *c; c++) {
08476 if (*c == '\r') {
08477 *c = '\0';
08478 } else if (*c == '\n') {
08479 *c = '\0';
08480 current_header_offset = (c + 1) - req->data->str;
08481 previous_header = req->data->str + dst[i];
08482 if (skipping_headers) {
08483
08484
08485
08486 if (ast_strlen_zero(previous_header)) {
08487 skipping_headers = 0;
08488 }
08489 dst[i] = current_header_offset;
08490 continue;
08491 }
08492 if (sipdebug) {
08493 ast_debug(4, "%7s %2d [%3d]: %s\n",
08494 req->headers < 0 ? "Header" : "Body",
08495 i, (int) strlen(previous_header), previous_header);
08496 }
08497 if (ast_strlen_zero(previous_header) && req->headers < 0) {
08498 req->headers = i;
08499 dst = req->line;
08500 i = 0;
08501 lim = SIP_MAX_LINES - 1;
08502 } else {
08503 if (i++ == lim) {
08504
08505
08506
08507 if (req->headers != -1) {
08508 break;
08509 } else {
08510 req->headers = i;
08511 dst = req->line;
08512 i = 0;
08513 lim = SIP_MAX_LINES - 1;
08514 skipping_headers = 1;
08515 }
08516 }
08517 }
08518 dst[i] = current_header_offset;
08519 }
08520 }
08521
08522
08523
08524
08525
08526
08527 previous_header = req->data->str + dst[i];
08528 if ((i < lim) && !ast_strlen_zero(previous_header)) {
08529 if (sipdebug) {
08530 ast_debug(4, "%7s %2d [%3d]: %s\n",
08531 req->headers < 0 ? "Header" : "Body",
08532 i, (int) strlen(previous_header), previous_header );
08533 }
08534 i++;
08535 }
08536
08537
08538 if (req->headers >= 0) {
08539 req->lines = i;
08540 } else {
08541 req->headers = i;
08542 req->lines = 0;
08543
08544 req->line[0] = ast_str_strlen(req->data);
08545 }
08546
08547 if (*c) {
08548 ast_log(LOG_WARNING, "Too many lines, skipping <%s>\n", c);
08549 }
08550
08551
08552 return determine_firstline_parts(req);
08553 }
08554
08555
08556
08557
08558
08559
08560
08561
08562
08563 static int find_sdp(struct sip_request *req)
08564 {
08565 const char *content_type;
08566 const char *content_length;
08567 const char *search;
08568 char *boundary;
08569 unsigned int x;
08570 int boundaryisquoted = FALSE;
08571 int found_application_sdp = FALSE;
08572 int found_end_of_headers = FALSE;
08573
08574 content_length = get_header(req, "Content-Length");
08575
08576 if (!ast_strlen_zero(content_length)) {
08577 if (sscanf(content_length, "%30u", &x) != 1) {
08578 ast_log(LOG_WARNING, "Invalid Content-Length: %s\n", content_length);
08579 return 0;
08580 }
08581
08582
08583
08584 if (x == 0)
08585 return 0;
08586 }
08587
08588 content_type = get_header(req, "Content-Type");
08589
08590
08591 if (!strncasecmp(content_type, "application/sdp", 15)) {
08592 req->sdp_start = 0;
08593 req->sdp_count = req->lines;
08594 return req->lines ? 1 : 0;
08595 }
08596
08597
08598 if (strncasecmp(content_type, "multipart/mixed", 15))
08599 return 0;
08600
08601
08602 if ((search = strcasestr(content_type, ";boundary=")))
08603 search += 10;
08604 else if ((search = strcasestr(content_type, "; boundary=")))
08605 search += 11;
08606 else
08607 return 0;
08608
08609 if (ast_strlen_zero(search))
08610 return 0;
08611
08612
08613 if (*search == '\"') {
08614 search++;
08615 boundaryisquoted = TRUE;
08616 }
08617
08618
08619
08620 boundary = ast_strdupa(search - 2);
08621 boundary[0] = boundary[1] = '-';
08622
08623 if (boundaryisquoted)
08624 boundary[strlen(boundary) - 1] = '\0';
08625
08626
08627
08628
08629 for (x = 0; x < (req->lines); x++) {
08630 const char *line = REQ_OFFSET_TO_STR(req, line[x]);
08631 if (!strncasecmp(line, boundary, strlen(boundary))){
08632 if (found_application_sdp && found_end_of_headers) {
08633 req->sdp_count = (x - 1) - req->sdp_start;
08634 return 1;
08635 }
08636 found_application_sdp = FALSE;
08637 }
08638 if (!strcasecmp(line, "Content-Type: application/sdp"))
08639 found_application_sdp = TRUE;
08640
08641 if (ast_strlen_zero(line)) {
08642 if (found_application_sdp && !found_end_of_headers){
08643 req->sdp_start = x;
08644 found_end_of_headers = TRUE;
08645 }
08646 }
08647 }
08648 if (found_application_sdp && found_end_of_headers) {
08649 req->sdp_count = x - req->sdp_start;
08650 return TRUE;
08651 }
08652 return FALSE;
08653 }
08654
08655
08656 static void change_hold_state(struct sip_pvt *dialog, struct sip_request *req, int holdstate, int sendonly)
08657 {
08658 if (sip_cfg.notifyhold && (!holdstate || !ast_test_flag(&dialog->flags[1], SIP_PAGE2_CALL_ONHOLD)))
08659 sip_peer_hold(dialog, holdstate);
08660 if (sip_cfg.callevents)
08661 manager_event(EVENT_FLAG_CALL, "Hold",
08662 "Status: %s\r\n"
08663 "Channel: %s\r\n"
08664 "Uniqueid: %s\r\n",
08665 holdstate ? "On" : "Off",
08666 dialog->owner->name,
08667 dialog->owner->uniqueid);
08668 append_history(dialog, holdstate ? "Hold" : "Unhold", "%s", req->data->str);
08669 if (!holdstate) {
08670 ast_clear_flag(&dialog->flags[1], SIP_PAGE2_CALL_ONHOLD);
08671 return;
08672 }
08673
08674
08675 if (sendonly == 1)
08676 ast_set_flag(&dialog->flags[1], SIP_PAGE2_CALL_ONHOLD_ONEDIR);
08677 else if (sendonly == 2)
08678 ast_set_flag(&dialog->flags[1], SIP_PAGE2_CALL_ONHOLD_INACTIVE);
08679 else
08680 ast_set_flag(&dialog->flags[1], SIP_PAGE2_CALL_ONHOLD_ACTIVE);
08681 return;
08682 }
08683
08684
08685 static int get_ip_and_port_from_sdp(struct sip_request *req, const enum media_type media, struct ast_sockaddr *addr)
08686 {
08687 const char *m;
08688 const char *c;
08689 int miterator = req->sdp_start;
08690 int citerator = req->sdp_start;
08691 int x = 0;
08692 int numberofports;
08693 int len;
08694 int af;
08695 char proto[4], host[258] = "";
08696
08697 c = get_sdp_iterate(&citerator, req, "c");
08698 if (sscanf(c, "IN %3s %256s", proto, host) != 2) {
08699 ast_log(LOG_WARNING, "Invalid host in c= line, '%s'\n", c);
08700
08701 }
08702
08703 for (m = get_sdp_iterate(&miterator, req, "m"); !ast_strlen_zero(m); m = get_sdp_iterate(&miterator, req, "m")) {
08704 if ((media == SDP_AUDIO && ((sscanf(m, "audio %30u/%30u RTP/AVP %n", &x, &numberofports, &len) == 2 && len > 0) ||
08705 (sscanf(m, "audio %30u RTP/AVP %n", &x, &len) == 1 && len > 0))) ||
08706 (media == SDP_VIDEO && ((sscanf(m, "video %30u/%30u RTP/AVP %n", &x, &numberofports, &len) == 2 && len > 0) ||
08707 (sscanf(m, "video %30u RTP/AVP %n", &x, &len) == 1 && len > 0)))) {
08708
08709
08710
08711
08712 c = get_sdp_iterate(&citerator, req, "c");
08713 if (!ast_strlen_zero(c)) {
08714 sscanf(c, "IN %3s %256s", proto, host);
08715 }
08716 break;
08717 }
08718 }
08719
08720 if (!strcmp("IP4", proto)) {
08721 af = AF_INET;
08722 } else if (!strcmp("IP6", proto)) {
08723 af = AF_INET6;
08724 } else {
08725 ast_log(LOG_WARNING, "Unknown protocol '%s'.\n", proto);
08726 return -1;
08727 }
08728
08729 if (ast_strlen_zero(host) || x == 0) {
08730 ast_log(LOG_WARNING, "Failed to read an alternate host or port in SDP. Expect %s problems\n", media == SDP_AUDIO ? "audio" : "video");
08731 return -1;
08732 }
08733
08734 if (ast_sockaddr_resolve_first_af(addr, host, 0, af)) {
08735 ast_log(LOG_WARNING, "Could not look up IP address of alternate hostname. Expect %s problems\n", media == SDP_AUDIO? "audio" : "video");
08736 return -1;
08737 }
08738
08739 return 0;
08740 }
08741
08742
08743
08744
08745
08746
08747
08748 static int sockaddr_is_null_or_any(const struct ast_sockaddr *addr)
08749 {
08750 return ast_sockaddr_isnull(addr) || ast_sockaddr_is_any(addr);
08751 }
08752
08753
08754
08755
08756
08757
08758 static int process_sdp(struct sip_pvt *p, struct sip_request *req, int t38action)
08759 {
08760
08761 int start = req->sdp_start;
08762 int next = start;
08763 int iterator = start;
08764
08765
08766 char type = '\0';
08767 const char *value = NULL;
08768 const char *m = NULL;
08769 const char *nextm = NULL;
08770 int len = -1;
08771
08772
08773 struct ast_sockaddr sessionsa;
08774 struct ast_sockaddr audiosa;
08775 struct ast_sockaddr videosa;
08776 struct ast_sockaddr textsa;
08777 struct ast_sockaddr imagesa;
08778 struct ast_sockaddr *sa = NULL;
08779 struct ast_sockaddr *vsa = NULL;
08780 struct ast_sockaddr *tsa = NULL;
08781 struct ast_sockaddr *isa = NULL;
08782 int portno = -1;
08783 int vportno = -1;
08784 int tportno = -1;
08785 int udptlportno = -1;
08786
08787
08788 format_t peercapability = 0, vpeercapability = 0, tpeercapability = 0;
08789 int peernoncodeccapability = 0, vpeernoncodeccapability = 0, tpeernoncodeccapability = 0;
08790
08791 struct ast_rtp_codecs newaudiortp, newvideortp, newtextrtp;
08792 format_t newjointcapability;
08793 format_t newpeercapability;
08794 int newnoncodeccapability;
08795
08796 const char *codecs;
08797 int codec;
08798
08799
08800 int secure_audio = FALSE;
08801 int secure_video = FALSE;
08802
08803
08804 int sendonly = -1;
08805 int vsendonly = -1;
08806 int numberofports;
08807 int numberofmediastreams = 0;
08808 int last_rtpmap_codec = 0;
08809 int red_data_pt[10];
08810 int red_num_gen = 0;
08811 char red_fmtp[100] = "empty";
08812 int debug = sip_debug_test_pvt(p);
08813
08814
08815 char buf[SIPBUFSIZE];
08816
08817
08818
08819 if (!p->rtp) {
08820 ast_log(LOG_ERROR, "Got SDP but have no RTP session allocated.\n");
08821 return -1;
08822 }
08823
08824
08825 ast_rtp_codecs_payloads_clear(&newaudiortp, NULL);
08826 ast_rtp_codecs_payloads_clear(&newvideortp, NULL);
08827 ast_rtp_codecs_payloads_clear(&newtextrtp, NULL);
08828
08829
08830 p->lastrtprx = p->lastrtptx = time(NULL);
08831
08832 memset(p->offered_media, 0, sizeof(p->offered_media));
08833
08834
08835
08836 p->novideo = TRUE;
08837 p->notext = TRUE;
08838
08839 if (p->vrtp) {
08840 ast_rtp_codecs_payloads_clear(&newvideortp, NULL);
08841 }
08842
08843 if (p->trtp) {
08844 ast_rtp_codecs_payloads_clear(&newtextrtp, NULL);
08845 }
08846
08847
08848 nextm = get_sdp_iterate(&next, req, "m");
08849 if (ast_strlen_zero(nextm)) {
08850 ast_log(LOG_WARNING, "Insufficient information for SDP (m= not found)\n");
08851 return -1;
08852 }
08853
08854
08855 while ((type = get_sdp_line(&iterator, next - 1, req, &value)) != '\0') {
08856 int processed = FALSE;
08857 switch (type) {
08858 case 'o':
08859
08860
08861
08862 if (!process_sdp_o(value, p))
08863 return (p->session_modify == FALSE) ? 0 : -1;
08864 break;
08865 case 'c':
08866 if (process_sdp_c(value, &sessionsa)) {
08867 processed = TRUE;
08868 sa = &sessionsa;
08869 vsa = sa;
08870 tsa = sa;
08871 isa = sa;
08872 }
08873 break;
08874 case 'a':
08875 if (process_sdp_a_sendonly(value, &sendonly)) {
08876 processed = TRUE;
08877 vsendonly = sendonly;
08878 }
08879 else if (process_sdp_a_audio(value, p, &newaudiortp, &last_rtpmap_codec))
08880 processed = TRUE;
08881 else if (process_sdp_a_video(value, p, &newvideortp, &last_rtpmap_codec))
08882 processed = TRUE;
08883 else if (process_sdp_a_text(value, p, &newtextrtp, red_fmtp, &red_num_gen, red_data_pt, &last_rtpmap_codec))
08884 processed = TRUE;
08885 else if (process_sdp_a_image(value, p))
08886 processed = TRUE;
08887 break;
08888 }
08889
08890 ast_debug(3, "Processing session-level SDP %c=%s... %s\n", type, value, (processed == TRUE)? "OK." : "UNSUPPORTED.");
08891 }
08892
08893
08894
08895
08896 while (!ast_strlen_zero(nextm)) {
08897 int audio = FALSE;
08898 int video = FALSE;
08899 int image = FALSE;
08900 int text = FALSE;
08901 char protocol[5] = {0,};
08902 int x;
08903
08904 numberofports = 1;
08905 len = -1;
08906 start = next;
08907 m = nextm;
08908 iterator = next;
08909 nextm = get_sdp_iterate(&next, req, "m");
08910
08911
08912 if ((sscanf(m, "audio %30u/%30u RTP/%4s %n", &x, &numberofports, protocol, &len) == 3 && len > 0) ||
08913 (sscanf(m, "audio %30u RTP/%4s %n", &x, protocol, &len) == 2 && len > 0)) {
08914 if (x == 0) {
08915 ast_log(LOG_WARNING, "ignoring 'audio' media offer because port number is zero");
08916 continue;
08917 }
08918 if (!strcmp(protocol, "SAVP")) {
08919 secure_audio = 1;
08920 } else if (strcmp(protocol, "AVP")) {
08921 ast_log(LOG_WARNING, "unknown SDP media protocol in offer: %s\n", protocol);
08922 continue;
08923 }
08924 if (p->offered_media[SDP_AUDIO].order_offered) {
08925 ast_log(LOG_WARNING, "Multiple audio streams are not supported\n");
08926 return -3;
08927 }
08928 audio = TRUE;
08929 p->offered_media[SDP_AUDIO].order_offered = ++numberofmediastreams;
08930 portno = x;
08931
08932
08933 codecs = m + len;
08934 ast_copy_string(p->offered_media[SDP_AUDIO].codecs, codecs, sizeof(p->offered_media[SDP_AUDIO].codecs));
08935 for (; !ast_strlen_zero(codecs); codecs = ast_skip_blanks(codecs + len)) {
08936 if (sscanf(codecs, "%30u%n", &codec, &len) != 1) {
08937 ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
08938 return -1;
08939 }
08940 if (debug)
08941 ast_verbose("Found RTP audio format %d\n", codec);
08942
08943 ast_rtp_codecs_payloads_set_m_type(&newaudiortp, NULL, codec);
08944 }
08945
08946 } else if ((sscanf(m, "video %30u/%30u RTP/%4s %n", &x, &numberofports, protocol, &len) == 3 && len > 0) ||
08947 (sscanf(m, "video %30u RTP/%4s %n", &x, protocol, &len) == 2 && len > 0)) {
08948 if (x == 0) {
08949 ast_log(LOG_WARNING, "ignoring 'video' media offer because port number is zero");
08950 continue;
08951 }
08952 if (!strcmp(protocol, "SAVP")) {
08953 secure_video = 1;
08954 } else if (strcmp(protocol, "AVP")) {
08955 ast_log(LOG_WARNING, "unknown SDP media protocol in offer: %s\n", protocol);
08956 continue;
08957 }
08958 if (p->offered_media[SDP_VIDEO].order_offered) {
08959 ast_log(LOG_WARNING, "Multiple video streams are not supported\n");
08960 return -3;
08961 }
08962 video = TRUE;
08963 p->novideo = FALSE;
08964 p->offered_media[SDP_VIDEO].order_offered = ++numberofmediastreams;
08965 vportno = x;
08966
08967
08968 codecs = m + len;
08969 ast_copy_string(p->offered_media[SDP_VIDEO].codecs, codecs, sizeof(p->offered_media[SDP_VIDEO].codecs));
08970 for (; !ast_strlen_zero(codecs); codecs = ast_skip_blanks(codecs + len)) {
08971 if (sscanf(codecs, "%30u%n", &codec, &len) != 1) {
08972 ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
08973 return -1;
08974 }
08975 if (debug)
08976 ast_verbose("Found RTP video format %d\n", codec);
08977 ast_rtp_codecs_payloads_set_m_type(&newvideortp, NULL, codec);
08978 }
08979
08980 } else if ((sscanf(m, "text %30u/%30u RTP/AVP %n", &x, &numberofports, &len) == 2 && len > 0) ||
08981 (sscanf(m, "text %30u RTP/AVP %n", &x, &len) == 1 && len > 0)) {
08982 if (x == 0) {
08983 ast_log(LOG_WARNING, "ignoring 'text' media offer because port number is zero");
08984 continue;
08985 }
08986 if (p->offered_media[SDP_TEXT].order_offered) {
08987 ast_log(LOG_WARNING, "Multiple text streams are not supported\n");
08988 return -3;
08989 }
08990 text = TRUE;
08991 p->notext = FALSE;
08992 p->offered_media[SDP_TEXT].order_offered = ++numberofmediastreams;
08993 tportno = x;
08994
08995
08996 codecs = m + len;
08997 ast_copy_string(p->offered_media[SDP_TEXT].codecs, codecs, sizeof(p->offered_media[SDP_TEXT].codecs));
08998 for (; !ast_strlen_zero(codecs); codecs = ast_skip_blanks(codecs + len)) {
08999 if (sscanf(codecs, "%30u%n", &codec, &len) != 1) {
09000 ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
09001 return -1;
09002 }
09003 if (debug)
09004 ast_verbose("Found RTP text format %d\n", codec);
09005 ast_rtp_codecs_payloads_set_m_type(&newtextrtp, NULL, codec);
09006 }
09007
09008 } else if (((sscanf(m, "image %30u udptl t38%n", &x, &len) == 1 && len > 0) ||
09009 (sscanf(m, "image %30u UDPTL t38%n", &x, &len) == 1 && len > 0))) {
09010 if (x == 0) {
09011 ast_log(LOG_WARNING, "ignoring 'image' media offer because port number is zero");
09012 continue;
09013 }
09014 if (initialize_udptl(p)) {
09015 continue;
09016 }
09017
09018 if (p->offered_media[SDP_IMAGE].order_offered) {
09019 ast_log(LOG_WARNING, "Multiple T.38 streams are not supported\n");
09020 return -3;
09021 }
09022 image = TRUE;
09023 if (debug)
09024 ast_verbose("Got T.38 offer in SDP in dialog %s\n", p->callid);
09025 p->offered_media[SDP_IMAGE].order_offered = ++numberofmediastreams;
09026 udptlportno = x;
09027
09028 if (p->t38.state != T38_ENABLED) {
09029 memset(&p->t38.their_parms, 0, sizeof(p->t38.their_parms));
09030
09031
09032
09033 ast_udptl_set_error_correction_scheme(p->udptl, UDPTL_ERROR_CORRECTION_NONE);
09034 }
09035 } else {
09036 ast_log(LOG_WARNING, "Unsupported SDP media type in offer: %s\n", m);
09037 continue;
09038 }
09039
09040
09041 if (numberofports > 1)
09042 ast_log(LOG_WARNING, "SDP offered %d ports for media, not supported by Asterisk. Will try anyway...\n", numberofports);
09043
09044
09045 while ((type = get_sdp_line(&iterator, next - 1, req, &value)) != '\0') {
09046 int processed = FALSE;
09047
09048 switch (type) {
09049 case 'c':
09050 if (audio) {
09051 if (process_sdp_c(value, &audiosa)) {
09052 processed = TRUE;
09053 sa = &audiosa;
09054 }
09055 } else if (video) {
09056 if (process_sdp_c(value, &videosa)) {
09057 processed = TRUE;
09058 vsa = &videosa;
09059 }
09060 } else if (text) {
09061 if (process_sdp_c(value, &textsa)) {
09062 processed = TRUE;
09063 tsa = &textsa;
09064 }
09065 } else if (image) {
09066 if (process_sdp_c(value, &imagesa)) {
09067 processed = TRUE;
09068 isa = &imagesa;
09069 }
09070 }
09071 break;
09072 case 'a':
09073
09074 if (audio) {
09075 if (process_sdp_a_sendonly(value, &sendonly))
09076 processed = TRUE;
09077 else if (process_crypto(p, p->rtp, &p->srtp, value))
09078 processed = TRUE;
09079 else if (process_sdp_a_audio(value, p, &newaudiortp, &last_rtpmap_codec))
09080 processed = TRUE;
09081 }
09082
09083 else if (video) {
09084 if (process_sdp_a_sendonly(value, &vsendonly))
09085 processed = TRUE;
09086 else if (process_crypto(p, p->vrtp, &p->vsrtp, value))
09087 processed = TRUE;
09088 else if (process_sdp_a_video(value, p, &newvideortp, &last_rtpmap_codec))
09089 processed = TRUE;
09090 }
09091
09092 else if (text) {
09093 if (process_sdp_a_text(value, p, &newtextrtp, red_fmtp, &red_num_gen, red_data_pt, &last_rtpmap_codec))
09094 processed = TRUE;
09095 else if (process_crypto(p, p->trtp, &p->tsrtp, value))
09096 processed = TRUE;
09097 }
09098
09099 else if (image) {
09100 if (process_sdp_a_image(value, p))
09101 processed = TRUE;
09102 }
09103 break;
09104 }
09105
09106 ast_debug(3, "Processing media-level (%s) SDP %c=%s... %s\n",
09107 (audio == TRUE)? "audio" : (video == TRUE)? "video" : "image",
09108 type, value,
09109 (processed == TRUE)? "OK." : "UNSUPPORTED.");
09110 }
09111 }
09112
09113
09114
09115 if (!sa && !vsa && !tsa && !isa) {
09116 ast_log(LOG_WARNING, "Insufficient information in SDP (c=)...\n");
09117 return -1;
09118 }
09119
09120 if (portno == -1 && vportno == -1 && udptlportno == -1 && tportno == -1) {
09121
09122
09123 ast_log(LOG_WARNING, "Failing due to no acceptable offer found\n");
09124 return -2;
09125 }
09126
09127 if (secure_audio && !(p->srtp && (ast_test_flag(p->srtp, SRTP_CRYPTO_OFFER_OK)))) {
09128 ast_log(LOG_WARNING, "Can't provide secure audio requested in SDP offer\n");
09129 return -4;
09130 }
09131
09132 if (!secure_audio && p->srtp) {
09133 ast_log(LOG_WARNING, "We are requesting SRTP, but they responded without it!\n");
09134 return -4;
09135 }
09136
09137 if (secure_video && !(p->vsrtp && (ast_test_flag(p->vsrtp, SRTP_CRYPTO_OFFER_OK)))) {
09138 ast_log(LOG_WARNING, "Can't provide secure video requested in SDP offer\n");
09139 return -4;
09140 }
09141
09142 if (!p->novideo && !secure_video && p->vsrtp) {
09143 ast_log(LOG_WARNING, "We are requesting SRTP, but they responded without it!\n");
09144 return -4;
09145 }
09146
09147 if (!(secure_audio || secure_video) && ast_test_flag(&p->flags[1], SIP_PAGE2_USE_SRTP)) {
09148 ast_log(LOG_WARNING, "Matched device setup to use SRTP, but request was not!\n");
09149 return -4;
09150 }
09151
09152 if (udptlportno == -1) {
09153 change_t38_state(p, T38_DISABLED);
09154 }
09155
09156
09157 ast_rtp_codecs_payload_formats(&newaudiortp, &peercapability, &peernoncodeccapability);
09158 ast_rtp_codecs_payload_formats(&newvideortp, &vpeercapability, &vpeernoncodeccapability);
09159 ast_rtp_codecs_payload_formats(&newtextrtp, &tpeercapability, &tpeernoncodeccapability);
09160
09161 newjointcapability = p->capability & (peercapability | vpeercapability | tpeercapability);
09162 newpeercapability = (peercapability | vpeercapability | tpeercapability);
09163 newnoncodeccapability = p->noncodeccapability & peernoncodeccapability;
09164
09165 if (debug) {
09166
09167 char s1[SIPBUFSIZE], s2[SIPBUFSIZE], s3[SIPBUFSIZE], s4[SIPBUFSIZE], s5[SIPBUFSIZE];
09168
09169 ast_verbose("Capabilities: us - %s, peer - audio=%s/video=%s/text=%s, combined - %s\n",
09170 ast_getformatname_multiple(s1, SIPBUFSIZE, p->capability),
09171 ast_getformatname_multiple(s2, SIPBUFSIZE, peercapability),
09172 ast_getformatname_multiple(s3, SIPBUFSIZE, vpeercapability),
09173 ast_getformatname_multiple(s4, SIPBUFSIZE, tpeercapability),
09174 ast_getformatname_multiple(s5, SIPBUFSIZE, newjointcapability));
09175 }
09176 if (debug) {
09177 struct ast_str *s1 = ast_str_alloca(SIPBUFSIZE);
09178 struct ast_str *s2 = ast_str_alloca(SIPBUFSIZE);
09179 struct ast_str *s3 = ast_str_alloca(SIPBUFSIZE);
09180
09181 ast_verbose("Non-codec capabilities (dtmf): us - %s, peer - %s, combined - %s\n",
09182 ast_rtp_lookup_mime_multiple2(s1, p->noncodeccapability, 0, 0),
09183 ast_rtp_lookup_mime_multiple2(s2, peernoncodeccapability, 0, 0),
09184 ast_rtp_lookup_mime_multiple2(s3, newnoncodeccapability, 0, 0));
09185 }
09186 if (!newjointcapability && udptlportno == -1) {
09187 ast_log(LOG_NOTICE, "No compatible codecs, not accepting this offer!\n");
09188
09189 return -1;
09190 }
09191
09192 if (portno != -1 || vportno != -1 || tportno != -1) {
09193
09194
09195 p->jointcapability = newjointcapability;
09196 p->peercapability = newpeercapability;
09197 p->jointnoncodeccapability = newnoncodeccapability;
09198
09199
09200 if (ast_test_flag(&p->flags[1], SIP_PAGE2_PREFERRED_CODEC)) {
09201 p->jointcapability = ast_codec_choose(&p->prefs, p->jointcapability, 1);
09202 }
09203 }
09204
09205
09206 if (p->rtp) {
09207 if (portno > 0) {
09208 ast_sockaddr_set_port(sa, portno);
09209 ast_rtp_instance_set_remote_address(p->rtp, sa);
09210 if (debug) {
09211 ast_verbose("Peer audio RTP is at port %s\n",
09212 ast_sockaddr_stringify(sa));
09213 }
09214
09215 ast_rtp_codecs_payloads_copy(&newaudiortp, ast_rtp_instance_get_codecs(p->rtp), p->rtp);
09216
09217
09218 ast_rtp_instance_set_prop(p->rtp, AST_RTP_PROPERTY_RTCP, 1);
09219
09220 if (p->owner) {
09221 ast_channel_set_fd(p->owner, 1, ast_rtp_instance_fd(p->rtp, 1));
09222 }
09223
09224 if (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO) {
09225 ast_clear_flag(&p->flags[0], SIP_DTMF);
09226 if (newnoncodeccapability & AST_RTP_DTMF) {
09227
09228 ast_set_flag(&p->flags[0], SIP_DTMF_RFC2833);
09229
09230 ast_rtp_instance_set_prop(p->rtp, AST_RTP_PROPERTY_DTMF, 1);
09231 ast_rtp_instance_set_prop(p->rtp, AST_RTP_PROPERTY_DTMF_COMPENSATE, ast_test_flag(&p->flags[1], SIP_PAGE2_RFC2833_COMPENSATE));
09232 } else {
09233 ast_set_flag(&p->flags[0], SIP_DTMF_INBAND);
09234 }
09235 }
09236 } else if (udptlportno > 0) {
09237 if (debug)
09238 ast_verbose("Got T.38 Re-invite without audio. Keeping RTP active during T.38 session.\n");
09239
09240 if (p->owner) {
09241 ast_channel_set_fd(p->owner, 1, -1);
09242 }
09243
09244 ast_rtp_instance_set_prop(p->rtp, AST_RTP_PROPERTY_RTCP, 0);
09245 } else {
09246 ast_rtp_instance_stop(p->rtp);
09247 if (debug)
09248 ast_verbose("Peer doesn't provide audio\n");
09249 }
09250 }
09251
09252
09253 if (p->vrtp) {
09254 if (vportno > 0) {
09255 ast_sockaddr_set_port(vsa, vportno);
09256 ast_rtp_instance_set_remote_address(p->vrtp, vsa);
09257 if (debug) {
09258 ast_verbose("Peer video RTP is at port %s\n",
09259 ast_sockaddr_stringify(vsa));
09260 }
09261 ast_rtp_codecs_payloads_copy(&newvideortp, ast_rtp_instance_get_codecs(p->vrtp), p->vrtp);
09262 } else {
09263 ast_rtp_instance_stop(p->vrtp);
09264 if (debug)
09265 ast_verbose("Peer doesn't provide video\n");
09266 }
09267 }
09268
09269
09270 if (p->trtp) {
09271 if (tportno > 0) {
09272 ast_sockaddr_set_port(tsa, tportno);
09273 ast_rtp_instance_set_remote_address(p->trtp, tsa);
09274 if (debug) {
09275 ast_verbose("Peer T.140 RTP is at port %s\n",
09276 ast_sockaddr_stringify(tsa));
09277 }
09278 if ((p->jointcapability & AST_FORMAT_T140RED)) {
09279 p->red = 1;
09280 ast_rtp_red_init(p->trtp, 300, red_data_pt, 2);
09281 } else {
09282 p->red = 0;
09283 }
09284 ast_rtp_codecs_payloads_copy(&newtextrtp, ast_rtp_instance_get_codecs(p->trtp), p->trtp);
09285 } else {
09286 ast_rtp_instance_stop(p->trtp);
09287 if (debug)
09288 ast_verbose("Peer doesn't provide T.140\n");
09289 }
09290 }
09291
09292 if (p->udptl) {
09293 if (udptlportno > 0) {
09294 if (ast_test_flag(&p->flags[1], SIP_PAGE2_SYMMETRICRTP) && ast_test_flag(&p->flags[1], SIP_PAGE2_UDPTL_DESTINATION)) {
09295 ast_rtp_instance_get_remote_address(p->rtp, isa);
09296 if (!ast_sockaddr_isnull(isa) && debug) {
09297 ast_debug(1, "Peer T.38 UDPTL is set behind NAT and with destination, destination address now %s\n", ast_sockaddr_stringify(isa));
09298 }
09299 }
09300 ast_sockaddr_set_port(isa, udptlportno);
09301 ast_udptl_set_peer(p->udptl, isa);
09302 if (debug)
09303 ast_debug(1,"Peer T.38 UDPTL is at port %s\n", ast_sockaddr_stringify(isa));
09304
09305
09306 if (!ast_udptl_get_far_max_datagram(p->udptl)) {
09307
09308 ast_udptl_set_far_max_datagram(p->udptl, 0);
09309 }
09310
09311
09312 if ((t38action == SDP_T38_ACCEPT) &&
09313 (p->t38.state == T38_LOCAL_REINVITE)) {
09314 change_t38_state(p, T38_ENABLED);
09315 } else if ((t38action == SDP_T38_INITIATE) &&
09316 p->owner && p->lastinvite) {
09317 change_t38_state(p, T38_PEER_REINVITE);
09318
09319 if (ast_test_flag(&p->flags[1], SIP_PAGE2_FAX_DETECT_T38)) {
09320 ast_channel_lock(p->owner);
09321 if (strcmp(p->owner->exten, "fax")) {
09322 const char *target_context = S_OR(p->owner->macrocontext, p->owner->context);
09323 ast_channel_unlock(p->owner);
09324 if (ast_exists_extension(p->owner, target_context, "fax", 1,
09325 S_COR(p->owner->caller.id.number.valid, p->owner->caller.id.number.str, NULL))) {
09326 ast_verbose(VERBOSE_PREFIX_2 "Redirecting '%s' to fax extension due to peer T.38 re-INVITE\n", p->owner->name);
09327 pbx_builtin_setvar_helper(p->owner, "FAXEXTEN", p->owner->exten);
09328 if (ast_async_goto(p->owner, target_context, "fax", 1)) {
09329 ast_log(LOG_NOTICE, "Failed to async goto '%s' into fax of '%s'\n", p->owner->name, target_context);
09330 }
09331 } else {
09332 ast_log(LOG_NOTICE, "T.38 re-INVITE detected but no fax extension\n");
09333 }
09334 } else {
09335 ast_channel_unlock(p->owner);
09336 }
09337 }
09338 }
09339 } else {
09340 change_t38_state(p, T38_DISABLED);
09341 ast_udptl_stop(p->udptl);
09342 if (debug)
09343 ast_debug(1, "Peer doesn't provide T.38 UDPTL\n");
09344 }
09345 }
09346
09347 if ((portno == -1) && (p->t38.state != T38_DISABLED)) {
09348 ast_debug(3, "Have T.38 but no audio, accepting offer anyway\n");
09349 return 0;
09350 }
09351
09352
09353 ast_debug(2, "We're settling with these formats: %s\n", ast_getformatname_multiple(buf, SIPBUFSIZE, p->jointcapability));
09354
09355 if (!p->owner)
09356 return 0;
09357
09358 ast_debug(4, "We have an owner, now see if we need to change this call\n");
09359
09360 if (!(p->owner->nativeformats & p->jointcapability) && (p->jointcapability & AST_FORMAT_AUDIO_MASK)) {
09361 if (debug) {
09362 char s1[SIPBUFSIZE], s2[SIPBUFSIZE];
09363 ast_debug(1, "Oooh, we need to change our audio formats since our peer supports only %s and not %s\n",
09364 ast_getformatname_multiple(s1, SIPBUFSIZE, p->jointcapability),
09365 ast_getformatname_multiple(s2, SIPBUFSIZE, p->owner->nativeformats));
09366 }
09367 p->owner->nativeformats = ast_codec_choose(&p->prefs, p->jointcapability, 1) | (p->capability & vpeercapability) | (p->capability & tpeercapability);
09368 ast_set_read_format(p->owner, p->owner->readformat);
09369 ast_set_write_format(p->owner, p->owner->writeformat);
09370 }
09371
09372 if (ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD) && (!ast_sockaddr_isnull(sa) || !ast_sockaddr_isnull(vsa) || !ast_sockaddr_isnull(tsa) || !ast_sockaddr_isnull(isa)) && (!sendonly || sendonly == -1)) {
09373 ast_queue_control(p->owner, AST_CONTROL_UNHOLD);
09374
09375 ast_queue_frame(p->owner, &ast_null_frame);
09376 change_hold_state(p, req, FALSE, sendonly);
09377 } else if ((sockaddr_is_null_or_any(sa) && sockaddr_is_null_or_any(vsa) && sockaddr_is_null_or_any(tsa) && sockaddr_is_null_or_any(isa)) || (sendonly && sendonly != -1)) {
09378 ast_queue_control_data(p->owner, AST_CONTROL_HOLD,
09379 S_OR(p->mohsuggest, NULL),
09380 !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0);
09381 if (sendonly)
09382 ast_rtp_instance_stop(p->rtp);
09383
09384
09385 ast_queue_frame(p->owner, &ast_null_frame);
09386 change_hold_state(p, req, TRUE, sendonly);
09387 }
09388
09389 return 0;
09390 }
09391
09392 static int process_sdp_o(const char *o, struct sip_pvt *p)
09393 {
09394 char *o_copy;
09395 char *token;
09396 int64_t rua_version;
09397
09398
09399
09400
09401
09402
09403
09404
09405
09406
09407 p->session_modify = TRUE;
09408
09409 if (ast_strlen_zero(o)) {
09410 ast_log(LOG_WARNING, "SDP syntax error. SDP without an o= line\n");
09411 return FALSE;
09412 }
09413
09414 o_copy = ast_strdupa(o);
09415 token = strsep(&o_copy, " ");
09416 if (!o_copy) {
09417 ast_log(LOG_WARNING, "SDP syntax error in o= line username\n");
09418 return FALSE;
09419 }
09420 token = strsep(&o_copy, " ");
09421 if (!o_copy) {
09422 ast_log(LOG_WARNING, "SDP syntax error in o= line session-id\n");
09423 return FALSE;
09424 }
09425 token = strsep(&o_copy, " ");
09426 if (!o_copy) {
09427 ast_log(LOG_WARNING, "SDP syntax error in o= line\n");
09428 return FALSE;
09429 }
09430 if (!sscanf(token, "%30" SCNd64, &rua_version)) {
09431 ast_log(LOG_WARNING, "SDP syntax error in o= line version\n");
09432 return FALSE;
09433 }
09434
09435
09436
09437
09438
09439
09440
09441
09442
09443
09444
09445
09446
09447
09448
09449
09450
09451
09452
09453 if (ast_test_flag(&p->flags[1], SIP_PAGE2_IGNORESDPVERSION) ||
09454 (p->sessionversion_remote < 0) ||
09455 (p->sessionversion_remote < rua_version)) {
09456 p->sessionversion_remote = rua_version;
09457 } else {
09458 if (p->t38.state == T38_LOCAL_REINVITE) {
09459 p->sessionversion_remote = rua_version;
09460 ast_log(LOG_WARNING, "Call %s responded to our T.38 reinvite without changing SDP version; 'ignoresdpversion' should be set for this peer.\n", p->callid);
09461 } else {
09462 p->session_modify = FALSE;
09463 ast_debug(2, "Call %s responded to our reinvite without changing SDP version; ignoring SDP.\n", p->callid);
09464 return FALSE;
09465 }
09466 }
09467
09468 return TRUE;
09469 }
09470
09471 static int process_sdp_c(const char *c, struct ast_sockaddr *addr)
09472 {
09473 char proto[4], host[258];
09474 int af;
09475
09476
09477 if (sscanf(c, "IN %3s %255s", proto, host) == 2) {
09478 if (!strcmp("IP4", proto)) {
09479 af = AF_INET;
09480 } else if (!strcmp("IP6", proto)) {
09481 af = AF_INET6;
09482 } else {
09483 ast_log(LOG_WARNING, "Unknown protocol '%s'.\n", proto);
09484 return FALSE;
09485 }
09486 if (ast_sockaddr_resolve_first_af(addr, host, 0, af)) {
09487 ast_log(LOG_WARNING, "Unable to lookup RTP Audio host in c= line, '%s'\n", c);
09488 return FALSE;
09489 }
09490 return TRUE;
09491 } else {
09492 ast_log(LOG_WARNING, "Invalid host in c= line, '%s'\n", c);
09493 return FALSE;
09494 }
09495 return FALSE;
09496 }
09497
09498 static int process_sdp_a_sendonly(const char *a, int *sendonly)
09499 {
09500 int found = FALSE;
09501
09502 if (!strcasecmp(a, "sendonly")) {
09503 if (*sendonly == -1)
09504 *sendonly = 1;
09505 found = TRUE;
09506 } else if (!strcasecmp(a, "inactive")) {
09507 if (*sendonly == -1)
09508 *sendonly = 2;
09509 found = TRUE;
09510 } else if (!strcasecmp(a, "sendrecv")) {
09511 if (*sendonly == -1)
09512 *sendonly = 0;
09513 found = TRUE;
09514 }
09515 return found;
09516 }
09517
09518 static int process_sdp_a_audio(const char *a, struct sip_pvt *p, struct ast_rtp_codecs *newaudiortp, int *last_rtpmap_codec)
09519 {
09520 int found = FALSE;
09521 int codec;
09522 char mimeSubtype[128];
09523 char fmtp_string[64];
09524 unsigned int sample_rate;
09525 int debug = sip_debug_test_pvt(p);
09526
09527 if (!strncasecmp(a, "ptime", 5)) {
09528 char *tmp = strrchr(a, ':');
09529 long int framing = 0;
09530 if (tmp) {
09531 tmp++;
09532 framing = strtol(tmp, NULL, 10);
09533 if (framing == LONG_MIN || framing == LONG_MAX) {
09534 framing = 0;
09535 ast_debug(1, "Can't read framing from SDP: %s\n", a);
09536 }
09537 }
09538 if (framing && p->autoframing) {
09539 struct ast_codec_pref *pref = &ast_rtp_instance_get_codecs(p->rtp)->pref;
09540 int codec_n;
09541 for (codec_n = 0; codec_n < AST_RTP_MAX_PT; codec_n++) {
09542 struct ast_rtp_payload_type format = ast_rtp_codecs_payload_lookup(ast_rtp_instance_get_codecs(p->rtp), codec_n);
09543 if (!format.asterisk_format || !format.code)
09544 continue;
09545 ast_debug(1, "Setting framing for %s to %ld\n", ast_getformatname(format.code), framing);
09546 ast_codec_pref_setsize(pref, format.code, framing);
09547 }
09548 ast_rtp_codecs_packetization_set(ast_rtp_instance_get_codecs(p->rtp), p->rtp, pref);
09549 }
09550 found = TRUE;
09551 } else if (sscanf(a, "rtpmap: %30u %127[^/]/%30u", &codec, mimeSubtype, &sample_rate) == 3) {
09552
09553 if (*last_rtpmap_codec < SDP_MAX_RTPMAP_CODECS) {
09554 if (!(ast_rtp_codecs_payloads_set_rtpmap_type_rate(newaudiortp, NULL, codec, "audio", mimeSubtype,
09555 ast_test_flag(&p->flags[0], SIP_G726_NONSTANDARD) ? AST_RTP_OPT_G726_NONSTANDARD : 0, sample_rate))) {
09556 if (debug)
09557 ast_verbose("Found audio description format %s for ID %d\n", mimeSubtype, codec);
09558
09559 (*last_rtpmap_codec)++;
09560 found = TRUE;
09561 } else {
09562 ast_rtp_codecs_payloads_unset(newaudiortp, NULL, codec);
09563 if (debug)
09564 ast_verbose("Found unknown media description format %s for ID %d\n", mimeSubtype, codec);
09565 }
09566 } else {
09567 if (debug)
09568 ast_verbose("Discarded description format %s for ID %d\n", mimeSubtype, codec);
09569 }
09570 } else if (sscanf(a, "fmtp: %30u %63s", &codec, fmtp_string) == 2) {
09571 struct ast_rtp_payload_type payload;
09572
09573 payload = ast_rtp_codecs_payload_lookup(newaudiortp, codec);
09574 if (payload.code && payload.asterisk_format) {
09575 unsigned int bit_rate;
09576
09577 switch (payload.code) {
09578 case AST_FORMAT_SIREN7:
09579 if (sscanf(fmtp_string, "bitrate=%30u", &bit_rate) == 1) {
09580 if (bit_rate != 32000) {
09581 ast_log(LOG_WARNING, "Got Siren7 offer at %d bps, but only 32000 bps supported; ignoring.\n", bit_rate);
09582 ast_rtp_codecs_payloads_unset(newaudiortp, NULL, codec);
09583 } else {
09584 found = TRUE;
09585 }
09586 }
09587 break;
09588 case AST_FORMAT_SIREN14:
09589 if (sscanf(fmtp_string, "bitrate=%30u", &bit_rate) == 1) {
09590 if (bit_rate != 48000) {
09591 ast_log(LOG_WARNING, "Got Siren14 offer at %d bps, but only 48000 bps supported; ignoring.\n", bit_rate);
09592 ast_rtp_codecs_payloads_unset(newaudiortp, NULL, codec);
09593 } else {
09594 found = TRUE;
09595 }
09596 }
09597 break;
09598 case AST_FORMAT_G719:
09599 if (sscanf(fmtp_string, "bitrate=%30u", &bit_rate) == 1) {
09600 if (bit_rate != 64000) {
09601 ast_log(LOG_WARNING, "Got G.719 offer at %d bps, but only 64000 bps supported; ignoring.\n", bit_rate);
09602 ast_rtp_codecs_payloads_unset(newaudiortp, NULL, codec);
09603 } else {
09604 found = TRUE;
09605 }
09606 }
09607 }
09608 }
09609 }
09610
09611 return found;
09612 }
09613
09614 static int process_sdp_a_video(const char *a, struct sip_pvt *p, struct ast_rtp_codecs *newvideortp, int *last_rtpmap_codec)
09615 {
09616 int found = FALSE;
09617 int codec;
09618 char mimeSubtype[128];
09619 unsigned int sample_rate;
09620 int debug = sip_debug_test_pvt(p);
09621
09622 if (sscanf(a, "rtpmap: %30u %127[^/]/%30u", &codec, mimeSubtype, &sample_rate) == 3) {
09623
09624 if (*last_rtpmap_codec < SDP_MAX_RTPMAP_CODECS) {
09625
09626 if (!strncasecmp(mimeSubtype, "H26", 3) || !strncasecmp(mimeSubtype, "MP4", 3)) {
09627 if (!(ast_rtp_codecs_payloads_set_rtpmap_type_rate(newvideortp, NULL, codec, "video", mimeSubtype, 0, sample_rate))) {
09628 if (debug)
09629 ast_verbose("Found video description format %s for ID %d\n", mimeSubtype, codec);
09630
09631 (*last_rtpmap_codec)++;
09632 found = TRUE;
09633 } else {
09634 ast_rtp_codecs_payloads_unset(newvideortp, NULL, codec);
09635 if (debug)
09636 ast_verbose("Found unknown media description format %s for ID %d\n", mimeSubtype, codec);
09637 }
09638 }
09639 } else {
09640 if (debug)
09641 ast_verbose("Discarded description format %s for ID %d\n", mimeSubtype, codec);
09642 }
09643 }
09644
09645 return found;
09646 }
09647
09648 static int process_sdp_a_text(const char *a, struct sip_pvt *p, struct ast_rtp_codecs *newtextrtp, char *red_fmtp, int *red_num_gen, int *red_data_pt, int *last_rtpmap_codec)
09649 {
09650 int found = FALSE;
09651 int codec;
09652 char mimeSubtype[128];
09653 unsigned int sample_rate;
09654 char *red_cp;
09655 int debug = sip_debug_test_pvt(p);
09656
09657 if (sscanf(a, "rtpmap: %30u %127[^/]/%30u", &codec, mimeSubtype, &sample_rate) == 3) {
09658
09659 if (*last_rtpmap_codec < SDP_MAX_RTPMAP_CODECS) {
09660 if (!strncasecmp(mimeSubtype, "T140", 4)) {
09661 if (p->trtp) {
09662
09663 ast_rtp_codecs_payloads_set_rtpmap_type_rate(newtextrtp, NULL, codec, "text", mimeSubtype, 0, sample_rate);
09664 found = TRUE;
09665 }
09666 } else if (!strncasecmp(mimeSubtype, "RED", 3)) {
09667 if (p->trtp) {
09668 ast_rtp_codecs_payloads_set_rtpmap_type_rate(newtextrtp, NULL, codec, "text", mimeSubtype, 0, sample_rate);
09669 sprintf(red_fmtp, "fmtp:%d ", codec);
09670 if (debug)
09671 ast_verbose("RED submimetype has payload type: %d\n", codec);
09672 found = TRUE;
09673 }
09674 }
09675 } else {
09676 if (debug)
09677 ast_verbose("Discarded description format %s for ID %d\n", mimeSubtype, codec);
09678 }
09679 } else if (!strncmp(a, red_fmtp, strlen(red_fmtp))) {
09680
09681 red_cp = &red_fmtp[strlen(red_fmtp)];
09682 strncpy(red_fmtp, a, 100);
09683
09684 sscanf(red_cp, "%30u", &red_data_pt[*red_num_gen]);
09685 red_cp = strtok(red_cp, "/");
09686 while (red_cp && (*red_num_gen)++ < AST_RED_MAX_GENERATION) {
09687 sscanf(red_cp, "%30u", &red_data_pt[*red_num_gen]);
09688 red_cp = strtok(NULL, "/");
09689 }
09690 red_cp = red_fmtp;
09691 found = TRUE;
09692 }
09693
09694 return found;
09695 }
09696
09697 static int process_sdp_a_image(const char *a, struct sip_pvt *p)
09698 {
09699 int found = FALSE;
09700 char s[256];
09701 unsigned int x;
09702
09703 if (initialize_udptl(p)) {
09704 return found;
09705 }
09706
09707 if ((sscanf(a, "T38FaxMaxBuffer:%30u", &x) == 1)) {
09708 ast_debug(3, "MaxBufferSize:%d\n", x);
09709 found = TRUE;
09710 } else if ((sscanf(a, "T38MaxBitRate:%30u", &x) == 1) || (sscanf(a, "T38FaxMaxRate:%30u", &x) == 1)) {
09711 ast_debug(3, "T38MaxBitRate: %d\n", x);
09712 switch (x) {
09713 case 14400:
09714 p->t38.their_parms.rate = AST_T38_RATE_14400;
09715 break;
09716 case 12000:
09717 p->t38.their_parms.rate = AST_T38_RATE_12000;
09718 break;
09719 case 9600:
09720 p->t38.their_parms.rate = AST_T38_RATE_9600;
09721 break;
09722 case 7200:
09723 p->t38.their_parms.rate = AST_T38_RATE_7200;
09724 break;
09725 case 4800:
09726 p->t38.their_parms.rate = AST_T38_RATE_4800;
09727 break;
09728 case 2400:
09729 p->t38.their_parms.rate = AST_T38_RATE_2400;
09730 break;
09731 }
09732 found = TRUE;
09733 } else if ((sscanf(a, "T38FaxVersion:%30u", &x) == 1)) {
09734 ast_debug(3, "FaxVersion: %u\n", x);
09735 p->t38.their_parms.version = x;
09736 found = TRUE;
09737 } else if ((sscanf(a, "T38FaxMaxDatagram:%30u", &x) == 1) || (sscanf(a, "T38MaxDatagram:%30u", &x) == 1)) {
09738
09739 if (((signed int) p->t38_maxdatagram >= 0) && ((unsigned int) p->t38_maxdatagram > x)) {
09740 ast_debug(1, "Overriding T38FaxMaxDatagram '%d' with '%d'\n", x, p->t38_maxdatagram);
09741 x = p->t38_maxdatagram;
09742 }
09743 ast_debug(3, "FaxMaxDatagram: %u\n", x);
09744 ast_udptl_set_far_max_datagram(p->udptl, x);
09745 found = TRUE;
09746 } else if ((strncmp(a, "T38FaxFillBitRemoval", 20) == 0)) {
09747 if (sscanf(a, "T38FaxFillBitRemoval:%30u", &x) == 1) {
09748 ast_debug(3, "FillBitRemoval: %d\n", x);
09749 if (x == 1) {
09750 p->t38.their_parms.fill_bit_removal = TRUE;
09751 }
09752 } else {
09753 ast_debug(3, "FillBitRemoval\n");
09754 p->t38.their_parms.fill_bit_removal = TRUE;
09755 }
09756 found = TRUE;
09757 } else if ((strncmp(a, "T38FaxTranscodingMMR", 20) == 0)) {
09758 if (sscanf(a, "T38FaxTranscodingMMR:%30u", &x) == 1) {
09759 ast_debug(3, "Transcoding MMR: %d\n", x);
09760 if (x == 1) {
09761 p->t38.their_parms.transcoding_mmr = TRUE;
09762 }
09763 } else {
09764 ast_debug(3, "Transcoding MMR\n");
09765 p->t38.their_parms.transcoding_mmr = TRUE;
09766 }
09767 found = TRUE;
09768 } else if ((strncmp(a, "T38FaxTranscodingJBIG", 21) == 0)) {
09769 if (sscanf(a, "T38FaxTranscodingJBIG:%30u", &x) == 1) {
09770 ast_debug(3, "Transcoding JBIG: %d\n", x);
09771 if (x == 1) {
09772 p->t38.their_parms.transcoding_jbig = TRUE;
09773 }
09774 } else {
09775 ast_debug(3, "Transcoding JBIG\n");
09776 p->t38.their_parms.transcoding_jbig = TRUE;
09777 }
09778 found = TRUE;
09779 } else if ((sscanf(a, "T38FaxRateManagement:%255s", s) == 1)) {
09780 ast_debug(3, "RateManagement: %s\n", s);
09781 if (!strcasecmp(s, "localTCF"))
09782 p->t38.their_parms.rate_management = AST_T38_RATE_MANAGEMENT_LOCAL_TCF;
09783 else if (!strcasecmp(s, "transferredTCF"))
09784 p->t38.their_parms.rate_management = AST_T38_RATE_MANAGEMENT_TRANSFERRED_TCF;
09785 found = TRUE;
09786 } else if ((sscanf(a, "T38FaxUdpEC:%255s", s) == 1)) {
09787 ast_debug(3, "UDP EC: %s\n", s);
09788 if (!strcasecmp(s, "t38UDPRedundancy")) {
09789 ast_udptl_set_error_correction_scheme(p->udptl, UDPTL_ERROR_CORRECTION_REDUNDANCY);
09790 } else if (!strcasecmp(s, "t38UDPFEC")) {
09791 ast_udptl_set_error_correction_scheme(p->udptl, UDPTL_ERROR_CORRECTION_FEC);
09792 } else {
09793 ast_udptl_set_error_correction_scheme(p->udptl, UDPTL_ERROR_CORRECTION_NONE);
09794 }
09795 found = TRUE;
09796 }
09797
09798 return found;
09799 }
09800
09801
09802
09803
09804 static int add_supported_header(struct sip_pvt *pvt, struct sip_request *req)
09805 {
09806 int res;
09807 if (st_get_mode(pvt, 0) != SESSION_TIMER_MODE_REFUSE) {
09808 res = add_header(req, "Supported", "replaces, timer");
09809 } else {
09810 res = add_header(req, "Supported", "replaces");
09811 }
09812 return res;
09813 }
09814
09815
09816 static int add_header(struct sip_request *req, const char *var, const char *value)
09817 {
09818 if (req->headers == SIP_MAX_HEADERS) {
09819 ast_log(LOG_WARNING, "Out of SIP header space\n");
09820 return -1;
09821 }
09822
09823 if (req->lines) {
09824 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
09825 return -1;
09826 }
09827
09828 if (sip_cfg.compactheaders) {
09829 var = find_alias(var, var);
09830 }
09831
09832 ast_str_append(&req->data, 0, "%s: %s\r\n", var, value);
09833 req->header[req->headers] = ast_str_strlen(req->data);
09834
09835 req->headers++;
09836
09837 return 0;
09838 }
09839
09840
09841
09842
09843
09844 static int add_header_max_forwards(struct sip_pvt *dialog, struct sip_request *req)
09845 {
09846 char clen[10];
09847
09848 snprintf(clen, sizeof(clen), "%d", dialog->maxforwards);
09849
09850 return add_header(req, "Max-Forwards", clen);
09851 }
09852
09853
09854 static int finalize_content(struct sip_request *req)
09855 {
09856 char clen[10];
09857
09858 if (req->lines) {
09859 ast_log(LOG_WARNING, "finalize_content() called on a message that has already been finalized\n");
09860 return -1;
09861 }
09862
09863 snprintf(clen, sizeof(clen), "%zd", ast_str_strlen(req->content));
09864 add_header(req, "Content-Length", clen);
09865
09866 if (ast_str_strlen(req->content)) {
09867 ast_str_append(&req->data, 0, "\r\n%s", ast_str_buffer(req->content));
09868 }
09869 req->lines = ast_str_strlen(req->content) ? 1 : 0;
09870 return 0;
09871 }
09872
09873
09874 static int add_content(struct sip_request *req, const char *line)
09875 {
09876 if (req->lines) {
09877 ast_log(LOG_WARNING, "Can't add more content when the content has been finalized\n");
09878 return -1;
09879 }
09880
09881 ast_str_append(&req->content, 0, "%s", line);
09882 return 0;
09883 }
09884
09885
09886 static int copy_header(struct sip_request *req, const struct sip_request *orig, const char *field)
09887 {
09888 const char *tmp = get_header(orig, field);
09889
09890 if (!ast_strlen_zero(tmp))
09891 return add_header(req, field, tmp);
09892 ast_log(LOG_NOTICE, "No field '%s' present to copy\n", field);
09893 return -1;
09894 }
09895
09896
09897 static int copy_all_header(struct sip_request *req, const struct sip_request *orig, const char *field)
09898 {
09899 int start = 0;
09900 int copied = 0;
09901 for (;;) {
09902 const char *tmp = __get_header(orig, field, &start);
09903
09904 if (ast_strlen_zero(tmp))
09905 break;
09906
09907 add_header(req, field, tmp);
09908 copied++;
09909 }
09910 return copied ? 0 : -1;
09911 }
09912
09913
09914
09915
09916
09917
09918
09919
09920
09921 static int copy_via_headers(struct sip_pvt *p, struct sip_request *req, const struct sip_request *orig, const char *field)
09922 {
09923 int copied = 0;
09924 int start = 0;
09925
09926 for (;;) {
09927 char new[512];
09928 const char *oh = __get_header(orig, field, &start);
09929
09930 if (ast_strlen_zero(oh))
09931 break;
09932
09933 if (!copied) {
09934 char leftmost[512], *others, *rport;
09935
09936
09937 ast_copy_string(leftmost, oh, sizeof(leftmost));
09938 others = strchr(leftmost, ',');
09939 if (others)
09940 *others++ = '\0';
09941
09942
09943 rport = strstr(leftmost, ";rport");
09944 if (rport && *(rport+6) == '=')
09945 rport = NULL;
09946
09947 if (((ast_test_flag(&p->flags[0], SIP_NAT_FORCE_RPORT)) || (rport && ast_test_flag(&p->flags[0], SIP_NAT_RPORT_PRESENT)))) {
09948
09949 char *end;
09950
09951 rport = strstr(leftmost, ";rport");
09952
09953 if (rport) {
09954 end = strchr(rport + 1, ';');
09955 if (end)
09956 memmove(rport, end, strlen(end) + 1);
09957 else
09958 *rport = '\0';
09959 }
09960
09961
09962 snprintf(new, sizeof(new), "%s;received=%s;rport=%d%s%s",
09963 leftmost, ast_sockaddr_stringify_addr_remote(&p->recv),
09964 ast_sockaddr_port(&p->recv),
09965 others ? "," : "", others ? others : "");
09966 } else {
09967
09968 snprintf(new, sizeof(new), "%s;received=%s%s%s",
09969 leftmost, ast_sockaddr_stringify_addr_remote(&p->recv),
09970 others ? "," : "", others ? others : "");
09971 }
09972 oh = new;
09973 }
09974 add_header(req, field, oh);
09975 copied++;
09976 }
09977 if (!copied) {
09978 ast_log(LOG_NOTICE, "No header field '%s' present to copy\n", field);
09979 return -1;
09980 }
09981 return 0;
09982 }
09983
09984
09985 static void add_route(struct sip_request *req, struct sip_route *route)
09986 {
09987 char r[SIPBUFSIZE*2], *p;
09988 int n, rem = sizeof(r);
09989
09990 if (!route)
09991 return;
09992
09993 p = r;
09994 for (;route ; route = route->next) {
09995 n = strlen(route->hop);
09996 if (rem < n+3)
09997 break;
09998 if (p != r) {
09999 *p++ = ',';
10000 --rem;
10001 }
10002 *p++ = '<';
10003 ast_copy_string(p, route->hop, rem);
10004 p += n;
10005 *p++ = '>';
10006 rem -= (n+2);
10007 }
10008 *p = '\0';
10009 add_header(req, "Route", r);
10010 }
10011
10012
10013
10014
10015
10016
10017
10018
10019
10020
10021 static void set_destination(struct sip_pvt *p, char *uri)
10022 {
10023 char *h, *maddr, hostname[256];
10024 int hn;
10025 int debug=sip_debug_test_pvt(p);
10026 int tls_on = FALSE;
10027
10028 if (debug)
10029 ast_verbose("set_destination: Parsing <%s> for address/port to send to\n", uri);
10030
10031
10032 h = strchr(uri, '@');
10033 if (h)
10034 ++h;
10035 else {
10036 h = uri;
10037 if (!strncasecmp(h, "sip:", 4)) {
10038 h += 4;
10039 } else if (!strncasecmp(h, "sips:", 5)) {
10040 h += 5;
10041 tls_on = TRUE;
10042 }
10043 }
10044 hn = strcspn(h, ";>") + 1;
10045 if (hn > sizeof(hostname))
10046 hn = sizeof(hostname);
10047 ast_copy_string(hostname, h, hn);
10048
10049 h += hn - 1;
10050
10051
10052
10053 if (ast_sockaddr_resolve_first(&p->sa, hostname, 0)) {
10054 ast_log(LOG_WARNING, "Can't find address for host '%s'\n", hostname);
10055 return;
10056 }
10057
10058
10059 maddr = strstr(h, "maddr=");
10060 if (maddr) {
10061 int port;
10062
10063 maddr += 6;
10064 hn = strspn(maddr, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
10065 "0123456789-.:[]") + 1;
10066 if (hn > sizeof(hostname))
10067 hn = sizeof(hostname);
10068 ast_copy_string(hostname, maddr, hn);
10069
10070 port = ast_sockaddr_port(&p->sa);
10071
10072
10073
10074 if (ast_sockaddr_resolve_first(&p->sa, hostname, PARSE_PORT_FORBID)) {
10075 ast_log(LOG_WARNING, "Can't find address for host '%s'\n", hostname);
10076 return;
10077 }
10078
10079 ast_sockaddr_set_port(&p->sa, port);
10080 }
10081
10082 if (!ast_sockaddr_port(&p->sa)) {
10083 ast_sockaddr_set_port(&p->sa, tls_on ?
10084 STANDARD_TLS_PORT : STANDARD_SIP_PORT);
10085 }
10086
10087 if (debug) {
10088 ast_verbose("set_destination: set destination to %s\n",
10089 ast_sockaddr_stringify(&p->sa));
10090 }
10091 }
10092
10093
10094 static int init_resp(struct sip_request *resp, const char *msg)
10095 {
10096
10097 memset(resp, 0, sizeof(*resp));
10098 resp->method = SIP_RESPONSE;
10099 if (!(resp->data = ast_str_create(SIP_MIN_PACKET)))
10100 goto e_return;
10101 if (!(resp->content = ast_str_create(SIP_MIN_PACKET)))
10102 goto e_free_data;
10103 resp->header[0] = 0;
10104 ast_str_set(&resp->data, 0, "SIP/2.0 %s\r\n", msg);
10105 resp->headers++;
10106 return 0;
10107
10108 e_free_data:
10109 ast_free(resp->data);
10110 resp->data = NULL;
10111 e_return:
10112 return -1;
10113 }
10114
10115
10116 static int init_req(struct sip_request *req, int sipmethod, const char *recip)
10117 {
10118
10119 memset(req, 0, sizeof(*req));
10120 if (!(req->data = ast_str_create(SIP_MIN_PACKET)))
10121 goto e_return;
10122 if (!(req->content = ast_str_create(SIP_MIN_PACKET)))
10123 goto e_free_data;
10124 req->method = sipmethod;
10125 req->header[0] = 0;
10126 ast_str_set(&req->data, 0, "%s %s SIP/2.0\r\n", sip_methods[sipmethod].text, recip);
10127 req->headers++;
10128 return 0;
10129
10130 e_free_data:
10131 ast_free(req->data);
10132 req->data = NULL;
10133 e_return:
10134 return -1;
10135 }
10136
10137
10138 static void deinit_req(struct sip_request *req)
10139 {
10140 if (req->data) {
10141 ast_free(req->data);
10142 req->data = NULL;
10143 }
10144 if (req->content) {
10145 ast_free(req->content);
10146 req->content = NULL;
10147 }
10148 }
10149
10150
10151
10152 static inline int resp_needs_contact(const char *msg, enum sipmethod method) {
10153
10154
10155
10156
10157
10158
10159
10160
10161
10162
10163
10164
10165
10166
10167
10168 switch (method) {
10169
10170 case SIP_INVITE:
10171 case SIP_UPDATE:
10172 case SIP_SUBSCRIBE:
10173 case SIP_NOTIFY:
10174 if ((msg[0] >= '1' && msg[0] <= '3') || !strncmp(msg, "485", 3))
10175 return 1;
10176 break;
10177
10178
10179 case SIP_REGISTER:
10180 case SIP_OPTIONS:
10181 if (msg[0] == '2' || msg[0] == '3' || !strncmp(msg, "485", 3))
10182 return 1;
10183 break;
10184
10185
10186 case SIP_BYE:
10187 case SIP_PRACK:
10188 case SIP_MESSAGE:
10189 case SIP_PUBLISH:
10190 if (msg[0] == '3' || !strncmp(msg, "485", 3))
10191 return 1;
10192 break;
10193
10194
10195 case SIP_REFER:
10196 if (msg[0] >= '2' && msg[0] <= '6')
10197 return 1;
10198 break;
10199
10200
10201 case SIP_ACK:
10202 case SIP_CANCEL:
10203 case SIP_INFO:
10204 case SIP_PING:
10205 default:
10206 return 0;
10207 }
10208 return 0;
10209 }
10210
10211
10212 static int respprep(struct sip_request *resp, struct sip_pvt *p, const char *msg, const struct sip_request *req)
10213 {
10214 char newto[256];
10215 const char *ot;
10216
10217 init_resp(resp, msg);
10218 copy_via_headers(p, resp, req, "Via");
10219 if (msg[0] == '1' || msg[0] == '2')
10220 copy_all_header(resp, req, "Record-Route");
10221 copy_header(resp, req, "From");
10222 ot = get_header(req, "To");
10223 if (!strcasestr(ot, "tag=") && strncmp(msg, "100", 3)) {
10224
10225
10226 if (!ast_strlen_zero(p->theirtag) && ast_test_flag(&p->flags[0], SIP_OUTGOING))
10227 snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
10228 else if (p->tag && !ast_test_flag(&p->flags[0], SIP_OUTGOING))
10229 snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->tag);
10230 else
10231 ast_copy_string(newto, ot, sizeof(newto));
10232 ot = newto;
10233 }
10234 add_header(resp, "To", ot);
10235 copy_header(resp, req, "Call-ID");
10236 copy_header(resp, req, "CSeq");
10237 if (!ast_strlen_zero(global_useragent))
10238 add_header(resp, "Server", global_useragent);
10239 add_header(resp, "Allow", ALLOWED_METHODS);
10240 add_supported_header(p, resp);
10241
10242
10243 if (p->method == SIP_INVITE && p->stimer && p->stimer->st_active == TRUE && p->stimer->st_active_peer_ua == TRUE) {
10244 char se_hdr[256];
10245 snprintf(se_hdr, sizeof(se_hdr), "%d;refresher=%s", p->stimer->st_interval,
10246 strefresher2str(p->stimer->st_ref));
10247 add_header(resp, "Session-Expires", se_hdr);
10248 }
10249
10250 if (msg[0] == '2' && (p->method == SIP_SUBSCRIBE || p->method == SIP_REGISTER)) {
10251
10252
10253 char tmp[256];
10254
10255 snprintf(tmp, sizeof(tmp), "%d", p->expiry);
10256 add_header(resp, "Expires", tmp);
10257 if (p->expiry) {
10258 char contact[SIPBUFSIZE];
10259 const char *contact_uri = p->method == SIP_SUBSCRIBE ? p->our_contact : p->fullcontact;
10260 char *brackets = strchr(contact_uri, '<');
10261 snprintf(contact, sizeof(contact), "%s%s%s;expires=%d", brackets ? "" : "<", contact_uri, brackets ? "" : ">", p->expiry);
10262 add_header(resp, "Contact", contact);
10263 }
10264 } else if (!ast_strlen_zero(p->our_contact) && resp_needs_contact(msg, p->method)) {
10265 add_header(resp, "Contact", p->our_contact);
10266 }
10267
10268 if (!ast_strlen_zero(p->url)) {
10269 add_header(resp, "Access-URL", p->url);
10270 ast_string_field_set(p, url, NULL);
10271 }
10272
10273
10274
10275
10276
10277
10278
10279 p->sa = p->recv;
10280
10281 if (process_via(p, req)) {
10282 ast_log(LOG_WARNING, "error processing via header, will send response to originating address\n");
10283 }
10284
10285 return 0;
10286 }
10287
10288
10289 static int reqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod, int seqno, int newbranch)
10290 {
10291 struct sip_request *orig = &p->initreq;
10292 char stripped[80];
10293 char tmp[80];
10294 char newto[256];
10295 const char *c;
10296 const char *ot, *of;
10297 int is_strict = FALSE;
10298 int is_outbound = ast_test_flag(&p->flags[0], SIP_OUTGOING);
10299
10300 memset(req, 0, sizeof(struct sip_request));
10301
10302 snprintf(p->lastmsg, sizeof(p->lastmsg), "Tx: %s", sip_methods[sipmethod].text);
10303
10304 if (!seqno) {
10305 p->ocseq++;
10306 seqno = p->ocseq;
10307 }
10308
10309
10310 if (sipmethod == SIP_CANCEL) {
10311 p->branch = p->invite_branch;
10312 build_via(p);
10313 } else if (newbranch && (sipmethod == SIP_INVITE)) {
10314 p->branch ^= ast_random();
10315 p->invite_branch = p->branch;
10316 build_via(p);
10317 } else if (newbranch) {
10318 p->branch ^= ast_random();
10319 build_via(p);
10320 }
10321
10322
10323 if (p->route && !ast_strlen_zero(p->route->hop) && strstr(p->route->hop, ";lr") == NULL) {
10324 is_strict = TRUE;
10325 if (sipdebug)
10326 ast_debug(1, "Strict routing enforced for session %s\n", p->callid);
10327 }
10328
10329 if (sipmethod == SIP_CANCEL)
10330 c = REQ_OFFSET_TO_STR(&p->initreq, rlPart2);
10331 else if (sipmethod == SIP_ACK) {
10332
10333
10334 if (!ast_strlen_zero(p->okcontacturi))
10335 c = is_strict ? p->route->hop : p->okcontacturi;
10336 else
10337 c = REQ_OFFSET_TO_STR(&p->initreq, rlPart2);
10338 } else if (!ast_strlen_zero(p->okcontacturi))
10339 c = is_strict ? p->route->hop : p->okcontacturi;
10340 else if (!ast_strlen_zero(p->uri))
10341 c = p->uri;
10342 else {
10343 char *n;
10344
10345 ast_copy_string(stripped, get_header(orig, is_outbound ? "To" : "From"),
10346 sizeof(stripped));
10347 n = get_in_brackets(stripped);
10348 c = remove_uri_parameters(n);
10349 }
10350 init_req(req, sipmethod, c);
10351
10352 snprintf(tmp, sizeof(tmp), "%d %s", seqno, sip_methods[sipmethod].text);
10353
10354 add_header(req, "Via", p->via);
10355
10356
10357
10358
10359
10360 if (sipmethod == SIP_CANCEL ||
10361 (sipmethod == SIP_ACK && (p->invitestate == INV_COMPLETED || p->invitestate == INV_CANCELLED))) {
10362 set_destination(p, ast_strdupa(p->uri));
10363 } else if (p->route) {
10364 set_destination(p, p->route->hop);
10365 add_route(req, is_strict ? p->route->next : p->route);
10366 }
10367 add_header_max_forwards(p, req);
10368
10369 ot = get_header(orig, "To");
10370 of = get_header(orig, "From");
10371
10372
10373
10374 if (!strcasestr(ot, "tag=") && sipmethod != SIP_CANCEL) {
10375
10376
10377 if (is_outbound && !ast_strlen_zero(p->theirtag))
10378 snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->theirtag);
10379 else if (!is_outbound)
10380 snprintf(newto, sizeof(newto), "%s;tag=%s", ot, p->tag);
10381 else
10382 snprintf(newto, sizeof(newto), "%s", ot);
10383 ot = newto;
10384 }
10385
10386 if (is_outbound) {
10387 add_header(req, "From", of);
10388 add_header(req, "To", ot);
10389 } else {
10390 add_header(req, "From", ot);
10391 add_header(req, "To", of);
10392 }
10393
10394 if (sipmethod != SIP_BYE && sipmethod != SIP_CANCEL && sipmethod != SIP_MESSAGE)
10395 add_header(req, "Contact", p->our_contact);
10396
10397 copy_header(req, orig, "Call-ID");
10398 add_header(req, "CSeq", tmp);
10399
10400 if (!ast_strlen_zero(global_useragent))
10401 add_header(req, "User-Agent", global_useragent);
10402
10403 if (!ast_strlen_zero(p->url)) {
10404 add_header(req, "Access-URL", p->url);
10405 ast_string_field_set(p, url, NULL);
10406 }
10407
10408
10409
10410
10411
10412
10413
10414
10415 if (p->stimer && p->stimer->st_active == TRUE && p->stimer->st_active_peer_ua == TRUE
10416 && sipmethod == SIP_INVITE) {
10417 char se_hdr[256];
10418 snprintf(se_hdr, sizeof(se_hdr), "%d;refresher=%s", p->stimer->st_interval,
10419 strefresher2str(p->stimer->st_ref));
10420 add_header(req, "Session-Expires", se_hdr);
10421 snprintf(se_hdr, sizeof(se_hdr), "%d", st_get_se(p, FALSE));
10422 add_header(req, "Min-SE", se_hdr);
10423 }
10424
10425 return 0;
10426 }
10427
10428
10429 static int __transmit_response(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable)
10430 {
10431 struct sip_request resp;
10432 int seqno = 0;
10433
10434 if (reliable && (sscanf(get_header(req, "CSeq"), "%30d ", &seqno) != 1)) {
10435 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
10436 return -1;
10437 }
10438 respprep(&resp, p, msg, req);
10439
10440 if (ast_test_flag(&p->flags[0], SIP_SENDRPID)
10441 && ast_test_flag(&p->flags[1], SIP_PAGE2_CONNECTLINEUPDATE_PEND)
10442 && (!strncmp(msg, "180", 3) || !strncmp(msg, "183", 3))) {
10443 ast_clear_flag(&p->flags[1], SIP_PAGE2_CONNECTLINEUPDATE_PEND);
10444 add_rpid(&resp, p);
10445 }
10446 if (ast_test_flag(&p->flags[0], SIP_OFFER_CC)) {
10447 add_cc_call_info_to_response(p, &resp);
10448 }
10449
10450
10451 if (!strncmp(msg, "302", 3)) {
10452 add_diversion_header(&resp, p);
10453 }
10454
10455
10456
10457 if (p->method == SIP_INVITE && msg[0] != '1') {
10458 char buf[20];
10459
10460 if (ast_test_flag(&p->flags[1], SIP_PAGE2_Q850_REASON)) {
10461 int hangupcause = 0;
10462
10463 if (p->owner && p->owner->hangupcause) {
10464 hangupcause = p->owner->hangupcause;
10465 } else if (p->hangupcause) {
10466 hangupcause = p->hangupcause;
10467 } else {
10468 int respcode;
10469 if (sscanf(msg, "%30d ", &respcode))
10470 hangupcause = hangup_sip2cause(respcode);
10471 }
10472
10473 if (hangupcause) {
10474 sprintf(buf, "Q.850;cause=%i", hangupcause & 0x7f);
10475 add_header(&resp, "Reason", buf);
10476 }
10477 }
10478
10479 if (p->owner && p->owner->hangupcause) {
10480 add_header(&resp, "X-Asterisk-HangupCause", ast_cause2str(p->owner->hangupcause));
10481 snprintf(buf, sizeof(buf), "%d", p->owner->hangupcause);
10482 add_header(&resp, "X-Asterisk-HangupCauseCode", buf);
10483 }
10484 }
10485 return send_response(p, &resp, reliable, seqno);
10486 }
10487
10488 static int transmit_response_with_sip_etag(struct sip_pvt *p, const char *msg, const struct sip_request *req, struct sip_esc_entry *esc_entry, int need_new_etag)
10489 {
10490 struct sip_request resp;
10491
10492 if (need_new_etag) {
10493 create_new_sip_etag(esc_entry, 1);
10494 }
10495 respprep(&resp, p, msg, req);
10496 add_header(&resp, "SIP-ETag", esc_entry->entity_tag);
10497
10498 return send_response(p, &resp, 0, 0);
10499 }
10500
10501 static int temp_pvt_init(void *data)
10502 {
10503 struct sip_pvt *p = data;
10504
10505 p->do_history = 0;
10506 return ast_string_field_init(p, 512);
10507 }
10508
10509 static void temp_pvt_cleanup(void *data)
10510 {
10511 struct sip_pvt *p = data;
10512
10513 ast_string_field_free_memory(p);
10514
10515 ast_free(data);
10516 }
10517
10518
10519 static int transmit_response_using_temp(ast_string_field callid, struct ast_sockaddr *addr, int useglobal_nat, const int intended_method, const struct sip_request *req, const char *msg)
10520 {
10521 struct sip_pvt *p = NULL;
10522
10523 if (!(p = ast_threadstorage_get(&ts_temp_pvt, sizeof(*p)))) {
10524 ast_log(LOG_ERROR, "Failed to get temporary pvt\n");
10525 return -1;
10526 }
10527
10528
10529
10530
10531
10532
10533
10534
10535
10536 p->method = intended_method;
10537
10538 if (!addr) {
10539 ast_sockaddr_copy(&p->ourip, &internip);
10540 } else {
10541 ast_sockaddr_copy(&p->sa, addr);
10542 ast_sip_ouraddrfor(&p->sa, &p->ourip, p);
10543 }
10544
10545 p->branch = ast_random();
10546 make_our_tag(p->tag, sizeof(p->tag));
10547 p->ocseq = INITIAL_CSEQ;
10548
10549 if (useglobal_nat && addr) {
10550 ast_copy_flags(&p->flags[0], &global_flags[0], SIP_NAT_FORCE_RPORT);
10551 ast_sockaddr_copy(&p->recv, addr);
10552 do_setnat(p);
10553 }
10554
10555 ast_string_field_set(p, fromdomain, default_fromdomain);
10556 p->fromdomainport = default_fromdomainport;
10557 build_via(p);
10558 ast_string_field_set(p, callid, callid);
10559
10560 copy_socket_data(&p->socket, &req->socket);
10561
10562
10563 __transmit_response(p, msg, req, XMIT_UNRELIABLE);
10564
10565
10566 ast_string_field_init(p, 0);
10567
10568 return 0;
10569 }
10570
10571
10572 static int transmit_response(struct sip_pvt *p, const char *msg, const struct sip_request *req)
10573 {
10574 return __transmit_response(p, msg, req, XMIT_UNRELIABLE);
10575 }
10576
10577
10578 static int transmit_response_with_unsupported(struct sip_pvt *p, const char *msg, const struct sip_request *req, const char *unsupported)
10579 {
10580 struct sip_request resp;
10581 respprep(&resp, p, msg, req);
10582 append_date(&resp);
10583 add_header(&resp, "Unsupported", unsupported);
10584 return send_response(p, &resp, XMIT_UNRELIABLE, 0);
10585 }
10586
10587
10588 static int transmit_response_with_minse(struct sip_pvt *p, const char *msg, const struct sip_request *req, int minse_int)
10589 {
10590 struct sip_request resp;
10591 char minse_str[20];
10592
10593 respprep(&resp, p, msg, req);
10594 append_date(&resp);
10595
10596 snprintf(minse_str, sizeof(minse_str), "%d", minse_int);
10597 add_header(&resp, "Min-SE", minse_str);
10598 return send_response(p, &resp, XMIT_UNRELIABLE, 0);
10599 }
10600
10601
10602
10603
10604
10605 static int transmit_response_reliable(struct sip_pvt *p, const char *msg, const struct sip_request *req)
10606 {
10607 return __transmit_response(p, msg, req, req->ignore ? XMIT_UNRELIABLE : XMIT_CRITICAL);
10608 }
10609
10610
10611 static void append_date(struct sip_request *req)
10612 {
10613 char tmpdat[256];
10614 struct tm tm;
10615 time_t t = time(NULL);
10616
10617 gmtime_r(&t, &tm);
10618 strftime(tmpdat, sizeof(tmpdat), "%a, %d %b %Y %T GMT", &tm);
10619 add_header(req, "Date", tmpdat);
10620 }
10621
10622
10623 static int transmit_response_with_retry_after(struct sip_pvt *p, const char *msg, const struct sip_request *req, const char *seconds)
10624 {
10625 struct sip_request resp;
10626 respprep(&resp, p, msg, req);
10627 add_header(&resp, "Retry-After", seconds);
10628 return send_response(p, &resp, XMIT_UNRELIABLE, 0);
10629 }
10630
10631
10632 static int transmit_response_with_date(struct sip_pvt *p, const char *msg, const struct sip_request *req)
10633 {
10634 struct sip_request resp;
10635 respprep(&resp, p, msg, req);
10636 append_date(&resp);
10637 return send_response(p, &resp, XMIT_UNRELIABLE, 0);
10638 }
10639
10640
10641 static int transmit_response_with_allow(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable)
10642 {
10643 struct sip_request resp;
10644 respprep(&resp, p, msg, req);
10645 add_header(&resp, "Accept", "application/sdp");
10646 return send_response(p, &resp, reliable, 0);
10647 }
10648
10649
10650 static int transmit_response_with_minexpires(struct sip_pvt *p, const char *msg, const struct sip_request *req)
10651 {
10652 struct sip_request resp;
10653 char tmp[32];
10654
10655 snprintf(tmp, sizeof(tmp), "%d", min_expiry);
10656 respprep(&resp, p, msg, req);
10657 add_header(&resp, "Min-Expires", tmp);
10658 return send_response(p, &resp, XMIT_UNRELIABLE, 0);
10659 }
10660
10661
10662 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)
10663 {
10664 struct sip_request resp;
10665 char tmp[512];
10666 int seqno = 0;
10667
10668 if (reliable && (sscanf(get_header(req, "CSeq"), "%30d ", &seqno) != 1)) {
10669 ast_log(LOG_WARNING, "Unable to determine sequence number from '%s'\n", get_header(req, "CSeq"));
10670 return -1;
10671 }
10672
10673 get_realm(p, req);
10674
10675
10676
10677 snprintf(tmp, sizeof(tmp), "Digest algorithm=MD5, realm=\"%s\", nonce=\"%s\"%s", p->realm, randdata, stale ? ", stale=true" : "");
10678 respprep(&resp, p, msg, req);
10679 add_header(&resp, header, tmp);
10680 append_history(p, "AuthChal", "Auth challenge sent for %s - nc %d", p->username, p->noncecount);
10681 return send_response(p, &resp, reliable, seqno);
10682 }
10683
10684
10685
10686
10687
10688
10689
10690 static int get_domain(const char *str, char *domain, int len)
10691 {
10692 char tmpf[256];
10693 char *a, *from;
10694
10695 *domain = '\0';
10696 ast_copy_string(tmpf, str, sizeof(tmpf));
10697 from = get_in_brackets(tmpf);
10698 if (!ast_strlen_zero(from)) {
10699 if (strncasecmp(from, "sip:", 4)) {
10700 ast_log(LOG_WARNING, "Huh? Not a SIP header (%s)?\n", from);
10701 return -1;
10702 }
10703 from += 4;
10704 } else
10705 from = NULL;
10706
10707 if (from) {
10708 int bracket = 0;
10709
10710
10711 if ((a = strchr(from, ';')))
10712 *a = '\0';
10713
10714 for (a = from; *a != '\0'; ++a) {
10715 if (*a == ':' && bracket == 0) {
10716 *a = '\0';
10717 break;
10718 } else if (*a == '[') {
10719 ++bracket;
10720 } else if (*a == ']') {
10721 --bracket;
10722 }
10723 }
10724 if ((a = strchr(from, '@'))) {
10725 *a = '\0';
10726 ast_copy_string(domain, a + 1, len);
10727 } else
10728 ast_copy_string(domain, from, len);
10729 }
10730
10731 return ast_strlen_zero(domain);
10732 }
10733
10734
10735
10736
10737
10738 static void get_realm(struct sip_pvt *p, const struct sip_request *req)
10739 {
10740 char domain[MAXHOSTNAMELEN];
10741
10742 if (!ast_strlen_zero(p->realm))
10743 return;
10744
10745 if (sip_cfg.domainsasrealm &&
10746 !AST_LIST_EMPTY(&domain_list))
10747 {
10748
10749 if (!get_domain(get_header(req, "From"), domain, sizeof(domain))) {
10750 if (check_sip_domain(domain, NULL, 0)) {
10751 ast_string_field_set(p, realm, domain);
10752 return;
10753 }
10754 }
10755
10756 if (!get_domain(get_header(req, "To"), domain, sizeof(domain))) {
10757 if (check_sip_domain(domain, NULL, 0)) {
10758 ast_string_field_set(p, realm, domain);
10759 return;
10760 }
10761 }
10762 }
10763
10764
10765 ast_string_field_set(p, realm, sip_cfg.realm);
10766 }
10767
10768
10769
10770
10771
10772
10773
10774
10775 static int transmit_provisional_response(struct sip_pvt *p, const char *msg, const struct sip_request *req, int with_sdp)
10776 {
10777 int res;
10778
10779 if (!(res = with_sdp ? transmit_response_with_sdp(p, msg, req, XMIT_UNRELIABLE, FALSE, FALSE) : transmit_response(p, msg, req))) {
10780 p->last_provisional = msg;
10781 update_provisional_keepalive(p, with_sdp);
10782 }
10783
10784 return res;
10785 }
10786
10787
10788 static int add_text(struct sip_request *req, const char *text)
10789 {
10790
10791 add_header(req, "Content-Type", "text/plain;charset=UTF-8");
10792 add_content(req, text);
10793 return 0;
10794 }
10795
10796
10797
10798
10799
10800 static int add_digit(struct sip_request *req, char digit, unsigned int duration, int mode)
10801 {
10802 char tmp[256];
10803 int event;
10804 if (mode) {
10805
10806 if ('0' <= digit && digit <= '9') {
10807 event = digit - '0';
10808 } else if (digit == '*') {
10809 event = 10;
10810 } else if (digit == '#') {
10811 event = 11;
10812 } else if ('A' <= digit && digit <= 'D') {
10813 event = 12 + digit - 'A';
10814 } else if ('a' <= digit && digit <= 'd') {
10815 event = 12 + digit - 'a';
10816 } else {
10817
10818 event = 0;
10819 }
10820 snprintf(tmp, sizeof(tmp), "%d\r\n", event);
10821 add_header(req, "Content-Type", "application/dtmf");
10822 add_content(req, tmp);
10823 } else {
10824
10825 snprintf(tmp, sizeof(tmp), "Signal=%c\r\nDuration=%u\r\n", digit, duration);
10826 add_header(req, "Content-Type", "application/dtmf-relay");
10827 add_content(req, tmp);
10828 }
10829 return 0;
10830 }
10831
10832
10833
10834
10835
10836 static int add_rpid(struct sip_request *req, struct sip_pvt *p)
10837 {
10838 struct ast_str *tmp = ast_str_alloca(256);
10839 char tmp2[256];
10840 char *lid_num = NULL;
10841 char *lid_name = NULL;
10842 int lid_pres;
10843 const char *fromdomain;
10844 const char *privacy = NULL;
10845 const char *screen = NULL;
10846 const char *anonymous_string = "\"Anonymous\" <sip:anonymous@anonymous.invalid>";
10847
10848 if (!ast_test_flag(&p->flags[0], SIP_SENDRPID)) {
10849 return 0;
10850 }
10851
10852 if (p->owner && p->owner->connected.id.number.valid
10853 && p->owner->connected.id.number.str) {
10854 lid_num = p->owner->connected.id.number.str;
10855 }
10856 if (p->owner && p->owner->connected.id.name.valid
10857 && p->owner->connected.id.name.str) {
10858 lid_name = p->owner->connected.id.name.str;
10859 }
10860 lid_pres = (p->owner) ? ast_party_id_presentation(&p->owner->connected.id) : AST_PRES_NUMBER_NOT_AVAILABLE;
10861
10862 if (ast_strlen_zero(lid_num))
10863 return 0;
10864 if (ast_strlen_zero(lid_name))
10865 lid_name = lid_num;
10866 fromdomain = S_OR(p->fromdomain, ast_sockaddr_stringify_host_remote(&p->ourip));
10867
10868 lid_num = ast_uri_encode(lid_num, tmp2, sizeof(tmp2), 0);
10869
10870 if (ast_test_flag(&p->flags[0], SIP_SENDRPID_PAI)) {
10871 if ((lid_pres & AST_PRES_RESTRICTION) != AST_PRES_ALLOWED) {
10872 ast_str_set(&tmp, -1, "%s", anonymous_string);
10873 } else {
10874 ast_str_set(&tmp, -1, "\"%s\" <sip:%s@%s>", lid_name, lid_num, fromdomain);
10875 }
10876 add_header(req, "P-Asserted-Identity", ast_str_buffer(tmp));
10877 } else {
10878 ast_str_set(&tmp, -1, "\"%s\" <sip:%s@%s>;party=%s", lid_name, lid_num, fromdomain, ast_test_flag(&p->flags[0], SIP_OUTGOING) ? "calling" : "called");
10879
10880 switch (lid_pres) {
10881 case AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED:
10882 case AST_PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN:
10883 privacy = "off";
10884 screen = "no";
10885 break;
10886 case AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN:
10887 case AST_PRES_ALLOWED_NETWORK_NUMBER:
10888 privacy = "off";
10889 screen = "yes";
10890 break;
10891 case AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED:
10892 case AST_PRES_PROHIB_USER_NUMBER_FAILED_SCREEN:
10893 privacy = "full";
10894 screen = "no";
10895 break;
10896 case AST_PRES_PROHIB_USER_NUMBER_PASSED_SCREEN:
10897 case AST_PRES_PROHIB_NETWORK_NUMBER:
10898 privacy = "full";
10899 screen = "yes";
10900 break;
10901 case AST_PRES_NUMBER_NOT_AVAILABLE:
10902 break;
10903 default:
10904 if ((lid_pres & AST_PRES_RESTRICTION) != AST_PRES_ALLOWED) {
10905 privacy = "full";
10906 }
10907 else
10908 privacy = "off";
10909 screen = "no";
10910 break;
10911 }
10912
10913 if (!ast_strlen_zero(privacy) && !ast_strlen_zero(screen)) {
10914 ast_str_append(&tmp, -1, ";privacy=%s;screen=%s", privacy, screen);
10915 }
10916
10917 add_header(req, "Remote-Party-ID", ast_str_buffer(tmp));
10918 }
10919 return 0;
10920 }
10921
10922
10923
10924 static int add_vidupdate(struct sip_request *req)
10925 {
10926 const char *xml_is_a_huge_waste_of_space =
10927 "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\r\n"
10928 " <media_control>\r\n"
10929 " <vc_primitive>\r\n"
10930 " <to_encoder>\r\n"
10931 " <picture_fast_update>\r\n"
10932 " </picture_fast_update>\r\n"
10933 " </to_encoder>\r\n"
10934 " </vc_primitive>\r\n"
10935 " </media_control>\r\n";
10936 add_header(req, "Content-Type", "application/media_control+xml");
10937 add_content(req, xml_is_a_huge_waste_of_space);
10938 return 0;
10939 }
10940
10941
10942 static void add_codec_to_sdp(const struct sip_pvt *p, format_t codec,
10943 struct ast_str **m_buf, struct ast_str **a_buf,
10944 int debug, int *min_packet_size)
10945 {
10946 int rtp_code;
10947 struct ast_format_list fmt;
10948
10949
10950 if (debug)
10951 ast_verbose("Adding codec 0x%" PRIx64 " (%s) to SDP\n", codec, ast_getformatname(codec));
10952 if ((rtp_code = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(p->rtp), 1, codec)) == -1)
10953 return;
10954
10955 if (p->rtp) {
10956 struct ast_codec_pref *pref = &ast_rtp_instance_get_codecs(p->rtp)->pref;
10957 fmt = ast_codec_pref_getsize(pref, codec);
10958 } else
10959 return;
10960 ast_str_append(m_buf, 0, " %d", rtp_code);
10961 ast_str_append(a_buf, 0, "a=rtpmap:%d %s/%d\r\n", rtp_code,
10962 ast_rtp_lookup_mime_subtype2(1, codec,
10963 ast_test_flag(&p->flags[0], SIP_G726_NONSTANDARD) ? AST_RTP_OPT_G726_NONSTANDARD : 0),
10964 ast_rtp_lookup_sample_rate2(1, codec));
10965
10966 switch (codec) {
10967 case AST_FORMAT_G729A:
10968
10969 ast_str_append(a_buf, 0, "a=fmtp:%d annexb=no\r\n", rtp_code);
10970 break;
10971 case AST_FORMAT_G723_1:
10972
10973 ast_str_append(a_buf, 0, "a=fmtp:%d annexa=no\r\n", rtp_code);
10974 break;
10975 case AST_FORMAT_ILBC:
10976
10977 ast_str_append(a_buf, 0, "a=fmtp:%d mode=%d\r\n", rtp_code, fmt.cur_ms);
10978 break;
10979 case AST_FORMAT_SIREN7:
10980
10981 ast_str_append(a_buf, 0, "a=fmtp:%d bitrate=32000\r\n", rtp_code);
10982 break;
10983 case AST_FORMAT_SIREN14:
10984
10985 ast_str_append(a_buf, 0, "a=fmtp:%d bitrate=48000\r\n", rtp_code);
10986 break;
10987 case AST_FORMAT_G719:
10988
10989 ast_str_append(a_buf, 0, "a=fmtp:%d bitrate=64000\r\n", rtp_code);
10990 break;
10991 }
10992
10993 if (fmt.cur_ms && (fmt.cur_ms < *min_packet_size))
10994 *min_packet_size = fmt.cur_ms;
10995
10996
10997 if ((*min_packet_size)==0 && fmt.cur_ms)
10998 *min_packet_size = fmt.cur_ms;
10999 }
11000
11001
11002
11003 static void add_vcodec_to_sdp(const struct sip_pvt *p, format_t codec,
11004 struct ast_str **m_buf, struct ast_str **a_buf,
11005 int debug, int *min_packet_size)
11006 {
11007 int rtp_code;
11008
11009 if (!p->vrtp)
11010 return;
11011
11012 if (debug)
11013 ast_verbose("Adding video codec 0x%" PRIx64 " (%s) to SDP\n", codec, ast_getformatname(codec));
11014
11015 if ((rtp_code = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(p->vrtp), 1, codec)) == -1)
11016 return;
11017
11018 ast_str_append(m_buf, 0, " %d", rtp_code);
11019 ast_str_append(a_buf, 0, "a=rtpmap:%d %s/%d\r\n", rtp_code,
11020 ast_rtp_lookup_mime_subtype2(1, codec, 0),
11021 ast_rtp_lookup_sample_rate2(1, codec));
11022
11023 }
11024
11025
11026 static void add_tcodec_to_sdp(const struct sip_pvt *p, int codec,
11027 struct ast_str **m_buf, struct ast_str **a_buf,
11028 int debug, int *min_packet_size)
11029 {
11030 int rtp_code;
11031
11032 if (!p->trtp)
11033 return;
11034
11035 if (debug)
11036 ast_verbose("Adding text codec 0x%x (%s) to SDP\n", codec, ast_getformatname(codec));
11037
11038 if ((rtp_code = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(p->trtp), 1, codec)) == -1)
11039 return;
11040
11041 ast_str_append(m_buf, 0, " %d", rtp_code);
11042 ast_str_append(a_buf, 0, "a=rtpmap:%d %s/%d\r\n", rtp_code,
11043 ast_rtp_lookup_mime_subtype2(1, codec, 0),
11044 ast_rtp_lookup_sample_rate2(1, codec));
11045
11046
11047 if (codec == AST_FORMAT_T140RED) {
11048 int t140code = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(p->trtp), 1, AST_FORMAT_T140);
11049 ast_str_append(a_buf, 0, "a=fmtp:%d %d/%d/%d\r\n", rtp_code,
11050 t140code,
11051 t140code,
11052 t140code);
11053
11054 }
11055 }
11056
11057
11058
11059 static unsigned int t38_get_rate(enum ast_control_t38_rate rate)
11060 {
11061 switch (rate) {
11062 case AST_T38_RATE_2400:
11063 return 2400;
11064 case AST_T38_RATE_4800:
11065 return 4800;
11066 case AST_T38_RATE_7200:
11067 return 7200;
11068 case AST_T38_RATE_9600:
11069 return 9600;
11070 case AST_T38_RATE_12000:
11071 return 12000;
11072 case AST_T38_RATE_14400:
11073 return 14400;
11074 default:
11075 return 0;
11076 }
11077 }
11078
11079
11080 static void add_noncodec_to_sdp(const struct sip_pvt *p, int format,
11081 struct ast_str **m_buf, struct ast_str **a_buf,
11082 int debug)
11083 {
11084 int rtp_code;
11085
11086 if (debug)
11087 ast_verbose("Adding non-codec 0x%x (%s) to SDP\n", format, ast_rtp_lookup_mime_subtype2(0, format, 0));
11088 if ((rtp_code = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(p->rtp), 0, format)) == -1)
11089 return;
11090
11091 ast_str_append(m_buf, 0, " %d", rtp_code);
11092 ast_str_append(a_buf, 0, "a=rtpmap:%d %s/%d\r\n", rtp_code,
11093 ast_rtp_lookup_mime_subtype2(0, format, 0),
11094 ast_rtp_lookup_sample_rate2(0, format));
11095 if (format == AST_RTP_DTMF)
11096 ast_str_append(a_buf, 0, "a=fmtp:%d 0-16\r\n", rtp_code);
11097 }
11098
11099
11100
11101
11102 static void get_our_media_address(struct sip_pvt *p, int needvideo, int needtext,
11103 struct ast_sockaddr *addr, struct ast_sockaddr *vaddr,
11104 struct ast_sockaddr *taddr, struct ast_sockaddr *dest,
11105 struct ast_sockaddr *vdest, struct ast_sockaddr *tdest)
11106 {
11107 int use_externip = 0;
11108
11109
11110 ast_rtp_instance_get_local_address(p->rtp, addr);
11111 if (p->vrtp) {
11112 ast_rtp_instance_get_local_address(p->vrtp, vaddr);
11113 }
11114 if (p->trtp) {
11115 ast_rtp_instance_get_local_address(p->trtp, taddr);
11116 }
11117
11118
11119
11120
11121 use_externip = ast_sockaddr_cmp_addr(&p->ourip, addr);
11122
11123
11124
11125 if (!ast_sockaddr_isnull(&p->redirip)) {
11126 ast_sockaddr_copy(dest, &p->redirip);
11127 } else {
11128
11129
11130
11131
11132
11133
11134
11135
11136
11137
11138
11139 ast_sockaddr_copy(dest,
11140 !ast_sockaddr_isnull(&media_address) ? &media_address :
11141 !ast_sockaddr_is_any(addr) && !use_externip ? addr :
11142 &p->ourip);
11143 ast_sockaddr_set_port(dest, ast_sockaddr_port(addr));
11144 }
11145
11146 if (needvideo) {
11147
11148 if (!ast_sockaddr_isnull(&p->vredirip)) {
11149 ast_sockaddr_copy(vdest, &p->vredirip);
11150 } else {
11151
11152
11153
11154
11155
11156
11157
11158
11159
11160
11161
11162 ast_sockaddr_copy(vdest,
11163 !ast_sockaddr_isnull(&media_address) ? &media_address :
11164 !ast_sockaddr_is_any(vaddr) && !use_externip ? vaddr :
11165 &p->ourip);
11166 ast_sockaddr_set_port(vdest, ast_sockaddr_port(vaddr));
11167 }
11168 }
11169
11170 if (needtext) {
11171
11172 if (!ast_sockaddr_isnull(&p->tredirip)) {
11173 ast_sockaddr_copy(tdest, &p->tredirip);
11174 } else {
11175
11176
11177
11178
11179
11180
11181
11182
11183
11184
11185
11186 ast_sockaddr_copy(tdest,
11187 !ast_sockaddr_isnull(&media_address) ? &media_address :
11188 !ast_sockaddr_is_any(taddr) && !use_externip ? taddr :
11189 &p->ourip);
11190 ast_sockaddr_set_port(tdest, ast_sockaddr_port(taddr));
11191 }
11192 }
11193 }
11194
11195 static void get_crypto_attrib(struct sip_srtp *srtp, const char **a_crypto)
11196 {
11197
11198 if (srtp) {
11199 if (!srtp->crypto) {
11200 srtp->crypto = sdp_crypto_setup();
11201 }
11202 if (srtp->crypto && (sdp_crypto_offer(srtp->crypto) >= 0)) {
11203 *a_crypto = sdp_crypto_attrib(srtp->crypto);
11204 }
11205
11206 if (!*a_crypto) {
11207 ast_log(LOG_WARNING, "No SRTP key management enabled\n");
11208 }
11209 }
11210 }
11211
11212
11213
11214
11215
11216
11217
11218 static enum sip_result add_sdp(struct sip_request *resp, struct sip_pvt *p, int oldsdp, int add_audio, int add_t38)
11219 {
11220 format_t alreadysent = 0;
11221 int doing_directmedia = FALSE;
11222
11223 struct ast_sockaddr addr = { {0,} };
11224 struct ast_sockaddr vaddr = { {0,} };
11225 struct ast_sockaddr taddr = { {0,} };
11226 struct ast_sockaddr udptladdr = { {0,} };
11227 struct ast_sockaddr dest = { {0,} };
11228 struct ast_sockaddr vdest = { {0,} };
11229 struct ast_sockaddr tdest = { {0,} };
11230 struct ast_sockaddr udptldest = { {0,} };
11231
11232
11233 char *version = "v=0\r\n";
11234 char subject[256];
11235 char owner[256];
11236 char connection[256];
11237 char *session_time = "t=0 0\r\n";
11238 char bandwidth[256] = "";
11239 char *hold = "";
11240 struct ast_str *m_audio = ast_str_alloca(256);
11241 struct ast_str *m_video = ast_str_alloca(256);
11242 struct ast_str *m_text = ast_str_alloca(256);
11243 struct ast_str *m_modem = ast_str_alloca(256);
11244 struct ast_str *a_audio = ast_str_alloca(1024);
11245 struct ast_str *a_video = ast_str_alloca(1024);
11246 struct ast_str *a_text = ast_str_alloca(1024);
11247 struct ast_str *a_modem = ast_str_alloca(1024);
11248 const char *a_crypto = NULL;
11249 const char *v_a_crypto = NULL;
11250 const char *t_a_crypto = NULL;
11251
11252 format_t x;
11253 format_t capability = 0;
11254 int needaudio = FALSE;
11255 int needvideo = FALSE;
11256 int needtext = FALSE;
11257 int debug = sip_debug_test_pvt(p);
11258 int min_audio_packet_size = 0;
11259 int min_video_packet_size = 0;
11260 int min_text_packet_size = 0;
11261
11262 char codecbuf[SIPBUFSIZE];
11263 char buf[SIPBUFSIZE];
11264 char dummy_answer[256];
11265
11266
11267 snprintf(subject, sizeof(subject), "s=%s\r\n", ast_strlen_zero(global_sdpsession) ? "-" : global_sdpsession);
11268
11269 if (!p->rtp) {
11270 ast_log(LOG_WARNING, "No way to add SDP without an RTP structure\n");
11271 return AST_FAILURE;
11272 }
11273
11274
11275
11276
11277 if (!p->sessionid) {
11278 p->sessionid = (int)ast_random();
11279 p->sessionversion = p->sessionid;
11280 } else {
11281 if (oldsdp == FALSE)
11282 p->sessionversion++;
11283 }
11284
11285 if (add_audio) {
11286 doing_directmedia = (!ast_sockaddr_isnull(&p->redirip) && p->redircodecs) ? TRUE : FALSE;
11287
11288 if ((p->jointcapability & AST_FORMAT_VIDEO_MASK) && !p->novideo) {
11289 if (doing_directmedia && !(p->jointcapability & AST_FORMAT_VIDEO_MASK & p->redircodecs)) {
11290 ast_debug(2, "This call needs video offers, but caller probably did not offer it!\n");
11291 } else if (p->vrtp) {
11292 needvideo = TRUE;
11293 ast_debug(2, "This call needs video offers!\n");
11294 } else {
11295 ast_debug(2, "This call needs video offers, but there's no video support enabled!\n");
11296 }
11297 }
11298
11299 if ((p->jointcapability & AST_FORMAT_TEXT_MASK) && !p->notext) {
11300 if (sipdebug_text)
11301 ast_verbose("We think we can do text\n");
11302 if (p->trtp) {
11303 if (sipdebug_text) {
11304 ast_verbose("And we have a text rtp object\n");
11305 }
11306 needtext = TRUE;
11307 ast_debug(2, "This call needs text offers! \n");
11308 } else {
11309 ast_debug(2, "This call needs text offers, but there's no text support enabled ! \n");
11310 }
11311 }
11312 }
11313
11314 get_our_media_address(p, needvideo, needtext, &addr, &vaddr, &taddr, &dest, &vdest, &tdest);
11315
11316 snprintf(owner, sizeof(owner), "o=%s %d %d IN %s %s\r\n",
11317 ast_strlen_zero(global_sdpowner) ? "-" : global_sdpowner,
11318 p->sessionid, p->sessionversion,
11319 (ast_sockaddr_is_ipv6(&dest) && !ast_sockaddr_is_ipv4_mapped(&dest)) ?
11320 "IP6" : "IP4",
11321 ast_sockaddr_stringify_addr_remote(&dest));
11322
11323 snprintf(connection, sizeof(connection), "c=IN %s %s\r\n",
11324 (ast_sockaddr_is_ipv6(&dest) && !ast_sockaddr_is_ipv4_mapped(&dest)) ?
11325 "IP6" : "IP4",
11326 ast_sockaddr_stringify_addr_remote(&dest));
11327
11328 if (add_audio) {
11329 if (ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD) == SIP_PAGE2_CALL_ONHOLD_ONEDIR) {
11330 hold = "a=recvonly\r\n";
11331 doing_directmedia = FALSE;
11332 } else if (ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD) == SIP_PAGE2_CALL_ONHOLD_INACTIVE) {
11333 hold = "a=inactive\r\n";
11334 doing_directmedia = FALSE;
11335 } else {
11336 hold = "a=sendrecv\r\n";
11337 }
11338
11339 capability = p->jointcapability;
11340
11341
11342 ast_debug(1, "** Our capability: %s Video flag: %s Text flag: %s\n", ast_getformatname_multiple(codecbuf, sizeof(codecbuf), capability),
11343 p->novideo ? "True" : "False", p->notext ? "True" : "False");
11344 ast_debug(1, "** Our prefcodec: %s \n", ast_getformatname_multiple(codecbuf, sizeof(codecbuf), p->prefcodec));
11345
11346 if (doing_directmedia) {
11347 capability &= p->redircodecs;
11348 ast_debug(1, "** Our native-bridge filtered capablity: %s\n", ast_getformatname_multiple(codecbuf, sizeof(codecbuf), capability));
11349 }
11350
11351
11352 if (capability & AST_FORMAT_AUDIO_MASK)
11353 needaudio = TRUE;
11354
11355 if (debug) {
11356 ast_verbose("Audio is at %s\n", ast_sockaddr_stringify_port(&addr));
11357 }
11358
11359
11360
11361 if (needvideo) {
11362 get_crypto_attrib(p->vsrtp, &v_a_crypto);
11363 ast_str_append(&m_video, 0, "m=video %d RTP/%s", ast_sockaddr_port(&vdest),
11364 v_a_crypto ? "SAVP" : "AVP");
11365
11366
11367 if (p->maxcallbitrate)
11368 snprintf(bandwidth, sizeof(bandwidth), "b=CT:%d\r\n", p->maxcallbitrate);
11369 if (debug) {
11370 ast_verbose("Video is at %s\n", ast_sockaddr_stringify(&vdest));
11371 }
11372 }
11373
11374
11375
11376 if (needtext) {
11377 if (sipdebug_text)
11378 ast_verbose("Lets set up the text sdp\n");
11379 get_crypto_attrib(p->tsrtp, &t_a_crypto);
11380 ast_str_append(&m_text, 0, "m=text %d RTP/%s", ast_sockaddr_port(&tdest),
11381 t_a_crypto ? "SAVP" : "AVP");
11382 if (debug) {
11383 ast_verbose("Text is at %s\n", ast_sockaddr_stringify(&taddr));
11384 }
11385 }
11386
11387
11388
11389
11390
11391
11392 get_crypto_attrib(p->srtp, &a_crypto);
11393 ast_str_append(&m_audio, 0, "m=audio %d RTP/%s", ast_sockaddr_port(&dest),
11394 a_crypto ? "SAVP" : "AVP");
11395
11396
11397
11398
11399
11400
11401
11402
11403
11404
11405 if (capability & p->prefcodec) {
11406 format_t codec = p->prefcodec & AST_FORMAT_AUDIO_MASK;
11407
11408 add_codec_to_sdp(p, codec, &m_audio, &a_audio, debug, &min_audio_packet_size);
11409 alreadysent |= codec;
11410 }
11411
11412
11413 for (x = 0; x < 64; x++) {
11414 format_t codec;
11415
11416 if (!(codec = ast_codec_pref_index(&p->prefs, x)))
11417 break;
11418
11419 if (!(capability & codec))
11420 continue;
11421
11422 if (alreadysent & codec)
11423 continue;
11424
11425 add_codec_to_sdp(p, codec, &m_audio, &a_audio, debug, &min_audio_packet_size);
11426 alreadysent |= codec;
11427 }
11428
11429
11430 for (x = 1ULL; x <= (needtext ? AST_FORMAT_TEXT_MASK : (needvideo ? AST_FORMAT_VIDEO_MASK : AST_FORMAT_AUDIO_MASK)); x <<= 1) {
11431 if (!(capability & x))
11432 continue;
11433
11434 if (alreadysent & x)
11435 continue;
11436
11437 if (x & AST_FORMAT_AUDIO_MASK)
11438 add_codec_to_sdp(p, x, &m_audio, &a_audio, debug, &min_audio_packet_size);
11439 else if (x & AST_FORMAT_VIDEO_MASK)
11440 add_vcodec_to_sdp(p, x, &m_video, &a_video, debug, &min_video_packet_size);
11441 else if (x & AST_FORMAT_TEXT_MASK)
11442 add_tcodec_to_sdp(p, x, &m_text, &a_text, debug, &min_text_packet_size);
11443 }
11444
11445
11446 for (x = 1LL; x <= AST_RTP_MAX; x <<= 1) {
11447 if (!(p->jointnoncodeccapability & x))
11448 continue;
11449
11450 add_noncodec_to_sdp(p, x, &m_audio, &a_audio, debug);
11451 }
11452
11453 ast_debug(3, "-- Done with adding codecs to SDP\n");
11454
11455 if (!p->owner || !ast_internal_timing_enabled(p->owner))
11456 ast_str_append(&a_audio, 0, "a=silenceSupp:off - - - -\r\n");
11457
11458 if (min_audio_packet_size)
11459 ast_str_append(&a_audio, 0, "a=ptime:%d\r\n", min_audio_packet_size);
11460
11461
11462 if (min_video_packet_size)
11463 ast_str_append(&a_video, 0, "a=ptime:%d\r\n", min_video_packet_size);
11464
11465
11466 if (min_text_packet_size)
11467 ast_str_append(&a_text, 0, "a=ptime:%d\r\n", min_text_packet_size);
11468
11469 if (m_audio->len - m_audio->used < 2 || m_video->len - m_video->used < 2 ||
11470 m_text->len - m_text->used < 2 || a_text->len - a_text->used < 2 ||
11471 a_audio->len - a_audio->used < 2 || a_video->len - a_video->used < 2)
11472 ast_log(LOG_WARNING, "SIP SDP may be truncated due to undersized buffer!!\n");
11473 }
11474
11475 if (add_t38) {
11476
11477 ast_udptl_get_us(p->udptl, &udptladdr);
11478
11479
11480 if (!ast_sockaddr_isnull(&p->udptlredirip)) {
11481 ast_sockaddr_copy(&udptldest, &p->udptlredirip);
11482 } else {
11483 ast_sockaddr_copy(&udptldest, &p->ourip);
11484 ast_sockaddr_set_port(&udptldest, ast_sockaddr_port(&udptladdr));
11485 }
11486
11487 if (debug) {
11488 ast_debug(1, "T.38 UDPTL is at %s port %d\n", ast_sockaddr_stringify_addr(&p->ourip), ast_sockaddr_port(&udptladdr));
11489 }
11490
11491
11492
11493
11494 ast_str_append(&m_modem, 0, "m=image %d udptl t38\r\n", ast_sockaddr_port(&udptldest));
11495
11496 if (!ast_sockaddr_cmp(&udptldest, &dest)) {
11497 ast_str_append(&m_modem, 0, "c=IN %s %s\r\n",
11498 (ast_sockaddr_is_ipv6(&dest) && !ast_sockaddr_is_ipv4_mapped(&dest)) ?
11499 "IP6" : "IP4", ast_sockaddr_stringify_addr_remote(&udptldest));
11500 }
11501
11502 ast_str_append(&a_modem, 0, "a=T38FaxVersion:%d\r\n", p->t38.our_parms.version);
11503 ast_str_append(&a_modem, 0, "a=T38MaxBitRate:%d\r\n", t38_get_rate(p->t38.our_parms.rate));
11504 if (p->t38.our_parms.fill_bit_removal) {
11505 ast_str_append(&a_modem, 0, "a=T38FaxFillBitRemoval\r\n");
11506 }
11507 if (p->t38.our_parms.transcoding_mmr) {
11508 ast_str_append(&a_modem, 0, "a=T38FaxTranscodingMMR\r\n");
11509 }
11510 if (p->t38.our_parms.transcoding_jbig) {
11511 ast_str_append(&a_modem, 0, "a=T38FaxTranscodingJBIG\r\n");
11512 }
11513 switch (p->t38.our_parms.rate_management) {
11514 case AST_T38_RATE_MANAGEMENT_TRANSFERRED_TCF:
11515 ast_str_append(&a_modem, 0, "a=T38FaxRateManagement:transferredTCF\r\n");
11516 break;
11517 case AST_T38_RATE_MANAGEMENT_LOCAL_TCF:
11518 ast_str_append(&a_modem, 0, "a=T38FaxRateManagement:localTCF\r\n");
11519 break;
11520 }
11521 ast_str_append(&a_modem, 0, "a=T38FaxMaxDatagram:%u\r\n", ast_udptl_get_local_max_datagram(p->udptl));
11522 switch (ast_udptl_get_error_correction_scheme(p->udptl)) {
11523 case UDPTL_ERROR_CORRECTION_NONE:
11524 break;
11525 case UDPTL_ERROR_CORRECTION_FEC:
11526 ast_str_append(&a_modem, 0, "a=T38FaxUdpEC:t38UDPFEC\r\n");
11527 break;
11528 case UDPTL_ERROR_CORRECTION_REDUNDANCY:
11529 ast_str_append(&a_modem, 0, "a=T38FaxUdpEC:t38UDPRedundancy\r\n");
11530 break;
11531 }
11532 }
11533
11534 if (needaudio)
11535 ast_str_append(&m_audio, 0, "\r\n");
11536 if (needvideo)
11537 ast_str_append(&m_video, 0, "\r\n");
11538 if (needtext)
11539 ast_str_append(&m_text, 0, "\r\n");
11540
11541 add_header(resp, "Content-Type", "application/sdp");
11542 add_content(resp, version);
11543 add_content(resp, owner);
11544 add_content(resp, subject);
11545 add_content(resp, connection);
11546
11547 if (needvideo) {
11548 add_content(resp, bandwidth);
11549 }
11550 add_content(resp, session_time);
11551
11552 if (p->offered_media[SDP_AUDIO].order_offered ||
11553 p->offered_media[SDP_VIDEO].order_offered ||
11554 p->offered_media[SDP_TEXT].order_offered ||
11555 p->offered_media[SDP_IMAGE].order_offered) {
11556 int i;
11557
11558 for (i = 1; i <= 3; i++) {
11559 if (p->offered_media[SDP_AUDIO].order_offered == i) {
11560 if (needaudio) {
11561 add_content(resp, m_audio->str);
11562 add_content(resp, a_audio->str);
11563 add_content(resp, hold);
11564 if (a_crypto) {
11565 add_content(resp, a_crypto);
11566 }
11567 } else {
11568 snprintf(dummy_answer, sizeof(dummy_answer), "m=audio 0 RTP/AVP %s\r\n", p->offered_media[SDP_AUDIO].codecs);
11569 add_content(resp, dummy_answer);
11570 }
11571 } else if (p->offered_media[SDP_VIDEO].order_offered == i) {
11572 if (needvideo) {
11573 add_content(resp, m_video->str);
11574 add_content(resp, a_video->str);
11575 add_content(resp, hold);
11576 if (v_a_crypto) {
11577 add_content(resp, v_a_crypto);
11578 }
11579 } else {
11580 snprintf(dummy_answer, sizeof(dummy_answer), "m=video 0 RTP/AVP %s\r\n", p->offered_media[SDP_VIDEO].codecs);
11581 add_content(resp, dummy_answer);
11582 }
11583 } else if (p->offered_media[SDP_TEXT].order_offered == i) {
11584 if (needtext) {
11585 add_content(resp, m_text->str);
11586 add_content(resp, a_text->str);
11587 add_content(resp, hold);
11588 if (t_a_crypto) {
11589 add_content(resp, t_a_crypto);
11590 }
11591 } else {
11592 snprintf(dummy_answer, sizeof(dummy_answer), "m=text 0 RTP/AVP %s\r\n", p->offered_media[SDP_TEXT].codecs);
11593 add_content(resp, dummy_answer);
11594 }
11595 } else if (p->offered_media[SDP_IMAGE].order_offered == i) {
11596 if (add_t38) {
11597 add_content(resp, m_modem->str);
11598 add_content(resp, a_modem->str);
11599 } else {
11600 add_content(resp, "m=image 0 udptl t38\r\n");
11601 }
11602 }
11603 }
11604 } else {
11605
11606 if (needaudio) {
11607 add_content(resp, m_audio->str);
11608 add_content(resp, a_audio->str);
11609 add_content(resp, hold);
11610 if (a_crypto) {
11611 add_content(resp, a_crypto);
11612 }
11613 }
11614 if (needvideo) {
11615 add_content(resp, m_video->str);
11616 add_content(resp, a_video->str);
11617 add_content(resp, hold);
11618 if (v_a_crypto) {
11619 add_content(resp, v_a_crypto);
11620 }
11621 }
11622 if (needtext) {
11623 add_content(resp, m_text->str);
11624 add_content(resp, a_text->str);
11625 add_content(resp, hold);
11626 if (t_a_crypto) {
11627 add_content(resp, t_a_crypto);
11628 }
11629 }
11630 if (add_t38) {
11631 add_content(resp, m_modem->str);
11632 add_content(resp, a_modem->str);
11633 }
11634 }
11635
11636
11637 p->lastrtprx = p->lastrtptx = time(NULL);
11638
11639 ast_debug(3, "Done building SDP. Settling with this capability: %s\n", ast_getformatname_multiple(buf, SIPBUFSIZE, capability));
11640
11641 return AST_SUCCESS;
11642 }
11643
11644
11645 static int transmit_response_with_t38_sdp(struct sip_pvt *p, char *msg, struct sip_request *req, int retrans)
11646 {
11647 struct sip_request resp;
11648 int seqno;
11649
11650 if (sscanf(get_header(req, "CSeq"), "%30d ", &seqno) != 1) {
11651 ast_log(LOG_WARNING, "Unable to get seqno from '%s'\n", get_header(req, "CSeq"));
11652 return -1;
11653 }
11654 respprep(&resp, p, msg, req);
11655 if (p->udptl) {
11656 add_sdp(&resp, p, 0, 0, 1);
11657 } else
11658 ast_log(LOG_ERROR, "Can't add SDP to response, since we have no UDPTL session allocated. Call-ID %s\n", p->callid);
11659 if (retrans && !p->pendinginvite)
11660 p->pendinginvite = seqno;
11661 return send_response(p, &resp, retrans, seqno);
11662 }
11663
11664
11665 static void copy_request(struct sip_request *dst, const struct sip_request *src)
11666 {
11667
11668
11669
11670 struct ast_str *duplicate = dst->data;
11671 struct ast_str *duplicate_content = dst->content;
11672
11673
11674
11675 memcpy(dst, src, sizeof(*dst));
11676 dst->data = duplicate;
11677 dst->content = duplicate_content;
11678
11679
11680 if (!dst->data && !(dst->data = ast_str_create(ast_str_strlen(src->data) + 1)))
11681 return;
11682 ast_str_copy_string(&dst->data, src->data);
11683
11684
11685 if (src->content) {
11686 if (!dst->content && !(dst->content = ast_str_create(ast_str_strlen(src->content) + 1)))
11687 return;
11688 ast_str_copy_string(&dst->content, src->content);
11689 }
11690 }
11691
11692 static void add_cc_call_info_to_response(struct sip_pvt *p, struct sip_request *resp)
11693 {
11694 char uri[SIPBUFSIZE];
11695 struct ast_str *header = ast_str_alloca(SIPBUFSIZE);
11696 struct ast_cc_agent *agent = find_sip_cc_agent_by_original_callid(p);
11697 struct sip_cc_agent_pvt *agent_pvt;
11698
11699 if (!agent) {
11700
11701
11702
11703 ast_log(LOG_WARNING, "Can't find SIP CC agent for call '%s' even though OFFER_CC flag was set?\n", p->callid);
11704 return;
11705 }
11706
11707 agent_pvt = agent->private_data;
11708
11709 if (!ast_strlen_zero(agent_pvt->subscribe_uri)) {
11710 ast_copy_string(uri, agent_pvt->subscribe_uri, sizeof(uri));
11711 } else {
11712 generate_uri(p, uri, sizeof(uri));
11713 ast_copy_string(agent_pvt->subscribe_uri, uri, sizeof(agent_pvt->subscribe_uri));
11714 }
11715
11716
11717
11718
11719 ast_str_set(&header, 0, "<%s>;purpose=call-completion;m=%s", uri, "NR");
11720 add_header(resp, "Call-Info", ast_str_buffer(header));
11721 ao2_ref(agent, -1);
11722 }
11723
11724
11725
11726
11727 static int transmit_response_with_sdp(struct sip_pvt *p, const char *msg, const struct sip_request *req, enum xmittype reliable, int oldsdp, int rpid)
11728 {
11729 struct sip_request resp;
11730 int seqno;
11731 if (sscanf(get_header(req, "CSeq"), "%30d ", &seqno) != 1) {
11732 ast_log(LOG_WARNING, "Unable to get seqno from '%s'\n", get_header(req, "CSeq"));
11733 return -1;
11734 }
11735 respprep(&resp, p, msg, req);
11736 if (rpid == TRUE) {
11737 add_rpid(&resp, p);
11738 }
11739 if (ast_test_flag(&p->flags[0], SIP_OFFER_CC)) {
11740 add_cc_call_info_to_response(p, &resp);
11741 }
11742 if (p->rtp) {
11743 if (!p->autoframing && !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
11744 ast_debug(1, "Setting framing from config on incoming call\n");
11745 ast_rtp_codecs_packetization_set(ast_rtp_instance_get_codecs(p->rtp), p->rtp, &p->prefs);
11746 }
11747 ast_rtp_instance_activate(p->rtp);
11748 try_suggested_sip_codec(p);
11749 if (p->t38.state == T38_ENABLED) {
11750 add_sdp(&resp, p, oldsdp, TRUE, TRUE);
11751 } else {
11752 add_sdp(&resp, p, oldsdp, TRUE, FALSE);
11753 }
11754 } else
11755 ast_log(LOG_ERROR, "Can't add SDP to response, since we have no RTP session allocated. Call-ID %s\n", p->callid);
11756 if (reliable && !p->pendinginvite)
11757 p->pendinginvite = seqno;
11758 return send_response(p, &resp, reliable, seqno);
11759 }
11760
11761
11762 static int determine_firstline_parts(struct sip_request *req)
11763 {
11764 char *e = ast_skip_blanks(req->data->str);
11765 char *local_rlPart1;
11766
11767 if (!*e)
11768 return -1;
11769 req->rlPart1 = e - req->data->str;
11770 local_rlPart1 = e;
11771 e = ast_skip_nonblanks(e);
11772 if (*e)
11773 *e++ = '\0';
11774
11775 e = ast_skip_blanks(e);
11776 if ( !*e )
11777 return -1;
11778 ast_trim_blanks(e);
11779
11780 if (!strcasecmp(local_rlPart1, "SIP/2.0") ) {
11781 if (strlen(e) < 3)
11782 return -1;
11783 req->rlPart2 = e - req->data->str;
11784 } else {
11785 if ( *e == '<' ) {
11786 ast_debug(3, "Oops. Bogus uri in <> %s\n", e);
11787 e++;
11788 if (!*e)
11789 return -1;
11790 }
11791 req->rlPart2 = e - req->data->str;
11792 e = ast_skip_nonblanks(e);
11793 if (*e)
11794 *e++ = '\0';
11795 e = ast_skip_blanks(e);
11796 if (strcasecmp(e, "SIP/2.0") ) {
11797 ast_debug(3, "Skipping packet - Bad request protocol %s\n", e);
11798 return -1;
11799 }
11800 }
11801 return 1;
11802 }
11803
11804
11805
11806
11807
11808
11809
11810
11811
11812
11813
11814
11815
11816
11817 static int transmit_reinvite_with_sdp(struct sip_pvt *p, int t38version, int oldsdp)
11818 {
11819 struct sip_request req;
11820
11821 reqprep(&req, p, ast_test_flag(&p->flags[0], SIP_REINVITE_UPDATE) ? SIP_UPDATE : SIP_INVITE, 0, 1);
11822
11823 add_header(&req, "Allow", ALLOWED_METHODS);
11824 add_supported_header(p, &req);
11825 if (sipdebug) {
11826 if (oldsdp == TRUE)
11827 add_header(&req, "X-asterisk-Info", "SIP re-invite (Session-Timers)");
11828 else
11829 add_header(&req, "X-asterisk-Info", "SIP re-invite (External RTP bridge)");
11830 }
11831
11832 if (ast_test_flag(&p->flags[0], SIP_SENDRPID))
11833 add_rpid(&req, p);
11834
11835 if (p->do_history) {
11836 append_history(p, "ReInv", "Re-invite sent");
11837 }
11838 memset(p->offered_media, 0, sizeof(p->offered_media));
11839
11840 try_suggested_sip_codec(p);
11841 if (t38version) {
11842 add_sdp(&req, p, oldsdp, FALSE, TRUE);
11843 } else {
11844 add_sdp(&req, p, oldsdp, TRUE, FALSE);
11845 }
11846
11847
11848 initialize_initreq(p, &req);
11849 p->lastinvite = p->ocseq;
11850 ast_set_flag(&p->flags[0], SIP_OUTGOING);
11851
11852 return send_request(p, &req, XMIT_CRITICAL, p->ocseq);
11853 }
11854
11855
11856 static char *remove_uri_parameters(char *uri)
11857 {
11858 char *atsign;
11859 atsign = strchr(uri, '@');
11860 if (!atsign) {
11861 atsign = uri;
11862 }
11863 atsign = strchr(atsign, ';');
11864 if (atsign)
11865 *atsign = '\0';
11866 return uri;
11867 }
11868
11869
11870 static void extract_uri(struct sip_pvt *p, struct sip_request *req)
11871 {
11872 char stripped[SIPBUFSIZE];
11873 char *c;
11874
11875 ast_copy_string(stripped, get_header(req, "Contact"), sizeof(stripped));
11876 c = get_in_brackets(stripped);
11877
11878 c = remove_uri_parameters(c);
11879 if (!ast_strlen_zero(c)) {
11880 ast_string_field_set(p, uri, c);
11881 }
11882
11883 }
11884
11885
11886 static void build_contact(struct sip_pvt *p)
11887 {
11888 char tmp[SIPBUFSIZE];
11889 char *user = ast_uri_encode(p->exten, tmp, sizeof(tmp), 0);
11890
11891 if (p->socket.type == SIP_TRANSPORT_UDP) {
11892 ast_string_field_build(p, our_contact, "<sip:%s%s%s>", user,
11893 ast_strlen_zero(user) ? "" : "@", ast_sockaddr_stringify_remote(&p->ourip));
11894 } else {
11895 ast_string_field_build(p, our_contact, "<sip:%s%s%s;transport=%s>", user,
11896 ast_strlen_zero(user) ? "" : "@", ast_sockaddr_stringify_remote(&p->ourip),
11897 get_transport(p->socket.type));
11898 }
11899 }
11900
11901
11902 static void initreqprep(struct sip_request *req, struct sip_pvt *p, int sipmethod, const char * const explicit_uri)
11903 {
11904 struct ast_str *invite = ast_str_alloca(256);
11905 char from[256];
11906 char to[256];
11907 char tmp_n[SIPBUFSIZE/2];
11908 char tmp_l[SIPBUFSIZE/2];
11909 const char *l = NULL;
11910 const char *n = NULL;
11911 const char *d = NULL;
11912 const char *urioptions = "";
11913 int ourport;
11914
11915 if (ast_test_flag(&p->flags[0], SIP_USEREQPHONE)) {
11916 const char *s = p->username;
11917
11918
11919
11920
11921
11922
11923 if (*s == '+')
11924 s++;
11925 for (; *s; s++) {
11926 if (!strchr(AST_DIGIT_ANYNUM, *s) )
11927 break;
11928 }
11929
11930 if (!*s)
11931 urioptions = ";user=phone";
11932 }
11933
11934
11935 snprintf(p->lastmsg, sizeof(p->lastmsg), "Init: %s", sip_methods[sipmethod].text);
11936
11937 d = S_OR(p->fromdomain, ast_sockaddr_stringify_host_remote(&p->ourip));
11938 if (p->owner) {
11939 if ((ast_party_id_presentation(&p->owner->connected.id) & AST_PRES_RESTRICTION) == AST_PRES_ALLOWED) {
11940 l = p->owner->connected.id.number.valid ? p->owner->connected.id.number.str : NULL;
11941 n = p->owner->connected.id.name.valid ? p->owner->connected.id.name.str : NULL;
11942 } else {
11943
11944
11945 l = CALLERID_UNKNOWN;
11946 n = l;
11947 d = FROMDOMAIN_INVALID;
11948 }
11949 }
11950
11951
11952
11953
11954
11955
11956
11957 if (sipmethod == SIP_NOTIFY && !ast_strlen_zero(p->mwi_from)) {
11958 l = p->mwi_from;
11959 }
11960
11961 if (ast_strlen_zero(l))
11962 l = default_callerid;
11963 if (ast_strlen_zero(n))
11964 n = l;
11965
11966 if (!ast_strlen_zero(p->fromuser))
11967 l = p->fromuser;
11968 else
11969 ast_string_field_set(p, fromuser, l);
11970
11971
11972 if (!ast_strlen_zero(p->fromname))
11973 n = p->fromname;
11974 else
11975 ast_string_field_set(p, fromname, n);
11976
11977 if (sip_cfg.pedanticsipchecking) {
11978 ast_escape_quoted(n, tmp_n, sizeof(tmp_n));
11979 n = tmp_n;
11980 ast_uri_encode(l, tmp_l, sizeof(tmp_l), 0);
11981 l = tmp_l;
11982 }
11983
11984 ourport = (p->fromdomainport) ? p->fromdomainport : ast_sockaddr_port(&p->ourip);
11985 if (!sip_standard_port(p->socket.type, ourport)) {
11986 snprintf(from, sizeof(from), "\"%s\" <sip:%s@%s:%d>;tag=%s", n, l, d, ourport, p->tag);
11987 } else {
11988 snprintf(from, sizeof(from), "\"%s\" <sip:%s@%s>;tag=%s", n, l, d, p->tag);
11989 }
11990
11991 if (!ast_strlen_zero(explicit_uri)) {
11992 ast_str_set(&invite, 0, "%s", explicit_uri);
11993 } else {
11994
11995 if (!ast_strlen_zero(p->fullcontact)) {
11996
11997 ast_str_append(&invite, 0, "%s", p->fullcontact);
11998 } else {
11999
12000 ast_str_append(&invite, 0, "sip:");
12001 if (!ast_strlen_zero(p->username)) {
12002 n = p->username;
12003 if (sip_cfg.pedanticsipchecking) {
12004 ast_uri_encode(n, tmp_n, sizeof(tmp_n), 0);
12005 n = tmp_n;
12006 }
12007 ast_str_append(&invite, 0, "%s@", n);
12008 }
12009 ast_str_append(&invite, 0, "%s", p->tohost);
12010 if (p->portinuri) {
12011 ast_str_append(&invite, 0, ":%d", ast_sockaddr_port(&p->sa));
12012 }
12013 ast_str_append(&invite, 0, "%s", urioptions);
12014 }
12015 }
12016
12017
12018 if (p->options && !ast_strlen_zero(p->options->uri_options))
12019 ast_str_append(&invite, 0, ";%s", p->options->uri_options);
12020
12021
12022
12023
12024 ast_string_field_set(p, uri, invite->str);
12025
12026 if (!ast_strlen_zero(p->todnid)) {
12027
12028 if (!strchr(p->todnid, '@')) {
12029
12030 snprintf(to, sizeof(to), "<sip:%s@%s>%s%s", p->todnid, p->tohost, ast_strlen_zero(p->theirtag) ? "" : ";tag=", p->theirtag);
12031 } else {
12032 snprintf(to, sizeof(to), "<sip:%s>%s%s", p->todnid, ast_strlen_zero(p->theirtag) ? "" : ";tag=", p->theirtag);
12033 }
12034 } else {
12035 if (sipmethod == SIP_NOTIFY && !ast_strlen_zero(p->theirtag)) {
12036
12037 snprintf(to, sizeof(to), "<%s%s>;tag=%s", (strncasecmp(p->uri, "sip:", 4) ? "sip:" : ""), p->uri, p->theirtag);
12038 } else if (p->options && p->options->vxml_url) {
12039
12040 snprintf(to, sizeof(to), "<%s>;%s", p->uri, p->options->vxml_url);
12041 } else {
12042 snprintf(to, sizeof(to), "<%s>", p->uri);
12043 }
12044 }
12045
12046 init_req(req, sipmethod, p->uri);
12047
12048 snprintf(tmp_n, sizeof(tmp_n), "%d %s", ++p->ocseq, sip_methods[sipmethod].text);
12049
12050 add_header(req, "Via", p->via);
12051 add_header_max_forwards(p, req);
12052
12053
12054
12055
12056 add_route(req, p->route);
12057
12058 add_header(req, "From", from);
12059 add_header(req, "To", to);
12060 ast_string_field_set(p, exten, l);
12061 build_contact(p);
12062 add_header(req, "Contact", p->our_contact);
12063 add_header(req, "Call-ID", p->callid);
12064 add_header(req, "CSeq", tmp_n);
12065 if (!ast_strlen_zero(global_useragent)) {
12066 add_header(req, "User-Agent", global_useragent);
12067 }
12068 }
12069
12070
12071
12072
12073
12074
12075
12076
12077
12078 static void add_diversion_header(struct sip_request *req, struct sip_pvt *pvt)
12079 {
12080 const char *diverting_number;
12081 const char *diverting_name;
12082 const char *reason;
12083 char header_text[256];
12084
12085 if (!pvt->owner) {
12086 return;
12087 }
12088
12089 diverting_number = pvt->owner->redirecting.from.number.str;
12090 if (!pvt->owner->redirecting.from.number.valid
12091 || ast_strlen_zero(diverting_number)) {
12092 return;
12093 }
12094
12095 reason = sip_reason_code_to_str(pvt->owner->redirecting.reason);
12096
12097
12098 diverting_name = pvt->owner->redirecting.from.name.str;
12099 if (!pvt->owner->redirecting.from.name.valid
12100 || ast_strlen_zero(diverting_name)) {
12101 snprintf(header_text, sizeof(header_text), "<sip:%s@%s>;reason=%s", diverting_number,
12102 ast_sockaddr_stringify_host_remote(&pvt->ourip), reason);
12103 } else {
12104 snprintf(header_text, sizeof(header_text), "\"%s\" <sip:%s@%s>;reason=%s",
12105 diverting_name, diverting_number,
12106 ast_sockaddr_stringify_host_remote(&pvt->ourip), reason);
12107 }
12108
12109 add_header(req, "Diversion", header_text);
12110 }
12111
12112 static int transmit_publish(struct sip_epa_entry *epa_entry, enum sip_publish_type publish_type, const char * const explicit_uri)
12113 {
12114 struct sip_pvt *pvt;
12115 int expires;
12116
12117 epa_entry->publish_type = publish_type;
12118
12119 if (!(pvt = sip_alloc(NULL, NULL, 0, SIP_PUBLISH, NULL))) {
12120 return -1;
12121 }
12122
12123 sip_pvt_lock(pvt);
12124
12125 if (create_addr(pvt, epa_entry->destination, NULL, TRUE, NULL)) {
12126 sip_pvt_unlock(pvt);
12127 dialog_unlink_all(pvt);
12128 dialog_unref(pvt, "create_addr failed in transmit_publish. Unref dialog");
12129 return -1;
12130 }
12131 ast_sip_ouraddrfor(&pvt->sa, &pvt->ourip, pvt);
12132 ast_set_flag(&pvt->flags[0], SIP_OUTGOING);
12133 expires = (publish_type == SIP_PUBLISH_REMOVE) ? 0 : DEFAULT_PUBLISH_EXPIRES;
12134 pvt->expiry = expires;
12135
12136
12137 ao2_ref(epa_entry, +1);
12138 pvt->epa_entry = epa_entry;
12139
12140 transmit_invite(pvt, SIP_PUBLISH, FALSE, 2, explicit_uri);
12141 sip_pvt_unlock(pvt);
12142 sip_scheddestroy(pvt, DEFAULT_TRANS_TIMEOUT);
12143 dialog_unref(pvt, "Done with the sip_pvt allocated for transmitting PUBLISH");
12144 return 0;
12145 }
12146
12147
12148
12149
12150
12151
12152
12153
12154
12155
12156 static int transmit_invite(struct sip_pvt *p, int sipmethod, int sdp, int init, const char * const explicit_uri)
12157 {
12158 struct sip_request req;
12159 struct ast_variable *var;
12160
12161 req.method = sipmethod;
12162 if (init) {
12163 p->branch ^= ast_random();
12164 p->invite_branch = p->branch;
12165 build_via(p);
12166 }
12167 if (init > 1) {
12168 initreqprep(&req, p, sipmethod, explicit_uri);
12169 } else {
12170
12171 reqprep(&req, p, sipmethod, 0, init ? 0 : 1);
12172 }
12173
12174 if (p->options && p->options->auth) {
12175 add_header(&req, p->options->authheader, p->options->auth);
12176 }
12177 append_date(&req);
12178 if (sipmethod == SIP_REFER) {
12179 if (p->refer) {
12180 char buf[SIPBUFSIZE];
12181 if (!ast_strlen_zero(p->refer->refer_to)) {
12182 add_header(&req, "Refer-To", p->refer->refer_to);
12183 }
12184 if (!ast_strlen_zero(p->refer->referred_by)) {
12185 snprintf(buf, sizeof(buf), "%s <%s>", p->refer->referred_by_name, p->refer->referred_by);
12186 add_header(&req, "Referred-By", buf);
12187 }
12188 }
12189 } else if (sipmethod == SIP_SUBSCRIBE) {
12190 char buf[SIPBUFSIZE];
12191 if (p->subscribed == MWI_NOTIFICATION) {
12192 add_header(&req, "Event", "message-summary");
12193 add_header(&req, "Accept", "application/simple-message-summary");
12194 } else if (p->subscribed == CALL_COMPLETION) {
12195 add_header(&req, "Event", "call-completion");
12196 add_header(&req, "Accept", "application/call-completion");
12197 }
12198 snprintf(buf, sizeof(buf), "%d", p->expiry);
12199 add_header(&req, "Expires", buf);
12200 }
12201
12202
12203
12204 if (p->options && !ast_strlen_zero(p->options->replaces)) {
12205 add_header(&req, "Replaces", p->options->replaces);
12206 add_header(&req, "Require", "replaces");
12207 }
12208
12209
12210 if (st_get_mode(p, 0) == SESSION_TIMER_MODE_ORIGINATE) {
12211 char i2astr[10];
12212
12213 if (!p->stimer->st_interval) {
12214 p->stimer->st_interval = st_get_se(p, TRUE);
12215 }
12216
12217 p->stimer->st_active = TRUE;
12218
12219 snprintf(i2astr, sizeof(i2astr), "%d", p->stimer->st_interval);
12220 add_header(&req, "Session-Expires", i2astr);
12221 snprintf(i2astr, sizeof(i2astr), "%d", st_get_se(p, FALSE));
12222 add_header(&req, "Min-SE", i2astr);
12223 }
12224
12225 add_header(&req, "Allow", ALLOWED_METHODS);
12226 add_supported_header(p, &req);
12227
12228 if (p->options && p->options->addsipheaders && p->owner) {
12229 struct ast_channel *chan = p->owner;
12230 struct varshead *headp;
12231
12232 ast_channel_lock(chan);
12233
12234 headp = &chan->varshead;
12235
12236 if (!headp) {
12237 ast_log(LOG_WARNING, "No Headp for the channel...ooops!\n");
12238 } else {
12239 const struct ast_var_t *current;
12240 AST_LIST_TRAVERSE(headp, current, entries) {
12241
12242 if (!strncasecmp(ast_var_name(current), "SIPADDHEADER", strlen("SIPADDHEADER"))) {
12243 char *content, *end;
12244 const char *header = ast_var_value(current);
12245 char *headdup = ast_strdupa(header);
12246
12247
12248 if (*headdup == '"') {
12249 headdup++;
12250 }
12251 if ((content = strchr(headdup, ':'))) {
12252 *content++ = '\0';
12253 content = ast_skip_blanks(content);
12254
12255 end = content + strlen(content) -1;
12256 if (*end == '"') {
12257 *end = '\0';
12258 }
12259
12260 add_header(&req, headdup, content);
12261 if (sipdebug) {
12262 ast_debug(1, "Adding SIP Header \"%s\" with content :%s: \n", headdup, content);
12263 }
12264 }
12265 }
12266 }
12267 }
12268
12269 ast_channel_unlock(chan);
12270 }
12271 if ((sipmethod == SIP_INVITE || sipmethod == SIP_UPDATE) && ast_test_flag(&p->flags[0], SIP_SENDRPID))
12272 add_rpid(&req, p);
12273 if (sipmethod == SIP_INVITE) {
12274 add_diversion_header(&req, p);
12275 }
12276 if (sdp) {
12277 memset(p->offered_media, 0, sizeof(p->offered_media));
12278 if (p->udptl && p->t38.state == T38_LOCAL_REINVITE) {
12279 ast_debug(1, "T38 is in state %d on channel %s\n", p->t38.state, p->owner ? p->owner->name : "<none>");
12280 add_sdp(&req, p, FALSE, FALSE, TRUE);
12281 } else if (p->rtp) {
12282 try_suggested_sip_codec(p);
12283 add_sdp(&req, p, FALSE, TRUE, FALSE);
12284 }
12285 } else if (p->notify) {
12286 for (var = p->notify->headers; var; var = var->next) {
12287 add_header(&req, var->name, var->value);
12288 }
12289 if (ast_str_strlen(p->notify->content)) {
12290 add_content(&req, ast_str_buffer(p->notify->content));
12291 }
12292 } else if (sipmethod == SIP_PUBLISH) {
12293 char expires[SIPBUFSIZE];
12294
12295 switch (p->epa_entry->static_data->event) {
12296 case CALL_COMPLETION:
12297 snprintf(expires, sizeof(expires), "%d", p->expiry);
12298 add_header(&req, "Event", "call-completion");
12299 add_header(&req, "Expires", expires);
12300 if (p->epa_entry->publish_type != SIP_PUBLISH_INITIAL) {
12301 add_header(&req, "SIP-If-Match", p->epa_entry->entity_tag);
12302 }
12303
12304 if (!ast_strlen_zero(p->epa_entry->body)) {
12305 add_header(&req, "Content-Type", "application/pidf+xml");
12306 add_content(&req, p->epa_entry->body);
12307 }
12308 default:
12309 break;
12310 }
12311 }
12312
12313 if (!p->initreq.headers || init > 2) {
12314 initialize_initreq(p, &req);
12315 }
12316 if (sipmethod == SIP_INVITE || sipmethod == SIP_SUBSCRIBE) {
12317 p->lastinvite = p->ocseq;
12318 }
12319 return send_request(p, &req, init ? XMIT_CRITICAL : XMIT_RELIABLE, p->ocseq);
12320 }
12321
12322
12323 static int sip_subscribe_mwi_do(const void *data)
12324 {
12325 struct sip_subscription_mwi *mwi = (struct sip_subscription_mwi*)data;
12326
12327 if (!mwi) {
12328 return -1;
12329 }
12330
12331 mwi->resub = -1;
12332 __sip_subscribe_mwi_do(mwi);
12333 ASTOBJ_UNREF(mwi, sip_subscribe_mwi_destroy);
12334
12335 return 0;
12336 }
12337
12338 static void on_dns_update_registry(struct ast_sockaddr *old, struct ast_sockaddr *new, void *data)
12339 {
12340 struct sip_registry *reg = data;
12341 const char *old_str;
12342
12343
12344 if (ast_sockaddr_isnull(new)) {
12345 ast_debug(1, "Empty sockaddr change...ignoring!\n");
12346 return;
12347 }
12348
12349 if (!ast_sockaddr_port(new)) {
12350 ast_sockaddr_set_port(new, reg->portno);
12351 }
12352
12353 old_str = ast_strdupa(ast_sockaddr_stringify(old));
12354
12355 ast_debug(1, "Changing registry %s from %s to %s\n", S_OR(reg->peername, reg->hostname), old_str, ast_sockaddr_stringify(new));
12356 ast_sockaddr_copy(®->us, new);
12357 }
12358
12359 static void on_dns_update_peer(struct ast_sockaddr *old, struct ast_sockaddr *new, void *data)
12360 {
12361 struct sip_peer *peer = data;
12362 const char *old_str;
12363
12364
12365 if (ast_sockaddr_isnull(new)) {
12366 ast_debug(1, "Empty sockaddr change...ignoring!\n");
12367 return;
12368 }
12369
12370 if (!ast_sockaddr_isnull(&peer->addr)) {
12371 ao2_unlink(peers_by_ip, peer);
12372 }
12373
12374 if (!ast_sockaddr_port(new)) {
12375 ast_sockaddr_set_port(new, default_sip_port(peer->socket.type));
12376 }
12377
12378 old_str = ast_strdupa(ast_sockaddr_stringify(old));
12379 ast_debug(1, "Changing peer %s address from %s to %s\n", peer->name, old_str, ast_sockaddr_stringify(new));
12380
12381 ao2_lock(peer);
12382 ast_sockaddr_copy(&peer->addr, new);
12383 ao2_unlock(peer);
12384
12385 ao2_link(peers_by_ip, peer);
12386 }
12387
12388 static void on_dns_update_mwi(struct ast_sockaddr *old, struct ast_sockaddr *new, void *data)
12389 {
12390 struct sip_subscription_mwi *mwi = data;
12391 const char *old_str;
12392
12393
12394 if (ast_sockaddr_isnull(new)) {
12395 ast_debug(1, "Empty sockaddr change...ignoring!\n");
12396 return;
12397 }
12398
12399 old_str = ast_strdupa(ast_sockaddr_stringify(old));
12400 ast_debug(1, "Changing mwi %s from %s to %s\n", mwi->hostname, old_str, ast_sockaddr_stringify(new));
12401 ast_sockaddr_copy(&mwi->us, new);
12402 }
12403
12404
12405 static int __sip_subscribe_mwi_do(struct sip_subscription_mwi *mwi)
12406 {
12407
12408 if (!mwi->dnsmgr) {
12409 char transport[MAXHOSTNAMELEN];
12410 snprintf(transport, sizeof(transport), "_%s._%s", get_srv_service(mwi->transport), get_srv_protocol(mwi->transport));
12411
12412 mwi->us.ss.ss_family = get_address_family_filter(&bindaddr);
12413 ASTOBJ_REF(mwi);
12414 ast_dnsmgr_lookup_cb(mwi->hostname, &mwi->us, &mwi->dnsmgr, sip_cfg.srvlookup ? transport : NULL, on_dns_update_mwi, mwi);
12415 if (!mwi->dnsmgr) {
12416 ASTOBJ_UNREF(mwi, sip_subscribe_mwi_destroy);
12417 }
12418 }
12419
12420
12421 if (mwi->call) {
12422 transmit_invite(mwi->call, SIP_SUBSCRIBE, 0, 0, NULL);
12423 return 0;
12424 }
12425
12426
12427 if (!(mwi->call = sip_alloc(NULL, NULL, 0, SIP_SUBSCRIBE, NULL))) {
12428 return -1;
12429 }
12430
12431 ref_proxy(mwi->call, obproxy_get(mwi->call, NULL));
12432
12433 if (!ast_sockaddr_port(&mwi->us) && mwi->portno) {
12434 ast_sockaddr_set_port(&mwi->us, mwi->portno);
12435 }
12436
12437
12438 if (create_addr(mwi->call, mwi->hostname, &mwi->us, 0, NULL)) {
12439 dialog_unlink_all(mwi->call);
12440 mwi->call = dialog_unref(mwi->call, "unref dialog after unlink_all");
12441 return 0;
12442 }
12443
12444 mwi->call->expiry = mwi_expiry;
12445
12446 if (!mwi->dnsmgr && mwi->portno) {
12447 ast_sockaddr_set_port(&mwi->call->sa, mwi->portno);
12448 ast_sockaddr_set_port(&mwi->call->recv, mwi->portno);
12449 } else {
12450 mwi->portno = ast_sockaddr_port(&mwi->call->sa);
12451 }
12452
12453
12454 if (!ast_strlen_zero(mwi->authuser)) {
12455 ast_string_field_set(mwi->call, peername, mwi->authuser);
12456 ast_string_field_set(mwi->call, authname, mwi->authuser);
12457 ast_string_field_set(mwi->call, fromuser, mwi->authuser);
12458 } else {
12459 ast_string_field_set(mwi->call, peername, mwi->username);
12460 ast_string_field_set(mwi->call, authname, mwi->username);
12461 ast_string_field_set(mwi->call, fromuser, mwi->username);
12462 }
12463 ast_string_field_set(mwi->call, username, mwi->username);
12464 if (!ast_strlen_zero(mwi->secret)) {
12465 ast_string_field_set(mwi->call, peersecret, mwi->secret);
12466 }
12467 set_socket_transport(&mwi->call->socket, mwi->transport);
12468 mwi->call->socket.port = htons(mwi->portno);
12469 ast_sip_ouraddrfor(&mwi->call->sa, &mwi->call->ourip, mwi->call);
12470 build_contact(mwi->call);
12471 build_via(mwi->call);
12472
12473
12474 change_callid_pvt(mwi->call, NULL);
12475
12476 ast_set_flag(&mwi->call->flags[0], SIP_OUTGOING);
12477
12478
12479 mwi->call->mwi = ASTOBJ_REF(mwi);
12480
12481 mwi->call->subscribed = MWI_NOTIFICATION;
12482
12483
12484 transmit_invite(mwi->call, SIP_SUBSCRIBE, 0, 2, NULL);
12485
12486 return 0;
12487 }
12488
12489
12490 static int find_calling_channel(void *obj, void *arg, void *data, int flags)
12491 {
12492 struct ast_channel *c = obj;
12493 struct sip_pvt *p = data;
12494 int res;
12495
12496 ast_channel_lock(c);
12497
12498 res = (c->pbx &&
12499 (!strcasecmp(c->macroexten, p->exten) || !strcasecmp(c->exten, p->exten)) &&
12500 (sip_cfg.notifycid == IGNORE_CONTEXT || !strcasecmp(c->context, p->context)));
12501
12502 ast_channel_unlock(c);
12503
12504 return res ? CMP_MATCH | CMP_STOP : 0;
12505 }
12506
12507
12508 static void state_notify_build_xml(int state, int full, const char *exten, const char *context, struct ast_str **tmp, struct sip_pvt *p, int subscribed, const char *mfrom, const char *mto)
12509 {
12510 enum state { NOTIFY_OPEN, NOTIFY_INUSE, NOTIFY_CLOSED } local_state = NOTIFY_OPEN;
12511 const char *statestring = "terminated";
12512 const char *pidfstate = "--";
12513 const char *pidfnote= "Ready";
12514 char hint[AST_MAX_EXTENSION];
12515
12516 switch (state) {
12517 case (AST_EXTENSION_RINGING | AST_EXTENSION_INUSE):
12518 statestring = (sip_cfg.notifyringing) ? "early" : "confirmed";
12519 local_state = NOTIFY_INUSE;
12520 pidfstate = "busy";
12521 pidfnote = "Ringing";
12522 break;
12523 case AST_EXTENSION_RINGING:
12524 statestring = "early";
12525 local_state = NOTIFY_INUSE;
12526 pidfstate = "busy";
12527 pidfnote = "Ringing";
12528 break;
12529 case AST_EXTENSION_INUSE:
12530 statestring = "confirmed";
12531 local_state = NOTIFY_INUSE;
12532 pidfstate = "busy";
12533 pidfnote = "On the phone";
12534 break;
12535 case AST_EXTENSION_BUSY:
12536 statestring = "confirmed";
12537 local_state = NOTIFY_CLOSED;
12538 pidfstate = "busy";
12539 pidfnote = "On the phone";
12540 break;
12541 case AST_EXTENSION_UNAVAILABLE:
12542 statestring = "terminated";
12543 local_state = NOTIFY_CLOSED;
12544 pidfstate = "away";
12545 pidfnote = "Unavailable";
12546 break;
12547 case AST_EXTENSION_ONHOLD:
12548 statestring = "confirmed";
12549 local_state = NOTIFY_CLOSED;
12550 pidfstate = "busy";
12551 pidfnote = "On hold";
12552 break;
12553 case AST_EXTENSION_NOT_INUSE:
12554 default:
12555
12556 break;
12557 }
12558
12559
12560 if (ast_get_hint(hint, sizeof(hint), NULL, 0, NULL, context, exten)) {
12561 char *hint2 = hint, *individual_hint = NULL;
12562 int hint_count = 0, unavailable_count = 0;
12563
12564 while ((individual_hint = strsep(&hint2, "&"))) {
12565 hint_count++;
12566
12567 if (ast_device_state(individual_hint) == AST_DEVICE_UNAVAILABLE)
12568 unavailable_count++;
12569 }
12570
12571
12572
12573
12574 if (hint_count > 0 && hint_count == unavailable_count) {
12575 local_state = NOTIFY_CLOSED;
12576 pidfstate = "away";
12577 pidfnote = "Not online";
12578 }
12579 }
12580
12581 switch (subscribed) {
12582 case XPIDF_XML:
12583 case CPIM_PIDF_XML:
12584 ast_str_append(tmp, 0,
12585 "<?xml version=\"1.0\"?>\n"
12586 "<!DOCTYPE presence PUBLIC \"-//IETF//DTD RFCxxxx XPIDF 1.0//EN\" \"xpidf.dtd\">\n"
12587 "<presence>\n");
12588 ast_str_append(tmp, 0, "<presentity uri=\"%s;method=SUBSCRIBE\" />\n", mfrom);
12589 ast_str_append(tmp, 0, "<atom id=\"%s\">\n", exten);
12590 ast_str_append(tmp, 0, "<address uri=\"%s;user=ip\" priority=\"0.800000\">\n", mto);
12591 ast_str_append(tmp, 0, "<status status=\"%s\" />\n", (local_state == NOTIFY_OPEN) ? "open" : (local_state == NOTIFY_INUSE) ? "inuse" : "closed");
12592 ast_str_append(tmp, 0, "<msnsubstatus substatus=\"%s\" />\n", (local_state == NOTIFY_OPEN) ? "online" : (local_state == NOTIFY_INUSE) ? "onthephone" : "offline");
12593 ast_str_append(tmp, 0, "</address>\n</atom>\n</presence>\n");
12594 break;
12595 case PIDF_XML:
12596 ast_str_append(tmp, 0,
12597 "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n"
12598 "<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);
12599 ast_str_append(tmp, 0, "<pp:person><status>\n");
12600 if (pidfstate[0] != '-') {
12601 ast_str_append(tmp, 0, "<ep:activities><ep:%s/></ep:activities>\n", pidfstate);
12602 }
12603 ast_str_append(tmp, 0, "</status></pp:person>\n");
12604 ast_str_append(tmp, 0, "<note>%s</note>\n", pidfnote);
12605 ast_str_append(tmp, 0, "<tuple id=\"%s\">\n", exten);
12606 ast_str_append(tmp, 0, "<contact priority=\"1\">%s</contact>\n", mto);
12607 if (pidfstate[0] == 'b')
12608 ast_str_append(tmp, 0, "<status><basic>open</basic></status>\n");
12609 else
12610 ast_str_append(tmp, 0, "<status><basic>%s</basic></status>\n", (local_state != NOTIFY_CLOSED) ? "open" : "closed");
12611 ast_str_append(tmp, 0, "</tuple>\n</presence>\n");
12612 break;
12613 case DIALOG_INFO_XML:
12614 ast_str_append(tmp, 0, "<?xml version=\"1.0\"?>\n");
12615 ast_str_append(tmp, 0, "<dialog-info xmlns=\"urn:ietf:params:xml:ns:dialog-info\" version=\"%u\" state=\"%s\" entity=\"%s\">\n", p->dialogver, full ? "full" : "partial", mto);
12616 if ((state & AST_EXTENSION_RINGING) && sip_cfg.notifyringing) {
12617 const char *local_display = exten;
12618 char *local_target = ast_strdupa(mto);
12619
12620
12621
12622
12623 if (sip_cfg.notifycid) {
12624 struct ast_channel *caller;
12625
12626 if ((caller = ast_channel_callback(find_calling_channel, NULL, p, 0))) {
12627 char *cid_num;
12628 int need;
12629
12630 ast_channel_lock(caller);
12631 cid_num = S_COR(caller->caller.id.number.valid,
12632 caller->caller.id.number.str, "");
12633 need = strlen(cid_num) + strlen(p->fromdomain) + sizeof("sip:@");
12634 local_target = alloca(need);
12635 snprintf(local_target, need, "sip:%s@%s", cid_num, p->fromdomain);
12636 local_display = ast_strdupa(S_COR(caller->caller.id.name.valid,
12637 caller->caller.id.name.str, ""));
12638 ast_channel_unlock(caller);
12639 caller = ast_channel_unref(caller);
12640 }
12641
12642
12643
12644 if (sip_cfg.pedanticsipchecking) {
12645 ast_str_append(tmp, 0, "<dialog id=\"%s\" call-id=\"pickup-%s\" local-tag=\"%s\" remote-tag=\"%s\" direction=\"recipient\">\n",
12646 exten, p->callid, p->theirtag, p->tag);
12647 } else {
12648 ast_str_append(tmp, 0, "<dialog id=\"%s\" call-id=\"pickup-%s\" direction=\"recipient\">\n",
12649 exten, p->callid);
12650 }
12651 ast_str_append(tmp, 0,
12652 "<remote>\n"
12653
12654
12655 "<identity display=\"%s\">%s</identity>\n"
12656 "<target uri=\"%s\"/>\n"
12657 "</remote>\n"
12658 "<local>\n"
12659 "<identity>%s</identity>\n"
12660 "<target uri=\"%s\"/>\n"
12661 "</local>\n",
12662 local_display, local_target, local_target, mto, mto);
12663 } else {
12664 ast_str_append(tmp, 0, "<dialog id=\"%s\" direction=\"recipient\">\n", exten);
12665 }
12666
12667 } else {
12668 ast_str_append(tmp, 0, "<dialog id=\"%s\">\n", exten);
12669 }
12670 ast_str_append(tmp, 0, "<state>%s</state>\n", statestring);
12671 if (state == AST_EXTENSION_ONHOLD) {
12672 ast_str_append(tmp, 0, "<local>\n<target uri=\"%s\">\n"
12673 "<param pname=\"+sip.rendering\" pvalue=\"no\"/>\n"
12674 "</target>\n</local>\n", mto);
12675 }
12676 ast_str_append(tmp, 0, "</dialog>\n</dialog-info>\n");
12677 break;
12678 case NONE:
12679 default:
12680 break;
12681 }
12682 }
12683
12684 static int transmit_cc_notify(struct ast_cc_agent *agent, struct sip_pvt *subscription, enum sip_cc_notify_state state)
12685 {
12686 struct sip_request req;
12687 struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
12688 char uri[SIPBUFSIZE];
12689 char state_str[64];
12690 char subscription_state_hdr[64];
12691
12692 if (state < CC_QUEUED || state > CC_READY) {
12693 ast_log(LOG_WARNING, "Invalid state provided for transmit_cc_notify (%d)\n", state);
12694 return -1;
12695 }
12696
12697 reqprep(&req, subscription, SIP_NOTIFY, 0, TRUE);
12698 snprintf(state_str, sizeof(state_str), "%s\r\n", sip_cc_notify_state_map[state].state_string);
12699 add_header(&req, "Event", "call-completion");
12700 add_header(&req, "Content-Type", "application/call-completion");
12701 snprintf(subscription_state_hdr, sizeof(subscription_state_hdr), "active;expires=%d", subscription->expiry);
12702 add_header(&req, "Subscription-State", subscription_state_hdr);
12703 if (state == CC_READY) {
12704 generate_uri(subscription, agent_pvt->notify_uri, sizeof(agent_pvt->notify_uri));
12705 snprintf(uri, sizeof(uri) - 1, "cc-URI: %s\r\n", agent_pvt->notify_uri);
12706 }
12707 add_content(&req, state_str);
12708 if (state == CC_READY) {
12709 add_content(&req, uri);
12710 }
12711 return send_request(subscription, &req, XMIT_RELIABLE, subscription->ocseq);
12712 }
12713
12714
12715 static int transmit_state_notify(struct sip_pvt *p, int state, int full, int timeout)
12716 {
12717 struct ast_str *tmp = ast_str_alloca(4000);
12718 char from[256], to[256];
12719 char *c, *mfrom, *mto;
12720 struct sip_request req;
12721 const struct cfsubscription_types *subscriptiontype;
12722
12723 memset(from, 0, sizeof(from));
12724 memset(to, 0, sizeof(to));
12725
12726 subscriptiontype = find_subscription_type(p->subscribed);
12727
12728 ast_copy_string(from, get_header(&p->initreq, "From"), sizeof(from));
12729 c = get_in_brackets(from);
12730 if (strncasecmp(c, "sip:", 4) && strncasecmp(c, "sips:", 5)) {
12731 ast_log(LOG_WARNING, "Huh? Not a SIP header (%s)?\n", c);
12732 return -1;
12733 }
12734
12735 mfrom = remove_uri_parameters(c);
12736
12737 ast_copy_string(to, get_header(&p->initreq, "To"), sizeof(to));
12738 c = get_in_brackets(to);
12739 if (strncasecmp(c, "sip:", 4) && strncasecmp(c, "sips:", 5)) {
12740 ast_log(LOG_WARNING, "Huh? Not a SIP header (%s)?\n", c);
12741 return -1;
12742 }
12743 mto = remove_uri_parameters(c);
12744
12745 reqprep(&req, p, SIP_NOTIFY, 0, 1);
12746
12747 switch(state) {
12748 case AST_EXTENSION_DEACTIVATED:
12749 if (timeout)
12750 add_header(&req, "Subscription-State", "terminated;reason=timeout");
12751 else {
12752 add_header(&req, "Subscription-State", "terminated;reason=probation");
12753 add_header(&req, "Retry-After", "60");
12754 }
12755 break;
12756 case AST_EXTENSION_REMOVED:
12757 add_header(&req, "Subscription-State", "terminated;reason=noresource");
12758 break;
12759 default:
12760 if (p->expiry)
12761 add_header(&req, "Subscription-State", "active");
12762 else
12763 add_header(&req, "Subscription-State", "terminated;reason=timeout");
12764 }
12765
12766 switch (p->subscribed) {
12767 case XPIDF_XML:
12768 case CPIM_PIDF_XML:
12769 add_header(&req, "Event", subscriptiontype->event);
12770 state_notify_build_xml(state, full, p->exten, p->context, &tmp, p, p->subscribed, mfrom, mto);
12771 add_header(&req, "Content-Type", subscriptiontype->mediatype);
12772 p->dialogver++;
12773 break;
12774 case PIDF_XML:
12775 add_header(&req, "Event", subscriptiontype->event);
12776 state_notify_build_xml(state, full, p->exten, p->context, &tmp, p, p->subscribed, mfrom, mto);
12777 add_header(&req, "Content-Type", subscriptiontype->mediatype);
12778 p->dialogver++;
12779 break;
12780 case DIALOG_INFO_XML:
12781 add_header(&req, "Event", subscriptiontype->event);
12782 state_notify_build_xml(state, full, p->exten, p->context, &tmp, p, p->subscribed, mfrom, mto);
12783 add_header(&req, "Content-Type", subscriptiontype->mediatype);
12784 p->dialogver++;
12785 break;
12786 case NONE:
12787 default:
12788 break;
12789 }
12790
12791 add_content(&req, tmp->str);
12792
12793 p->pendinginvite = p->ocseq;
12794
12795 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
12796 }
12797
12798
12799
12800
12801
12802
12803
12804 static int transmit_notify_with_mwi(struct sip_pvt *p, int newmsgs, int oldmsgs, const char *vmexten)
12805 {
12806 struct sip_request req;
12807 struct ast_str *out = ast_str_alloca(500);
12808 int ourport = (p->fromdomainport) ? p->fromdomainport : ast_sockaddr_port(&p->ourip);
12809 const char *domain;
12810 const char *exten = S_OR(vmexten, default_vmexten);
12811
12812 initreqprep(&req, p, SIP_NOTIFY, NULL);
12813 add_header(&req, "Event", "message-summary");
12814 add_header(&req, "Content-Type", default_notifymime);
12815 ast_str_append(&out, 0, "Messages-Waiting: %s\r\n", newmsgs ? "yes" : "no");
12816
12817
12818 domain = S_OR(p->fromdomain, ast_sockaddr_stringify_host_remote(&p->ourip));
12819
12820 if (!sip_standard_port(p->socket.type, ourport)) {
12821 if (p->socket.type == SIP_TRANSPORT_UDP) {
12822 ast_str_append(&out, 0, "Message-Account: sip:%s@%s:%d\r\n", exten, domain, ourport);
12823 } else {
12824 ast_str_append(&out, 0, "Message-Account: sip:%s@%s:%d;transport=%s\r\n", exten, domain, ourport, get_transport(p->socket.type));
12825 }
12826 } else {
12827 if (p->socket.type == SIP_TRANSPORT_UDP) {
12828 ast_str_append(&out, 0, "Message-Account: sip:%s@%s\r\n", exten, domain);
12829 } else {
12830 ast_str_append(&out, 0, "Message-Account: sip:%s@%s;transport=%s\r\n", exten, domain, get_transport(p->socket.type));
12831 }
12832 }
12833
12834
12835
12836 ast_str_append(&out, 0, "Voice-Message: %d/%d%s\r\n",
12837 newmsgs, oldmsgs, (ast_test_flag(&p->flags[1], SIP_PAGE2_BUGGY_MWI) ? "" : " (0/0)"));
12838
12839 if (p->subscribed) {
12840 if (p->expiry) {
12841 add_header(&req, "Subscription-State", "active");
12842 } else {
12843 add_header(&req, "Subscription-State", "terminated;reason=timeout");
12844 }
12845 }
12846
12847 add_content(&req, out->str);
12848
12849 if (!p->initreq.headers) {
12850 initialize_initreq(p, &req);
12851 }
12852 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
12853 }
12854
12855
12856 static int transmit_notify_with_sipfrag(struct sip_pvt *p, int cseq, char *message, int terminate)
12857 {
12858 struct sip_request req;
12859 char tmp[SIPBUFSIZE/2];
12860
12861 reqprep(&req, p, SIP_NOTIFY, 0, 1);
12862 snprintf(tmp, sizeof(tmp), "refer;id=%d", cseq);
12863 add_header(&req, "Event", tmp);
12864 add_header(&req, "Subscription-state", terminate ? "terminated;reason=noresource" : "active");
12865 add_header(&req, "Content-Type", "message/sipfrag;version=2.0");
12866 add_header(&req, "Allow", ALLOWED_METHODS);
12867 add_supported_header(p, &req);
12868
12869 snprintf(tmp, sizeof(tmp), "SIP/2.0 %s\r\n", message);
12870 add_content(&req, tmp);
12871
12872 if (!p->initreq.headers) {
12873 initialize_initreq(p, &req);
12874 }
12875
12876 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
12877 }
12878
12879 static int manager_sipnotify(struct mansession *s, const struct message *m)
12880 {
12881 const char *channame = astman_get_header(m, "Channel");
12882 struct ast_variable *vars = astman_get_variables(m);
12883 struct sip_pvt *p;
12884 struct ast_variable *header, *var;
12885
12886 if (ast_strlen_zero(channame)) {
12887 astman_send_error(s, m, "SIPNotify requires a channel name");
12888 return 0;
12889 }
12890
12891 if (!strncasecmp(channame, "sip/", 4)) {
12892 channame += 4;
12893 }
12894
12895 if (!(p = sip_alloc(NULL, NULL, 0, SIP_NOTIFY, NULL))) {
12896 astman_send_error(s, m, "Unable to build sip pvt data for notify (memory/socket error)");
12897 return 0;
12898 }
12899
12900 if (create_addr(p, channame, NULL, 0, NULL)) {
12901
12902 dialog_unlink_all(p);
12903 dialog_unref(p, "unref dialog inside for loop" );
12904
12905 astman_send_error(s, m, "Could not create address");
12906 return 0;
12907 }
12908
12909
12910 ast_set_flag(&p->flags[0], SIP_OUTGOING);
12911 sip_notify_allocate(p);
12912
12913 p->notify->headers = header = ast_variable_new("Subscription-State", "terminated", "");
12914
12915 for (var = vars; var; var = var->next) {
12916 if (!strcasecmp(var->name, "Content")) {
12917 if (ast_str_strlen(p->notify->content))
12918 ast_str_append(&p->notify->content, 0, "\r\n");
12919 ast_str_append(&p->notify->content, 0, "%s", var->value);
12920 } else if (!strcasecmp(var->name, "Content-Length")) {
12921 ast_log(LOG_WARNING, "it is not necessary to specify Content-Length, ignoring");
12922 } else {
12923 header->next = ast_variable_new(var->name, var->value, "");
12924 header = header->next;
12925 }
12926 }
12927
12928 sip_scheddestroy(p, SIP_TRANS_TIMEOUT);
12929 transmit_invite(p, SIP_NOTIFY, 0, 2, NULL);
12930 dialog_unref(p, "bump down the count of p since we're done with it.");
12931
12932 astman_send_ack(s, m, "Notify Sent");
12933 ast_variables_destroy(vars);
12934 return 0;
12935 }
12936
12937
12938
12939 static void update_redirecting(struct sip_pvt *p, const void *data, size_t datalen)
12940 {
12941 struct sip_request resp;
12942
12943 if (p->owner->_state == AST_STATE_UP || ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
12944 return;
12945 }
12946
12947 respprep(&resp, p, "181 Call is being forwarded", &p->initreq);
12948 add_diversion_header(&resp, p);
12949 send_response(p, &resp, XMIT_UNRELIABLE, 0);
12950 }
12951
12952
12953 static void update_connectedline(struct sip_pvt *p, const void *data, size_t datalen)
12954 {
12955
12956 if (!ast_test_flag(&p->flags[0], SIP_SENDRPID)) {
12957 return;
12958 }
12959 if (!p->owner->connected.id.number.valid
12960 || ast_strlen_zero(p->owner->connected.id.number.str)) {
12961 return;
12962 }
12963
12964 append_history(p, "ConnectedLine", "%s party is now %s <%s>",
12965 ast_test_flag(&p->flags[0], SIP_OUTGOING) ? "Calling" : "Called",
12966 S_COR(p->owner->connected.id.name.valid, p->owner->connected.id.name.str, ""),
12967 S_COR(p->owner->connected.id.number.valid, p->owner->connected.id.number.str, ""));
12968
12969 if (p->owner->_state == AST_STATE_UP || ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
12970 struct sip_request req;
12971
12972 if (p->invitestate == INV_CONFIRMED || p->invitestate == INV_TERMINATED) {
12973 reqprep(&req, p, ast_test_flag(&p->flags[0], SIP_REINVITE_UPDATE) ? SIP_UPDATE : SIP_INVITE, 0, 1);
12974
12975 add_header(&req, "Allow", ALLOWED_METHODS);
12976 add_supported_header(p, &req);
12977 add_rpid(&req, p);
12978 add_sdp(&req, p, FALSE, TRUE, FALSE);
12979
12980 initialize_initreq(p, &req);
12981 p->lastinvite = p->ocseq;
12982 ast_set_flag(&p->flags[0], SIP_OUTGOING);
12983 p->invitestate = INV_CALLING;
12984 send_request(p, &req, XMIT_CRITICAL, p->ocseq);
12985 } else if ((is_method_allowed(&p->allowed_methods, SIP_UPDATE)) && (!ast_strlen_zero(p->okcontacturi))) {
12986 reqprep(&req, p, SIP_UPDATE, 0, 1);
12987 add_rpid(&req, p);
12988 add_header(&req, "X-Asterisk-rpid-update", "Yes");
12989 send_request(p, &req, XMIT_CRITICAL, p->ocseq);
12990 } else {
12991
12992 ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
12993 }
12994 } else {
12995 ast_set_flag(&p->flags[1], SIP_PAGE2_CONNECTLINEUPDATE_PEND);
12996 if (ast_test_flag(&p->flags[1], SIP_PAGE2_RPID_IMMEDIATE)) {
12997 struct sip_request resp;
12998
12999 if ((p->owner->_state == AST_STATE_RING) && !ast_test_flag(&p->flags[0], SIP_PROGRESS_SENT)) {
13000 ast_clear_flag(&p->flags[1], SIP_PAGE2_CONNECTLINEUPDATE_PEND);
13001 respprep(&resp, p, "180 Ringing", &p->initreq);
13002 add_rpid(&resp, p);
13003 send_response(p, &resp, XMIT_UNRELIABLE, 0);
13004 ast_set_flag(&p->flags[0], SIP_RINGING);
13005 } else if (p->owner->_state == AST_STATE_RINGING) {
13006 ast_clear_flag(&p->flags[1], SIP_PAGE2_CONNECTLINEUPDATE_PEND);
13007 respprep(&resp, p, "183 Session Progress", &p->initreq);
13008 add_rpid(&resp, p);
13009 send_response(p, &resp, XMIT_UNRELIABLE, 0);
13010 ast_set_flag(&p->flags[0], SIP_PROGRESS_SENT);
13011 } else {
13012 ast_debug(1, "Unable able to send update to '%s' in state '%s'\n", p->owner->name, ast_state2str(p->owner->_state));
13013 }
13014 }
13015 }
13016 }
13017
13018 static const struct _map_x_s regstatestrings[] = {
13019 { REG_STATE_FAILED, "Failed" },
13020 { REG_STATE_UNREGISTERED, "Unregistered"},
13021 { REG_STATE_REGSENT, "Request Sent"},
13022 { REG_STATE_AUTHSENT, "Auth. Sent"},
13023 { REG_STATE_REGISTERED, "Registered"},
13024 { REG_STATE_REJECTED, "Rejected"},
13025 { REG_STATE_TIMEOUT, "Timeout"},
13026 { REG_STATE_NOAUTH, "No Authentication"},
13027 { -1, NULL }
13028 };
13029
13030
13031 static const char *regstate2str(enum sipregistrystate regstate)
13032 {
13033 return map_x_s(regstatestrings, regstate, "Unknown");
13034 }
13035
13036
13037
13038
13039
13040
13041
13042 static int sip_reregister(const void *data)
13043 {
13044
13045 struct sip_registry *r = (struct sip_registry *) data;
13046
13047
13048 if (!r) {
13049 return 0;
13050 }
13051
13052 if (r->call && r->call->do_history) {
13053 append_history(r->call, "RegistryRenew", "Account: %s@%s", r->username, r->hostname);
13054 }
13055
13056
13057 if (sipdebug) {
13058 ast_log(LOG_NOTICE, " -- Re-registration for %s@%s\n", r->username, r->hostname);
13059 }
13060
13061 r->expire = -1;
13062 r->expiry = r->configured_expiry;
13063 __sip_do_register(r);
13064 registry_unref(r, "unref the re-register scheduled event");
13065 return 0;
13066 }
13067
13068
13069
13070
13071 static int __sip_do_register(struct sip_registry *r)
13072 {
13073 int res;
13074
13075 res = transmit_register(r, SIP_REGISTER, NULL, NULL);
13076 return res;
13077 }
13078
13079
13080
13081
13082
13083
13084
13085 static int sip_reg_timeout(const void *data)
13086 {
13087
13088
13089 struct sip_registry *r = (struct sip_registry *)data;
13090 struct sip_pvt *p;
13091
13092
13093 if (!r) {
13094 return 0;
13095 }
13096
13097 if (r->dnsmgr) {
13098
13099 ast_dnsmgr_refresh(r->dnsmgr);
13100 }
13101
13102
13103
13104
13105
13106 if (r->call) {
13107
13108
13109 p = r->call;
13110 sip_pvt_lock(p);
13111 pvt_set_needdestroy(p, "registration timeout");
13112
13113 __sip_pretend_ack(p);
13114 sip_pvt_unlock(p);
13115
13116
13117
13118 if (p->registry) {
13119 p->registry = registry_unref(p->registry, "p->registry unreffed");
13120 }
13121 r->call = dialog_unref(r->call, "unrefing r->call");
13122 }
13123
13124 r->timeout = -1;
13125 if (global_regattempts_max && r->regattempts >= global_regattempts_max) {
13126
13127
13128
13129 ast_log(LOG_NOTICE, " -- Last Registration Attempt #%d failed, Giving up forever trying to register '%s@%s'\n", r->regattempts, r->username, r->hostname);
13130 r->regstate = REG_STATE_FAILED;
13131 } else {
13132 r->regstate = REG_STATE_UNREGISTERED;
13133 transmit_register(r, SIP_REGISTER, NULL, NULL);
13134 ast_log(LOG_NOTICE, " -- Registration for '%s@%s' timed out, trying again (Attempt #%d)\n", r->username, r->hostname, r->regattempts);
13135 }
13136 manager_event(EVENT_FLAG_SYSTEM, "Registry", "ChannelType: SIP\r\nUsername: %s\r\nDomain: %s\r\nStatus: %s\r\n", r->username, r->hostname, regstate2str(r->regstate));
13137 registry_unref(r, "unreffing registry_unref r");
13138 return 0;
13139 }
13140
13141 static const char *sip_sanitized_host(const char *host)
13142 {
13143 struct ast_sockaddr addr = { { 0, 0, }, };
13144
13145
13146
13147
13148 if (!ast_sockaddr_parse(&addr, host, PARSE_PORT_FORBID)) {
13149 return host;
13150 }
13151 return ast_sockaddr_stringify_host_remote(&addr);
13152 }
13153
13154
13155
13156
13157 static int transmit_register(struct sip_registry *r, int sipmethod, const char *auth, const char *authheader)
13158 {
13159 struct sip_request req;
13160 char from[256];
13161 char to[256];
13162 char tmp[80];
13163 char addr[80];
13164 struct sip_pvt *p;
13165 struct sip_peer *peer = NULL;
13166 int res;
13167 int portno = 0;
13168
13169
13170 if (r == NULL || ((auth == NULL) && (r->regstate == REG_STATE_REGSENT || r->regstate == REG_STATE_AUTHSENT))) {
13171 if (r) {
13172 ast_log(LOG_NOTICE, "Strange, trying to register %s@%s when registration already pending\n", r->username, r->hostname);
13173 }
13174 return 0;
13175 }
13176
13177 if (r->dnsmgr == NULL) {
13178 char transport[MAXHOSTNAMELEN];
13179 peer = find_peer(r->hostname, NULL, TRUE, FINDPEERS, FALSE, 0);
13180 snprintf(transport, sizeof(transport), "_%s._%s",get_srv_service(r->transport), get_srv_protocol(r->transport));
13181 r->us.ss.ss_family = get_address_family_filter(&bindaddr);
13182
13183
13184
13185
13186
13187 if (!obproxy_get(r->call, peer)) {
13188 registry_addref(r, "add reg ref for dnsmgr");
13189 ast_dnsmgr_lookup_cb(peer ? peer->tohost : r->hostname, &r->us, &r->dnsmgr, sip_cfg.srvlookup ? transport : NULL, on_dns_update_registry, r);
13190 if (!r->dnsmgr) {
13191
13192 registry_unref(r, "remove reg ref, dnsmgr disabled");
13193 }
13194 }
13195 if (peer) {
13196 peer = unref_peer(peer, "removing peer ref for dnsmgr_lookup");
13197 }
13198 }
13199
13200 if (r->call) {
13201 if (!auth) {
13202 ast_log(LOG_WARNING, "Already have a REGISTER going on to %s@%s?? \n", r->username, r->hostname);
13203 return 0;
13204 } else {
13205 p = dialog_ref(r->call, "getting a copy of the r->call dialog in transmit_register");
13206 make_our_tag(p->tag, sizeof(p->tag));
13207 ast_string_field_set(p, theirtag, NULL);
13208 }
13209 } else {
13210
13211 if (!r->callid_valid) {
13212 build_callid_registry(r, &internip, default_fromdomain);
13213 r->callid_valid = TRUE;
13214 }
13215
13216 if (!(p = sip_alloc( r->callid, NULL, 0, SIP_REGISTER, NULL))) {
13217 ast_log(LOG_WARNING, "Unable to allocate registration transaction (memory or socket error)\n");
13218 return 0;
13219 }
13220
13221 if (p->do_history) {
13222 append_history(p, "RegistryInit", "Account: %s@%s", r->username, r->hostname);
13223 }
13224
13225
13226 if (!ast_sockaddr_isnull(&r->us)) {
13227 if (!ast_sockaddr_port(&r->us) && r->portno) {
13228 ast_sockaddr_set_port(&r->us, r->portno);
13229 }
13230
13231
13232
13233
13234
13235 if ((peer = find_peer(S_OR(r->peername, r->hostname), NULL, TRUE, FINDPEERS, FALSE, 0))) {
13236 if (ast_sockaddr_cmp(&peer->addr, &r->us)) {
13237 on_dns_update_peer(&peer->addr, &r->us, peer);
13238 }
13239 peer = unref_peer(peer, "unref after find_peer");
13240 }
13241 }
13242
13243
13244 if (create_addr(p, S_OR(r->peername, r->hostname), &r->us, 0, NULL)) {
13245
13246
13247 dialog_unlink_all(p);
13248 p = dialog_unref(p, "unref dialog after unlink_all");
13249 if (r->timeout > -1) {
13250 AST_SCHED_REPLACE_UNREF(r->timeout, sched, global_reg_timeout * 1000, sip_reg_timeout, r,
13251 registry_unref(_data, "del for REPLACE of registry ptr"),
13252 registry_unref(r, "object ptr dec when SCHED_REPLACE add failed"),
13253 registry_addref(r,"add for REPLACE registry ptr"));
13254 ast_log(LOG_WARNING, "Still have a registration timeout for %s@%s (create_addr() error), %d\n", r->username, r->hostname, r->timeout);
13255 } else {
13256 r->timeout = ast_sched_add(sched, global_reg_timeout * 1000, sip_reg_timeout, registry_addref(r, "add for REPLACE registry ptr"));
13257 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);
13258 }
13259 r->regattempts++;
13260 return 0;
13261 }
13262
13263
13264 ast_string_field_set(r, callid, p->callid);
13265
13266 if (!r->dnsmgr && r->portno) {
13267 ast_sockaddr_set_port(&p->sa, r->portno);
13268 ast_sockaddr_set_port(&p->recv, r->portno);
13269 }
13270 if (!ast_strlen_zero(p->fromdomain)) {
13271 portno = (p->fromdomainport) ? p->fromdomainport : STANDARD_SIP_PORT;
13272 } else if (!ast_strlen_zero(r->regdomain)) {
13273 portno = (r->regdomainport) ? r->regdomainport : STANDARD_SIP_PORT;
13274 } else {
13275 portno = ast_sockaddr_port(&p->sa);
13276 }
13277
13278 ast_set_flag(&p->flags[0], SIP_OUTGOING);
13279 r->call = dialog_ref(p, "copying dialog into registry r->call");
13280 p->registry = registry_addref(r, "transmit_register: addref to p->registry in transmit_register");
13281 if (!ast_strlen_zero(r->secret)) {
13282 ast_string_field_set(p, peersecret, r->secret);
13283 }
13284 if (!ast_strlen_zero(r->md5secret))
13285 ast_string_field_set(p, peermd5secret, r->md5secret);
13286
13287
13288 if (!ast_strlen_zero(r->authuser)) {
13289 ast_string_field_set(p, peername, r->authuser);
13290 ast_string_field_set(p, authname, r->authuser);
13291 } else if (!ast_strlen_zero(r->username)) {
13292 ast_string_field_set(p, peername, r->username);
13293 ast_string_field_set(p, authname, r->username);
13294 ast_string_field_set(p, fromuser, r->username);
13295 }
13296 if (!ast_strlen_zero(r->username)) {
13297 ast_string_field_set(p, username, r->username);
13298 }
13299
13300 if (!ast_strlen_zero(r->callback)) {
13301 ast_string_field_set(p, exten, r->callback);
13302 }
13303
13304
13305 set_socket_transport(&p->socket, r->transport);
13306 if (r->transport == SIP_TRANSPORT_TLS || r->transport == SIP_TRANSPORT_TCP) {
13307 p->socket.port =
13308 htons(ast_sockaddr_port(&sip_tcp_desc.local_address));
13309 }
13310
13311
13312
13313
13314
13315
13316 ast_sip_ouraddrfor(&p->sa, &p->ourip, p);
13317 build_contact(p);
13318 }
13319
13320
13321 if (auth == NULL) {
13322 if (r->timeout > -1) {
13323 ast_log(LOG_WARNING, "Still have a registration timeout, #%d - deleting it\n", r->timeout);
13324 }
13325 AST_SCHED_REPLACE_UNREF(r->timeout, sched, global_reg_timeout * 1000, sip_reg_timeout, r,
13326 registry_unref(_data,"reg ptr unrefed from del in SCHED_REPLACE"),
13327 registry_unref(r,"reg ptr unrefed from add failure in SCHED_REPLACE"),
13328 registry_addref(r,"reg ptr reffed from add in SCHED_REPLACE"));
13329 ast_debug(1, "Scheduled a registration timeout for %s id #%d \n", r->hostname, r->timeout);
13330 }
13331
13332 snprintf(from, sizeof(from), "<sip:%s@%s>;tag=%s", r->username, S_OR(r->regdomain, sip_sanitized_host(p->tohost)), p->tag);
13333 if (!ast_strlen_zero(p->theirtag)) {
13334 snprintf(to, sizeof(to), "<sip:%s@%s>;tag=%s", r->username, S_OR(r->regdomain, sip_sanitized_host(p->tohost)), p->theirtag);
13335 } else {
13336 snprintf(to, sizeof(to), "<sip:%s@%s>", r->username, S_OR(r->regdomain, sip_sanitized_host(p->tohost)));
13337 }
13338
13339
13340
13341 if (portno && portno != STANDARD_SIP_PORT) {
13342 snprintf(addr, sizeof(addr), "sip:%s:%d", S_OR(p->fromdomain,S_OR(r->regdomain, sip_sanitized_host(r->hostname))), portno);
13343 } else {
13344 snprintf(addr, sizeof(addr), "sip:%s", S_OR(p->fromdomain,S_OR(r->regdomain, sip_sanitized_host(r->hostname))));
13345 }
13346
13347 ast_string_field_set(p, uri, addr);
13348
13349 p->branch ^= ast_random();
13350
13351 init_req(&req, sipmethod, addr);
13352
13353
13354 snprintf(tmp, sizeof(tmp), "%u %s", ++r->ocseq, sip_methods[sipmethod].text);
13355 p->ocseq = r->ocseq;
13356
13357 build_via(p);
13358 add_header(&req, "Via", p->via);
13359 add_header_max_forwards(p, &req);
13360 add_header(&req, "From", from);
13361 add_header(&req, "To", to);
13362 add_header(&req, "Call-ID", p->callid);
13363 add_header(&req, "CSeq", tmp);
13364 if (!ast_strlen_zero(global_useragent))
13365 add_header(&req, "User-Agent", global_useragent);
13366
13367 if (auth) {
13368 add_header(&req, authheader, auth);
13369 } else if (!ast_strlen_zero(r->nonce)) {
13370 char digest[1024];
13371
13372
13373
13374
13375
13376
13377 if (sipdebug) {
13378 ast_debug(1, " >>> Re-using Auth data for %s@%s\n", r->username, r->hostname);
13379 }
13380 ast_string_field_set(p, realm, r->realm);
13381 ast_string_field_set(p, nonce, r->nonce);
13382 ast_string_field_set(p, domain, r->authdomain);
13383 ast_string_field_set(p, opaque, r->opaque);
13384 ast_string_field_set(p, qop, r->qop);
13385 p->noncecount = ++r->noncecount;
13386
13387 memset(digest, 0, sizeof(digest));
13388 if(!build_reply_digest(p, sipmethod, digest, sizeof(digest))) {
13389 add_header(&req, "Authorization", digest);
13390 } else {
13391 ast_log(LOG_NOTICE, "No authorization available for authentication of registration to %s@%s\n", r->username, r->hostname);
13392 }
13393 }
13394
13395 snprintf(tmp, sizeof(tmp), "%d", r->expiry);
13396 add_header(&req, "Expires", tmp);
13397 add_header(&req, "Contact", p->our_contact);
13398
13399 initialize_initreq(p, &req);
13400 if (sip_debug_test_pvt(p)) {
13401 ast_verbose("REGISTER %d headers, %d lines\n", p->initreq.headers, p->initreq.lines);
13402 }
13403 r->regstate = auth ? REG_STATE_AUTHSENT : REG_STATE_REGSENT;
13404 r->regattempts++;
13405 ast_debug(4, "REGISTER attempt %d to %s@%s\n", r->regattempts, r->username, r->hostname);
13406 res = send_request(p, &req, XMIT_CRITICAL, p->ocseq);
13407 dialog_unref(p, "p is finished here at the end of transmit_register");
13408 return res;
13409 }
13410
13411
13412 static int transmit_message_with_text(struct sip_pvt *p, const char *text)
13413 {
13414 struct sip_request req;
13415
13416 reqprep(&req, p, SIP_MESSAGE, 0, 1);
13417 add_text(&req, text);
13418 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
13419 }
13420
13421
13422 static int sip_refer_allocate(struct sip_pvt *p)
13423 {
13424 p->refer = ast_calloc(1, sizeof(struct sip_refer));
13425 return p->refer ? 1 : 0;
13426 }
13427
13428
13429 static int sip_notify_allocate(struct sip_pvt *p)
13430 {
13431 p->notify = ast_calloc(1, sizeof(struct sip_notify));
13432 if (p->notify) {
13433 p->notify->content = ast_str_create(128);
13434 }
13435 return p->notify ? 1 : 0;
13436 }
13437
13438
13439
13440
13441
13442
13443 static int transmit_refer(struct sip_pvt *p, const char *dest)
13444 {
13445 struct sip_request req = {
13446 .headers = 0,
13447 };
13448 char from[256];
13449 const char *of;
13450 char *c;
13451 char referto[256];
13452 int use_tls=FALSE;
13453
13454 if (sipdebug) {
13455 ast_debug(1, "SIP transfer of %s to %s\n", p->callid, dest);
13456 }
13457
13458
13459 if (ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
13460 of = get_header(&p->initreq, "To");
13461 } else {
13462 of = get_header(&p->initreq, "From");
13463 }
13464
13465 ast_copy_string(from, of, sizeof(from));
13466 of = get_in_brackets(from);
13467 ast_string_field_set(p, from, of);
13468 if (!strncasecmp(of, "sip:", 4)) {
13469 of += 4;
13470 } else if (!strncasecmp(of, "sips:", 5)) {
13471 of += 5;
13472 use_tls = TRUE;
13473 } else {
13474 ast_log(LOG_NOTICE, "From address missing 'sip(s):', assuming sip:\n");
13475 }
13476
13477 if ((c = strchr(dest, '@'))) {
13478 c = NULL;
13479 } else if ((c = strchr(of, '@'))) {
13480 *c++ = '\0';
13481 }
13482 if (c) {
13483 snprintf(referto, sizeof(referto), "<sip%s:%s@%s>", use_tls ? "s" : "", dest, c);
13484 } else {
13485 snprintf(referto, sizeof(referto), "<sip%s:%s>", use_tls ? "s" : "", dest);
13486 }
13487
13488
13489 sip_refer_allocate(p);
13490 ast_copy_string(p->refer->refer_to, referto, sizeof(p->refer->refer_to));
13491 ast_copy_string(p->refer->referred_by, p->our_contact, sizeof(p->refer->referred_by));
13492 p->refer->status = REFER_SENT;
13493
13494 reqprep(&req, p, SIP_REFER, 0, 1);
13495
13496 add_header(&req, "Refer-To", referto);
13497 add_header(&req, "Allow", ALLOWED_METHODS);
13498 add_supported_header(p, &req);
13499 if (!ast_strlen_zero(p->our_contact)) {
13500 add_header(&req, "Referred-By", p->our_contact);
13501 }
13502
13503 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
13504
13505
13506
13507
13508
13509
13510
13511
13512
13513 }
13514
13515
13516 static int transmit_info_with_aoc(struct sip_pvt *p, struct ast_aoc_decoded *decoded)
13517 {
13518 struct sip_request req;
13519 struct ast_str *str = ast_str_alloca(512);
13520 const struct ast_aoc_unit_entry *unit_entry = ast_aoc_get_unit_info(decoded, 0);
13521 enum ast_aoc_charge_type charging = ast_aoc_get_charge_type(decoded);
13522
13523 reqprep(&req, p, SIP_INFO, 0, 1);
13524
13525 if (ast_aoc_get_msg_type(decoded) == AST_AOC_D) {
13526 ast_str_append(&str, 0, "type=active;");
13527 } else if (ast_aoc_get_msg_type(decoded) == AST_AOC_E) {
13528 ast_str_append(&str, 0, "type=terminated;");
13529 } else {
13530
13531 return -1;
13532 }
13533
13534 switch (charging) {
13535 case AST_AOC_CHARGE_FREE:
13536 ast_str_append(&str, 0, "free-of-charge;");
13537 break;
13538 case AST_AOC_CHARGE_CURRENCY:
13539 ast_str_append(&str, 0, "charging;");
13540 ast_str_append(&str, 0, "charging-info=currency;");
13541 ast_str_append(&str, 0, "amount=%u;", ast_aoc_get_currency_amount(decoded));
13542 ast_str_append(&str, 0, "multiplier=%s;", ast_aoc_get_currency_multiplier_decimal(decoded));
13543 if (!ast_strlen_zero(ast_aoc_get_currency_name(decoded))) {
13544 ast_str_append(&str, 0, "currency=%s;", ast_aoc_get_currency_name(decoded));
13545 }
13546 break;
13547 case AST_AOC_CHARGE_UNIT:
13548 ast_str_append(&str, 0, "charging;");
13549 ast_str_append(&str, 0, "charging-info=pulse;");
13550 if (unit_entry) {
13551 ast_str_append(&str, 0, "recorded-units=%u;", unit_entry->amount);
13552 }
13553 break;
13554 default:
13555 ast_str_append(&str, 0, "not-available;");
13556 };
13557
13558 add_header(&req, "AOC", ast_str_buffer(str));
13559
13560 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
13561 }
13562
13563
13564 static int transmit_info_with_digit(struct sip_pvt *p, const char digit, unsigned int duration)
13565 {
13566 struct sip_request req;
13567
13568 reqprep(&req, p, SIP_INFO, 0, 1);
13569 add_digit(&req, digit, duration, (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_SHORTINFO));
13570 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
13571 }
13572
13573
13574 static int transmit_info_with_vidupdate(struct sip_pvt *p)
13575 {
13576 struct sip_request req;
13577
13578 reqprep(&req, p, SIP_INFO, 0, 1);
13579 add_vidupdate(&req);
13580 return send_request(p, &req, XMIT_RELIABLE, p->ocseq);
13581 }
13582
13583
13584
13585
13586 static int transmit_request(struct sip_pvt *p, int sipmethod, int seqno, enum xmittype reliable, int newbranch)
13587 {
13588 struct sip_request resp;
13589
13590 reqprep(&resp, p, sipmethod, seqno, newbranch);
13591 if (sipmethod == SIP_CANCEL && p->answered_elsewhere) {
13592 add_header(&resp, "Reason", "SIP;cause=200;text=\"Call completed elsewhere\"");
13593 }
13594
13595 if (sipmethod == SIP_ACK) {
13596 p->invitestate = INV_CONFIRMED;
13597 }
13598
13599 return send_request(p, &resp, reliable, seqno ? seqno : p->ocseq);
13600 }
13601
13602
13603 static void auth_headers(enum sip_auth_type code, char **header, char **respheader)
13604 {
13605 if (code == WWW_AUTH) {
13606 *header = "WWW-Authenticate";
13607 *respheader = "Authorization";
13608 } else if (code == PROXY_AUTH) {
13609 *header = "Proxy-Authenticate";
13610 *respheader = "Proxy-Authorization";
13611 } else {
13612 ast_verbose("-- wrong response code %d\n", code);
13613 *header = *respheader = "Invalid";
13614 }
13615 }
13616
13617
13618 static int transmit_request_with_auth(struct sip_pvt *p, int sipmethod, int seqno, enum xmittype reliable, int newbranch)
13619 {
13620 struct sip_request resp;
13621
13622 reqprep(&resp, p, sipmethod, seqno, newbranch);
13623 if (!ast_strlen_zero(p->realm)) {
13624 char digest[1024];
13625
13626 memset(digest, 0, sizeof(digest));
13627 if(!build_reply_digest(p, sipmethod, digest, sizeof(digest))) {
13628 char *dummy, *response;
13629 enum sip_auth_type code = p->options ? p->options->auth_type : PROXY_AUTH;
13630 auth_headers(code, &dummy, &response);
13631 add_header(&resp, response, digest);
13632 } else {
13633 ast_log(LOG_WARNING, "No authentication available for call %s\n", p->callid);
13634 }
13635 }
13636
13637
13638 if (sipmethod == SIP_BYE) {
13639 char buf[20];
13640
13641 if (ast_test_flag(&p->flags[1], SIP_PAGE2_Q850_REASON) && p->hangupcause) {
13642 sprintf(buf, "Q.850;cause=%i", p->hangupcause & 0x7f);
13643 add_header(&resp, "Reason", buf);
13644 }
13645
13646 add_header(&resp, "X-Asterisk-HangupCause", ast_cause2str(p->hangupcause));
13647 snprintf(buf, sizeof(buf), "%d", p->hangupcause);
13648 add_header(&resp, "X-Asterisk-HangupCauseCode", buf);
13649 }
13650
13651 return send_request(p, &resp, reliable, seqno ? seqno : p->ocseq);
13652 }
13653
13654
13655 static void destroy_association(struct sip_peer *peer)
13656 {
13657 int realtimeregs = ast_check_realtime("sipregs");
13658 char *tablename = (realtimeregs) ? "sipregs" : "sippeers";
13659
13660 if (!sip_cfg.ignore_regexpire) {
13661 if (peer->rt_fromcontact && sip_cfg.peer_rtupdate) {
13662 ast_update_realtime(tablename, "name", peer->name, "fullcontact", "", "ipaddr", "", "port", "", "regseconds", "0", "regserver", "", "useragent", "", "lastms", "", SENTINEL);
13663 } else {
13664 ast_db_del("SIP/Registry", peer->name);
13665 ast_db_del("SIP/PeerMethods", peer->name);
13666 }
13667 }
13668 }
13669
13670 static void set_socket_transport(struct sip_socket *socket, int transport)
13671 {
13672
13673 if (socket->type != transport) {
13674 socket->fd = -1;
13675 socket->type = transport;
13676 if (socket->tcptls_session) {
13677 ao2_ref(socket->tcptls_session, -1);
13678 socket->tcptls_session = NULL;
13679 }
13680 }
13681 }
13682
13683
13684 static int expire_register(const void *data)
13685 {
13686 struct sip_peer *peer = (struct sip_peer *)data;
13687
13688 if (!peer) {
13689 return 0;
13690 }
13691
13692 peer->expire = -1;
13693 peer->portinuri = 0;
13694
13695 destroy_association(peer);
13696 set_socket_transport(&peer->socket, peer->default_outbound_transport);
13697
13698 if (peer->socket.tcptls_session) {
13699 ao2_ref(peer->socket.tcptls_session, -1);
13700 peer->socket.tcptls_session = NULL;
13701 }
13702
13703 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "ChannelType: SIP\r\nPeer: SIP/%s\r\nPeerStatus: Unregistered\r\nCause: Expired\r\n", peer->name);
13704 register_peer_exten(peer, FALSE);
13705 ast_devstate_changed(AST_DEVICE_UNKNOWN, "SIP/%s", peer->name);
13706
13707
13708
13709
13710 if (peer->is_realtime) {
13711 ast_debug(3, "-REALTIME- peer expired registration. Name: %s. Realtime peer objects now %d\n", peer->name, rpeerobjs);
13712 }
13713
13714 if (peer->selfdestruct ||
13715 ast_test_flag(&peer->flags[1], SIP_PAGE2_RTAUTOCLEAR)) {
13716 unlink_peer_from_tables(peer);
13717 } else if (!ast_sockaddr_isnull(&peer->addr)) {
13718
13719
13720
13721 ao2_t_unlink(peers_by_ip, peer, "ao2_unlink of peer from peers_by_ip table");
13722 }
13723
13724
13725
13726 memset(&peer->addr, 0, sizeof(peer->addr));
13727
13728 unref_peer(peer, "removing peer ref for expire_register");
13729
13730 return 0;
13731 }
13732
13733
13734 static int sip_poke_peer_s(const void *data)
13735 {
13736 struct sip_peer *peer = (struct sip_peer *)data;
13737 struct sip_peer *foundpeer;
13738
13739 peer->pokeexpire = -1;
13740
13741 foundpeer = ao2_find(peers, peer, OBJ_POINTER);
13742 if (!foundpeer) {
13743 unref_peer(peer, "removing poke peer ref");
13744 return 0;
13745 } else if (foundpeer->name != peer->name) {
13746 unref_peer(foundpeer, "removing above peer ref");
13747 unref_peer(peer, "removing poke peer ref");
13748 return 0;
13749 }
13750
13751 unref_peer(foundpeer, "removing above peer ref");
13752 sip_poke_peer(peer, 0);
13753 unref_peer(peer, "removing poke peer ref");
13754
13755 return 0;
13756 }
13757
13758
13759 static void reg_source_db(struct sip_peer *peer)
13760 {
13761 char data[256];
13762 struct ast_sockaddr sa;
13763 int expire;
13764 char full_addr[128];
13765 AST_DECLARE_APP_ARGS(args,
13766 AST_APP_ARG(addr);
13767 AST_APP_ARG(port);
13768 AST_APP_ARG(expiry_str);
13769 AST_APP_ARG(username);
13770 AST_APP_ARG(contact);
13771 );
13772
13773
13774 if (peer->rt_fromcontact && sip_cfg.peer_rtupdate) {
13775 return;
13776 }
13777 if (ast_db_get("SIP/Registry", peer->name, data, sizeof(data))) {
13778 return;
13779 }
13780
13781 AST_NONSTANDARD_RAW_ARGS(args, data, ':');
13782
13783 snprintf(full_addr, sizeof(full_addr), "%s:%s", args.addr, args.port);
13784
13785 if (!ast_sockaddr_parse(&sa, full_addr, 0)) {
13786 return;
13787 }
13788
13789 if (args.expiry_str) {
13790 expire = atoi(args.expiry_str);
13791 } else {
13792 return;
13793 }
13794
13795 if (args.username) {
13796 ast_string_field_set(peer, username, args.username);
13797 }
13798 if (args.contact) {
13799 ast_string_field_set(peer, fullcontact, args.contact);
13800 }
13801
13802 ast_debug(2, "SIP Seeding peer from astdb: '%s' at %s@%s for %d\n",
13803 peer->name, peer->username, ast_sockaddr_stringify_host(&sa), expire);
13804
13805 ast_sockaddr_copy(&peer->addr, &sa);
13806 if (sipsock < 0) {
13807
13808 AST_SCHED_REPLACE_UNREF(peer->pokeexpire, sched, ast_random() % 5000 + 1, sip_poke_peer_s, peer,
13809 unref_peer(_data, "removing poke peer ref"),
13810 unref_peer(peer, "removing poke peer ref"),
13811 ref_peer(peer, "adding poke peer ref"));
13812 } else {
13813 sip_poke_peer(peer, 0);
13814 }
13815 AST_SCHED_REPLACE_UNREF(peer->expire, sched, (expire + 10) * 1000, expire_register, peer,
13816 unref_peer(_data, "remove registration ref"),
13817 unref_peer(peer, "remove registration ref"),
13818 ref_peer(peer, "add registration ref"));
13819 register_peer_exten(peer, TRUE);
13820 }
13821
13822
13823 static int parse_ok_contact(struct sip_pvt *pvt, struct sip_request *req)
13824 {
13825 char contact[SIPBUFSIZE];
13826 char *c;
13827
13828
13829 ast_copy_string(contact, get_header(req, "Contact"), sizeof(contact));
13830 c = get_in_brackets(contact);
13831
13832
13833 ast_string_field_set(pvt, fullcontact, c);
13834
13835
13836 ast_string_field_set(pvt, okcontacturi, c);
13837
13838
13839
13840 return TRUE;
13841 }
13842
13843
13844
13845
13846
13847
13848
13849 static int parse_uri_legacy_check(char *uri, const char *scheme, char **user, char **pass, char **hostport, char **transport)
13850 {
13851 int ret = parse_uri(uri, scheme, user, pass, hostport, transport);
13852 if (sip_cfg.legacy_useroption_parsing) {
13853 char *p;
13854 if ((p = strchr(uri, (int)';'))) {
13855 *p = '\0';
13856 }
13857 }
13858 return ret;
13859 }
13860
13861 static int __set_address_from_contact(const char *fullcontact, struct ast_sockaddr *addr, int tcp)
13862 {
13863 char *hostport, *transport;
13864 char contact_buf[256];
13865 char *contact;
13866
13867
13868 ast_copy_string(contact_buf, fullcontact, sizeof(contact_buf));
13869 contact = contact_buf;
13870
13871
13872
13873
13874
13875
13876
13877
13878 if (parse_uri_legacy_check(contact, "sip:,sips:", &contact, NULL, &hostport,
13879 &transport)) {
13880 ast_log(LOG_WARNING, "Invalid contact uri %s (missing sip: or sips:), attempting to use anyway\n", fullcontact);
13881 }
13882
13883
13884
13885
13886
13887
13888
13889
13890
13891
13892 if (ast_strlen_zero(hostport)) {
13893 ast_log(LOG_WARNING, "Invalid URI: parse_uri failed to acquire hostport\n");
13894 return -1;
13895 }
13896
13897 if (ast_sockaddr_resolve_first(addr, hostport, 0)) {
13898 ast_log(LOG_WARNING, "Invalid host name in Contact: (can't "
13899 "resolve in DNS) : '%s'\n", hostport);
13900 return -1;
13901 }
13902
13903
13904 if (!ast_sockaddr_port(addr)) {
13905 ast_sockaddr_set_port(addr,
13906 (get_transport_str2enum(transport) ==
13907 SIP_TRANSPORT_TLS ||
13908 !strncasecmp(fullcontact, "sips", 4)) ?
13909 STANDARD_TLS_PORT : STANDARD_SIP_PORT);
13910 }
13911
13912 return 0;
13913 }
13914
13915
13916 static int set_address_from_contact(struct sip_pvt *pvt)
13917 {
13918 if (ast_test_flag(&pvt->flags[0], SIP_NAT_FORCE_RPORT)) {
13919
13920
13921
13922 pvt->sa = pvt->recv;
13923 return 0;
13924 }
13925
13926 return __set_address_from_contact(pvt->fullcontact, &pvt->sa, pvt->socket.type == SIP_TRANSPORT_TLS ? 1 : 0);
13927 }
13928
13929
13930 static enum parse_register_result parse_register_contact(struct sip_pvt *pvt, struct sip_peer *peer, struct sip_request *req)
13931 {
13932 char contact[SIPBUFSIZE];
13933 char data[SIPBUFSIZE];
13934 const char *expires = get_header(req, "Expires");
13935 int expire = atoi(expires);
13936 char *curi = NULL, *hostport = NULL, *transport = NULL;
13937 int transport_type;
13938 const char *useragent;
13939 struct ast_sockaddr oldsin, testsa;
13940 char *firstcuri = NULL;
13941 int start = 0;
13942 int wildcard_found = 0;
13943 int single_binding_found = 0;
13944
13945 ast_copy_string(contact, __get_header(req, "Contact", &start), sizeof(contact));
13946
13947 if (ast_strlen_zero(expires)) {
13948 char *s = strcasestr(contact, ";expires=");
13949 if (s) {
13950 expires = strsep(&s, ";");
13951 if (sscanf(expires + 9, "%30d", &expire) != 1) {
13952 expire = default_expiry;
13953 }
13954 } else {
13955
13956 expire = default_expiry;
13957 }
13958 }
13959
13960 copy_socket_data(&pvt->socket, &req->socket);
13961
13962 do {
13963
13964 curi = contact;
13965 if (strchr(contact, '<') == NULL)
13966 strsep(&curi, ";");
13967 curi = get_in_brackets(contact);
13968 if (!firstcuri) {
13969 firstcuri = ast_strdupa(curi);
13970 }
13971
13972 if (!strcasecmp(curi, "*")) {
13973 wildcard_found = 1;
13974 } else {
13975 single_binding_found = 1;
13976 }
13977
13978 if (wildcard_found && (ast_strlen_zero(expires) || expire != 0 || single_binding_found)) {
13979
13980
13981 return PARSE_REGISTER_FAILED;
13982 }
13983
13984 ast_copy_string(contact, __get_header(req, "Contact", &start), sizeof(contact));
13985 } while (!ast_strlen_zero(contact));
13986 curi = firstcuri;
13987
13988
13989
13990
13991
13992 if (ast_strlen_zero(curi) && ast_strlen_zero(expires)) {
13993
13994 if (peer->expire > -1 && !ast_strlen_zero(peer->fullcontact)) {
13995 pvt->expiry = ast_sched_when(sched, peer->expire);
13996 }
13997 return PARSE_REGISTER_QUERY;
13998 } else if (!strcasecmp(curi, "*") || !expire) {
13999
14000 AST_SCHED_DEL_UNREF(sched, peer->expire,
14001 unref_peer(peer, "remove register expire ref"));
14002 ast_verb(3, "Unregistered SIP '%s'\n", peer->name);
14003 expire_register(ref_peer(peer,"add ref for explicit expire_register"));
14004 return PARSE_REGISTER_UPDATE;
14005 }
14006
14007
14008 ast_string_field_set(peer, fullcontact, curi);
14009
14010
14011 ast_string_field_build(pvt, our_contact, "<%s>", curi);
14012
14013
14014 if (ast_strlen_zero(curi) || parse_uri_legacy_check(curi, "sip:,sips:", &curi, NULL, &hostport, &transport)) {
14015 ast_log(LOG_NOTICE, "Not a valid SIP contact (missing sip:/sips:) trying to use anyway\n");
14016 }
14017
14018
14019 if (!(transport_type = get_transport_str2enum(transport))) {
14020 transport_type = pvt->socket.type;
14021 }
14022
14023
14024
14025
14026 if ((peer->socket.type != transport_type) && (peer->transports & transport_type)) {
14027 set_socket_transport(&peer->socket, transport_type);
14028 }
14029
14030 oldsin = peer->addr;
14031
14032
14033 if (!ast_sockaddr_isnull(&peer->addr) && (!peer->is_realtime || ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS))) {
14034 ao2_t_unlink(peers_by_ip, peer, "ao2_unlink of peer from peers_by_ip table");
14035 }
14036
14037 if (!ast_test_flag(&peer->flags[0], SIP_NAT_FORCE_RPORT) && !ast_test_flag(&peer->flags[0], SIP_NAT_RPORT_PRESENT)) {
14038
14039 ast_debug(1, "Store REGISTER's Contact header for call routing.\n");
14040
14041
14042 if (ast_sockaddr_resolve_first(&testsa, hostport, 0)) {
14043 ast_log(LOG_WARNING, "Invalid hostport '%s'\n", hostport);
14044 ast_string_field_set(peer, fullcontact, "");
14045 ast_string_field_set(pvt, our_contact, "");
14046 return PARSE_REGISTER_FAILED;
14047 }
14048
14049
14050
14051 peer->portinuri = ast_sockaddr_port(&testsa) ? TRUE : FALSE;
14052
14053 if (!ast_sockaddr_port(&testsa)) {
14054 ast_sockaddr_set_port(&testsa, default_sip_port(transport_type));
14055 }
14056
14057 ast_sockaddr_copy(&peer->addr, &testsa);
14058 } else {
14059
14060
14061 ast_debug(1, "Store REGISTER's src-IP:port for call routing.\n");
14062 peer->addr = pvt->recv;
14063 }
14064
14065
14066 if (ast_apply_ha(sip_cfg.contact_ha, &peer->addr) != AST_SENSE_ALLOW ||
14067 ast_apply_ha(peer->contactha, &peer->addr) != AST_SENSE_ALLOW) {
14068 ast_log(LOG_WARNING, "Domain '%s' disallowed by contact ACL (violating IP %s)\n", hostport,
14069 ast_sockaddr_stringify_addr(&testsa));
14070 ast_string_field_set(peer, fullcontact, "");
14071 ast_string_field_set(pvt, our_contact, "");
14072 return PARSE_REGISTER_DENIED;
14073 }
14074
14075
14076
14077
14078 if ((peer->socket.type == pvt->socket.type) &&
14079 !ast_sockaddr_cmp(&peer->addr, &pvt->recv)) {
14080 copy_socket_data(&peer->socket, &pvt->socket);
14081 }
14082
14083
14084 if (!peer->is_realtime || ast_test_flag(&peer->flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
14085 ao2_t_link(peers_by_ip, peer, "ao2_link into peers_by_ip table");
14086 }
14087
14088
14089 peer->sipoptions = pvt->sipoptions;
14090
14091 if (!ast_strlen_zero(curi) && ast_strlen_zero(peer->username)) {
14092 ast_string_field_set(peer, username, curi);
14093 }
14094
14095 AST_SCHED_DEL_UNREF(sched, peer->expire,
14096 unref_peer(peer, "remove register expire ref"));
14097
14098 if (expire > max_expiry) {
14099 expire = max_expiry;
14100 }
14101 if (expire < min_expiry) {
14102 expire = min_expiry;
14103 }
14104 if (peer->is_realtime && !ast_test_flag(&peer->flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
14105 peer->expire = -1;
14106 } else {
14107 peer->expire = ast_sched_add(sched, (expire + 10) * 1000, expire_register,
14108 ref_peer(peer, "add registration ref"));
14109 if (peer->expire == -1) {
14110 unref_peer(peer, "remote registration ref");
14111 }
14112 }
14113 pvt->expiry = expire;
14114 snprintf(data, sizeof(data), "%s:%d:%s:%s", ast_sockaddr_stringify(&peer->addr),
14115 expire, peer->username, peer->fullcontact);
14116
14117 if (!peer->rt_fromcontact || !sip_cfg.peer_rtupdate)
14118 ast_db_put("SIP/Registry", peer->name, data);
14119 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "ChannelType: SIP\r\nPeer: SIP/%s\r\nPeerStatus: Registered\r\nAddress: %s\r\n", peer->name, ast_sockaddr_stringify(&peer->addr));
14120
14121
14122 if (VERBOSITY_ATLEAST(2) && ast_sockaddr_cmp(&peer->addr, &oldsin)) {
14123 ast_verbose(VERBOSE_PREFIX_3 "Registered SIP '%s' at %s\n", peer->name,
14124 ast_sockaddr_stringify(&peer->addr));
14125 }
14126 sip_poke_peer(peer, 0);
14127 register_peer_exten(peer, 1);
14128
14129
14130 useragent = get_header(req, "User-Agent");
14131 if (strcasecmp(useragent, peer->useragent)) {
14132 ast_string_field_set(peer, useragent, useragent);
14133 ast_verb(4, "Saved useragent \"%s\" for peer %s\n", peer->useragent, peer->name);
14134 }
14135 return PARSE_REGISTER_UPDATE;
14136 }
14137
14138
14139 static void free_old_route(struct sip_route *route)
14140 {
14141 struct sip_route *next;
14142
14143 while (route) {
14144 next = route->next;
14145 ast_free(route);
14146 route = next;
14147 }
14148 }
14149
14150
14151 static void list_route(struct sip_route *route)
14152 {
14153 if (!route) {
14154 ast_verbose("list_route: no route\n");
14155 } else {
14156 for (;route; route = route->next)
14157 ast_verbose("list_route: hop: <%s>\n", route->hop);
14158 }
14159 }
14160
14161
14162
14163 static void build_route(struct sip_pvt *p, struct sip_request *req, int backwards, int resp)
14164 {
14165 struct sip_route *thishop, *head, *tail;
14166 int start = 0;
14167 int len;
14168 const char *rr, *c;
14169
14170
14171 if (p->route && p->route_persistent) {
14172 ast_debug(1, "build_route: Retaining previous route: <%s>\n", p->route->hop);
14173 return;
14174 }
14175
14176 if (p->route) {
14177 free_old_route(p->route);
14178 p->route = NULL;
14179 }
14180
14181
14182
14183 if ((resp < 100) || (resp > 199)) {
14184 p->route_persistent = 1;
14185 }
14186
14187
14188
14189
14190
14191
14192 head = NULL;
14193 tail = head;
14194
14195 for (;;) {
14196
14197 char rr_copy[256];
14198 char *rr_copy_ptr;
14199 char *rr_iter;
14200 rr = __get_header(req, "Record-Route", &start);
14201 if (*rr == '\0') {
14202 break;
14203 }
14204 ast_copy_string(rr_copy, rr, sizeof(rr_copy));
14205 rr_copy_ptr = rr_copy;
14206 while ((rr_iter = strsep(&rr_copy_ptr, ","))) {
14207 char *uri = get_in_brackets(rr_iter);
14208 len = strlen(uri) + 1;
14209
14210 if ((thishop = ast_malloc(sizeof(*thishop) + len))) {
14211
14212 ast_copy_string(thishop->hop, uri, len);
14213 ast_debug(2, "build_route: Record-Route hop: <%s>\n", thishop->hop);
14214
14215 if (backwards) {
14216
14217 thishop->next = head;
14218 head = thishop;
14219
14220 if (!tail) {
14221 tail = thishop;
14222 }
14223 } else {
14224 thishop->next = NULL;
14225
14226 if (tail) {
14227 tail->next = thishop;
14228 } else {
14229 head = thishop;
14230 }
14231 tail = thishop;
14232 }
14233 }
14234 }
14235 }
14236
14237
14238 if (!head || (!ast_strlen_zero(head->hop) && strstr(head->hop, ";lr") == NULL) ) {
14239
14240
14241 char *contact = ast_strdupa(get_header(req, "Contact"));
14242 if (!ast_strlen_zero(contact)) {
14243 ast_debug(2, "build_route: Contact hop: %s\n", contact);
14244
14245 c = get_in_brackets(contact);
14246 len = strlen(c) + 1;
14247 if ((thishop = ast_malloc(sizeof(*thishop) + len))) {
14248
14249 ast_copy_string(thishop->hop, c, len);
14250 thishop->next = NULL;
14251
14252 if (tail) {
14253 tail->next = thishop;
14254 } else {
14255 head = thishop;
14256 }
14257 }
14258 }
14259 }
14260
14261
14262 p->route = head;
14263
14264
14265 if (sip_debug_test_pvt(p)) {
14266 list_route(p->route);
14267 }
14268 }
14269
14270
14271
14272
14273
14274
14275
14276 static void set_nonce_randdata(struct sip_pvt *p, int forceupdate)
14277 {
14278 if (p->stalenonce || forceupdate || ast_strlen_zero(p->randdata)) {
14279 ast_string_field_build(p, randdata, "%08lx", ast_random());
14280 p->stalenonce = 0;
14281 }
14282 }
14283
14284 AST_THREADSTORAGE(check_auth_buf);
14285 #define CHECK_AUTH_BUF_INITLEN 256
14286
14287
14288
14289
14290
14291
14292 static enum check_auth_result check_auth(struct sip_pvt *p, struct sip_request *req, const char *username,
14293 const char *secret, const char *md5secret, int sipmethod,
14294 const char *uri, enum xmittype reliable, int ignore)
14295 {
14296 const char *response;
14297 char *reqheader, *respheader;
14298 const char *authtoken;
14299 char a1_hash[256];
14300 char resp_hash[256]="";
14301 char *c;
14302 int wrongnonce = FALSE;
14303 int good_response;
14304 const char *usednonce = p->randdata;
14305 struct ast_str *buf;
14306 int res;
14307
14308
14309 enum keys { K_RESP, K_URI, K_USER, K_NONCE, K_LAST };
14310 struct x {
14311 const char *key;
14312 const char *s;
14313 } *i, keys[] = {
14314 [K_RESP] = { "response=", "" },
14315 [K_URI] = { "uri=", "" },
14316 [K_USER] = { "username=", "" },
14317 [K_NONCE] = { "nonce=", "" },
14318 [K_LAST] = { NULL, NULL}
14319 };
14320
14321
14322 if (ast_strlen_zero(secret) && ast_strlen_zero(md5secret))
14323 return AUTH_SUCCESSFUL;
14324
14325
14326
14327 response = "401 Unauthorized";
14328
14329
14330
14331
14332
14333 auth_headers(WWW_AUTH, &respheader, &reqheader);
14334
14335 authtoken = get_header(req, reqheader);
14336 if (ignore && !ast_strlen_zero(p->randdata) && ast_strlen_zero(authtoken)) {
14337
14338
14339 if (!reliable) {
14340
14341
14342 transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, 0);
14343
14344 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14345 }
14346 return AUTH_CHALLENGE_SENT;
14347 } else if (ast_strlen_zero(p->randdata) || ast_strlen_zero(authtoken)) {
14348
14349 set_nonce_randdata(p, 1);
14350 transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, 0);
14351
14352 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14353 return AUTH_CHALLENGE_SENT;
14354 }
14355
14356
14357
14358
14359
14360
14361 if (!(buf = ast_str_thread_get(&check_auth_buf, CHECK_AUTH_BUF_INITLEN))) {
14362 return AUTH_SECRET_FAILED;
14363 }
14364
14365
14366 res = ast_str_set(&buf, 0, "%s", authtoken);
14367
14368 if (res == AST_DYNSTR_BUILD_FAILED) {
14369 return AUTH_SECRET_FAILED;
14370 }
14371
14372 c = buf->str;
14373
14374 while(c && *(c = ast_skip_blanks(c)) ) {
14375 for (i = keys; i->key != NULL; i++) {
14376 const char *separator = ",";
14377
14378 if (strncasecmp(c, i->key, strlen(i->key)) != 0) {
14379 continue;
14380 }
14381
14382 c += strlen(i->key);
14383 if (*c == '"') {
14384 c++;
14385 separator = "\"";
14386 }
14387 i->s = c;
14388 strsep(&c, separator);
14389 break;
14390 }
14391 if (i->key == NULL) {
14392 strsep(&c, " ,");
14393 }
14394 }
14395
14396
14397 if (strcmp(username, keys[K_USER].s)) {
14398 ast_log(LOG_WARNING, "username mismatch, have <%s>, digest has <%s>\n",
14399 username, keys[K_USER].s);
14400
14401 return AUTH_USERNAME_MISMATCH;
14402 }
14403
14404
14405
14406 if (strcasecmp(p->randdata, keys[K_NONCE].s) || p->stalenonce) {
14407 wrongnonce = TRUE;
14408 usednonce = keys[K_NONCE].s;
14409 } else {
14410 p->stalenonce = 1;
14411 }
14412
14413 if (!ast_strlen_zero(md5secret)) {
14414 ast_copy_string(a1_hash, md5secret, sizeof(a1_hash));
14415 } else {
14416 char a1[256];
14417
14418 snprintf(a1, sizeof(a1), "%s:%s:%s", username, p->realm, secret);
14419 ast_md5_hash(a1_hash, a1);
14420 }
14421
14422
14423 {
14424 char a2[256];
14425 char a2_hash[256];
14426 char resp[256];
14427
14428 snprintf(a2, sizeof(a2), "%s:%s", sip_methods[sipmethod].text,
14429 S_OR(keys[K_URI].s, uri));
14430 ast_md5_hash(a2_hash, a2);
14431 snprintf(resp, sizeof(resp), "%s:%s:%s", a1_hash, usednonce, a2_hash);
14432 ast_md5_hash(resp_hash, resp);
14433 }
14434
14435 good_response = keys[K_RESP].s &&
14436 !strncasecmp(keys[K_RESP].s, resp_hash, strlen(resp_hash));
14437 if (wrongnonce) {
14438 if (good_response) {
14439 if (sipdebug)
14440 ast_log(LOG_NOTICE, "Correct auth, but based on stale nonce received from '%s'\n", get_header(req, "From"));
14441
14442 set_nonce_randdata(p, 0);
14443 transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, TRUE);
14444 } else {
14445
14446 if (!req->ignore) {
14447 if (sipdebug) {
14448 ast_log(LOG_NOTICE, "Bad authentication received from '%s'\n", get_header(req, "To"));
14449 }
14450 set_nonce_randdata(p, 1);
14451 } else {
14452 if (sipdebug) {
14453 ast_log(LOG_NOTICE, "Duplicate authentication received from '%s'\n", get_header(req, "To"));
14454 }
14455 }
14456 transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, FALSE);
14457 }
14458
14459
14460 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14461 return AUTH_CHALLENGE_SENT;
14462 }
14463 if (good_response) {
14464 append_history(p, "AuthOK", "Auth challenge successful for %s", username);
14465 return AUTH_SUCCESSFUL;
14466 }
14467
14468
14469
14470
14471
14472
14473 return AUTH_SECRET_FAILED;
14474 }
14475
14476
14477 static void sip_peer_hold(struct sip_pvt *p, int hold)
14478 {
14479 if (!p->relatedpeer) {
14480 return;
14481 }
14482
14483
14484 ast_atomic_fetchadd_int(&p->relatedpeer->onHold, (hold ? +1 : -1));
14485
14486
14487 ast_devstate_changed(AST_DEVICE_UNKNOWN, "SIP/%s", p->relatedpeer->name);
14488
14489 return;
14490 }
14491
14492
14493 static void mwi_event_cb(const struct ast_event *event, void *userdata)
14494 {
14495 struct sip_peer *peer = userdata;
14496
14497 sip_send_mwi_to_peer(peer, 0);
14498 }
14499
14500 static void network_change_event_subscribe(void)
14501 {
14502 if (!network_change_event_subscription) {
14503 network_change_event_subscription = ast_event_subscribe(AST_EVENT_NETWORK_CHANGE,
14504 network_change_event_cb, "SIP Network Change", NULL, AST_EVENT_IE_END);
14505 }
14506 }
14507
14508 static void network_change_event_unsubscribe(void)
14509 {
14510 if (network_change_event_subscription) {
14511 network_change_event_subscription = ast_event_unsubscribe(network_change_event_subscription);
14512 }
14513 }
14514
14515 static int network_change_event_sched_cb(const void *data)
14516 {
14517 network_change_event_sched_id = -1;
14518 sip_send_all_registers();
14519 sip_send_all_mwi_subscriptions();
14520 return 0;
14521 }
14522
14523 static void network_change_event_cb(const struct ast_event *event, void *userdata)
14524 {
14525 ast_debug(1, "SIP, got a network change event, renewing all SIP registrations.\n");
14526 if (network_change_event_sched_id == -1) {
14527 network_change_event_sched_id = ast_sched_add(sched, 1000, network_change_event_sched_cb, NULL);
14528 }
14529 }
14530
14531 static void cb_extensionstate_destroy(int id, void *data)
14532 {
14533 struct sip_pvt *p = data;
14534
14535 dialog_unref(p, "the extensionstate containing this dialog ptr was destroyed");
14536 }
14537
14538
14539
14540
14541 static int cb_extensionstate(char *context, char* exten, int state, void *data)
14542 {
14543 struct sip_pvt *p = data;
14544
14545 sip_pvt_lock(p);
14546
14547 switch(state) {
14548 case AST_EXTENSION_DEACTIVATED:
14549 case AST_EXTENSION_REMOVED:
14550 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14551 ast_verb(2, "Extension state: Watcher for hint %s %s. Notify User %s\n", exten, state == AST_EXTENSION_DEACTIVATED ? "deactivated" : "removed", p->username);
14552 p->subscribed = NONE;
14553 append_history(p, "Subscribestatus", "%s", state == AST_EXTENSION_REMOVED ? "HintRemoved" : "Deactivated");
14554 break;
14555 default:
14556 p->laststate = state;
14557 break;
14558 }
14559 if (p->subscribed != NONE) {
14560 if (!p->pendinginvite) {
14561 transmit_state_notify(p, state, 1, FALSE);
14562 } else {
14563
14564
14565 ast_set_flag(&p->flags[1], SIP_PAGE2_STATECHANGEQUEUE);
14566 }
14567 }
14568 ast_verb(2, "Extension Changed %s[%s] new state %s for Notify User %s %s\n", exten, context, ast_extension_state2str(state), p->username,
14569 ast_test_flag(&p->flags[1], SIP_PAGE2_STATECHANGEQUEUE) ? "(queued)" : "");
14570
14571 sip_pvt_unlock(p);
14572
14573 return 0;
14574 }
14575
14576
14577
14578
14579 static void transmit_fake_auth_response(struct sip_pvt *p, int sipmethod, struct sip_request *req, enum xmittype reliable)
14580 {
14581
14582
14583 const char *response = "401 Unauthorized";
14584 const char *reqheader = "Authorization";
14585 const char *respheader = "WWW-Authenticate";
14586 const char *authtoken;
14587 struct ast_str *buf;
14588 char *c;
14589
14590
14591 enum keys { K_NONCE, K_LAST };
14592 struct x {
14593 const char *key;
14594 const char *s;
14595 } *i, keys[] = {
14596 [K_NONCE] = { "nonce=", "" },
14597 [K_LAST] = { NULL, NULL}
14598 };
14599
14600 authtoken = get_header(req, reqheader);
14601 if (req->ignore && !ast_strlen_zero(p->randdata) && ast_strlen_zero(authtoken)) {
14602
14603
14604 transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, 0);
14605
14606 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14607 return;
14608 } else if (ast_strlen_zero(p->randdata) || ast_strlen_zero(authtoken)) {
14609
14610 set_nonce_randdata(p, 1);
14611 transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, 0);
14612
14613 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14614 return;
14615 }
14616
14617 if (!(buf = ast_str_thread_get(&check_auth_buf, CHECK_AUTH_BUF_INITLEN))) {
14618 transmit_response(p, "403 Forbidden (Bad auth)", &p->initreq);
14619 return;
14620 }
14621
14622
14623 if (ast_str_set(&buf, 0, "%s", authtoken) == AST_DYNSTR_BUILD_FAILED) {
14624 transmit_response(p, "403 Forbidden (Bad auth)", &p->initreq);
14625 return;
14626 }
14627
14628 c = buf->str;
14629
14630 while (c && *(c = ast_skip_blanks(c))) {
14631 for (i = keys; i->key != NULL; i++) {
14632 const char *separator = ",";
14633
14634 if (strncasecmp(c, i->key, strlen(i->key)) != 0) {
14635 continue;
14636 }
14637
14638 c += strlen(i->key);
14639 if (*c == '"') {
14640 c++;
14641 separator = "\"";
14642 }
14643 i->s = c;
14644 strsep(&c, separator);
14645 break;
14646 }
14647 if (i->key == NULL) {
14648 strsep(&c, " ,");
14649 }
14650 }
14651
14652
14653 if (strcasecmp(p->randdata, keys[K_NONCE].s)) {
14654 if (!req->ignore) {
14655 set_nonce_randdata(p, 1);
14656 }
14657 transmit_response_with_auth(p, response, req, p->randdata, reliable, respheader, FALSE);
14658
14659
14660 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
14661 } else {
14662 transmit_response(p, "403 Forbidden (Bad auth)", &p->initreq);
14663 }
14664 }
14665
14666
14667
14668
14669
14670
14671
14672
14673
14674
14675
14676
14677
14678
14679
14680 static char *terminate_uri(char *uri)
14681 {
14682 char *t = uri;
14683 while (*t && *t > ' ' && *t != ';') {
14684 t++;
14685 }
14686 *t = '\0';
14687 return uri;
14688 }
14689
14690
14691
14692
14693
14694
14695
14696 static void extract_host_from_hostport(char **hostport)
14697 {
14698 char *dont_care;
14699 ast_sockaddr_split_hostport(*hostport, hostport, &dont_care, PARSE_PORT_IGNORE);
14700 }
14701
14702
14703
14704
14705
14706
14707 static enum check_auth_result register_verify(struct sip_pvt *p, struct ast_sockaddr *addr,
14708 struct sip_request *req, const char *uri)
14709 {
14710 enum check_auth_result res = AUTH_NOT_FOUND;
14711 struct sip_peer *peer;
14712 char tmp[256];
14713 char *c, *name, *unused_password, *domain;
14714 char *uri2 = ast_strdupa(uri);
14715
14716 terminate_uri(uri2);
14717
14718 ast_copy_string(tmp, get_header(req, "To"), sizeof(tmp));
14719
14720 c = get_in_brackets(tmp);
14721 c = remove_uri_parameters(c);
14722
14723 if (parse_uri_legacy_check(c, "sip:,sips:", &name, &unused_password, &domain, NULL)) {
14724 ast_log(LOG_NOTICE, "Invalid to address: '%s' from %s (missing sip:) trying to use anyway...\n", c, ast_sockaddr_stringify_addr(addr));
14725 return -1;
14726 }
14727
14728 SIP_PEDANTIC_DECODE(name);
14729 SIP_PEDANTIC_DECODE(domain);
14730
14731 extract_host_from_hostport(&domain);
14732
14733 if (ast_strlen_zero(domain)) {
14734
14735 transmit_response(p, "404 Not found", &p->initreq);
14736 return AUTH_UNKNOWN_DOMAIN;
14737 }
14738
14739 if (ast_strlen_zero(name)) {
14740
14741
14742
14743
14744
14745
14746
14747 name = domain;
14748 }
14749
14750
14751
14752
14753
14754 if (!AST_LIST_EMPTY(&domain_list)) {
14755 if (!check_sip_domain(domain, NULL, 0)) {
14756 if (sip_cfg.alwaysauthreject) {
14757 transmit_fake_auth_response(p, SIP_REGISTER, &p->initreq, XMIT_UNRELIABLE);
14758 } else {
14759 transmit_response(p, "404 Not found (unknown domain)", &p->initreq);
14760 }
14761 return AUTH_UNKNOWN_DOMAIN;
14762 }
14763 }
14764
14765 ast_string_field_set(p, exten, name);
14766 build_contact(p);
14767 if (req->ignore) {
14768
14769 const char *expires = get_header(req, "Expires");
14770 int expire = atoi(expires);
14771
14772 if (ast_strlen_zero(expires)) {
14773 if ((expires = strcasestr(get_header(req, "Contact"), ";expires="))) {
14774 expire = atoi(expires + 9);
14775 }
14776 }
14777 if (!ast_strlen_zero(expires) && expire == 0) {
14778 transmit_response_with_date(p, "200 OK", req);
14779 return 0;
14780 }
14781 }
14782 peer = find_peer(name, NULL, TRUE, FINDPEERS, FALSE, 0);
14783
14784 if (!(peer && ast_apply_ha(peer->ha, addr))) {
14785
14786 if (peer) {
14787 unref_peer(peer, "register_verify: unref_peer: from find_peer operation");
14788 peer = NULL;
14789 res = AUTH_ACL_FAILED;
14790 } else {
14791 res = AUTH_NOT_FOUND;
14792 }
14793 }
14794
14795 if (peer) {
14796 ao2_lock(peer);
14797 if (!peer->host_dynamic) {
14798 ast_log(LOG_ERROR, "Peer '%s' is trying to register, but not configured as host=dynamic\n", peer->name);
14799 res = AUTH_PEER_NOT_DYNAMIC;
14800 } else {
14801 ast_copy_flags(&p->flags[0], &peer->flags[0], SIP_NAT_FORCE_RPORT);
14802 if (!(res = check_auth(p, req, peer->name, peer->secret, peer->md5secret, SIP_REGISTER, uri2, XMIT_UNRELIABLE, req->ignore))) {
14803 if (sip_cancel_destroy(p))
14804 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
14805
14806 if (check_request_transport(peer, req)) {
14807 ast_set_flag(&p->flags[0], SIP_PENDINGBYE);
14808 transmit_response_with_date(p, "403 Forbidden", req);
14809 res = AUTH_BAD_TRANSPORT;
14810 } else {
14811
14812
14813
14814 switch (parse_register_contact(p, peer, req)) {
14815 case PARSE_REGISTER_DENIED:
14816 ast_log(LOG_WARNING, "Registration denied because of contact ACL\n");
14817 transmit_response_with_date(p, "603 Denied", req);
14818 peer->lastmsgssent = -1;
14819 res = 0;
14820 break;
14821 case PARSE_REGISTER_FAILED:
14822 ast_log(LOG_WARNING, "Failed to parse contact info\n");
14823 transmit_response_with_date(p, "400 Bad Request", req);
14824 peer->lastmsgssent = -1;
14825 res = 0;
14826 break;
14827 case PARSE_REGISTER_QUERY:
14828 ast_string_field_set(p, fullcontact, peer->fullcontact);
14829 transmit_response_with_date(p, "200 OK", req);
14830 peer->lastmsgssent = -1;
14831 res = 0;
14832 break;
14833 case PARSE_REGISTER_UPDATE:
14834 ast_string_field_set(p, fullcontact, peer->fullcontact);
14835 update_peer(peer, p->expiry);
14836
14837 transmit_response_with_date(p, "200 OK", req);
14838 if (!ast_test_flag((&peer->flags[1]), SIP_PAGE2_SUBSCRIBEMWIONLY))
14839 peer->lastmsgssent = -1;
14840 res = 0;
14841 break;
14842 }
14843 }
14844
14845 }
14846 }
14847 ao2_unlock(peer);
14848 }
14849 if (!peer && sip_cfg.autocreatepeer) {
14850
14851 peer = temp_peer(name);
14852 if (peer) {
14853 ao2_t_link(peers, peer, "link peer into peer table");
14854 if (!ast_sockaddr_isnull(&peer->addr)) {
14855 ao2_t_link(peers_by_ip, peer, "link peer into peers-by-ip table");
14856 }
14857 ao2_lock(peer);
14858 if (sip_cancel_destroy(p))
14859 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
14860 switch (parse_register_contact(p, peer, req)) {
14861 case PARSE_REGISTER_DENIED:
14862 ast_log(LOG_WARNING, "Registration denied because of contact ACL\n");
14863 transmit_response_with_date(p, "403 Forbidden (ACL)", req);
14864 peer->lastmsgssent = -1;
14865 res = 0;
14866 break;
14867 case PARSE_REGISTER_FAILED:
14868 ast_log(LOG_WARNING, "Failed to parse contact info\n");
14869 transmit_response_with_date(p, "400 Bad Request", req);
14870 peer->lastmsgssent = -1;
14871 res = 0;
14872 break;
14873 case PARSE_REGISTER_QUERY:
14874 ast_string_field_set(p, fullcontact, peer->fullcontact);
14875 transmit_response_with_date(p, "200 OK", req);
14876 peer->lastmsgssent = -1;
14877 res = 0;
14878 break;
14879 case PARSE_REGISTER_UPDATE:
14880 ast_string_field_set(p, fullcontact, peer->fullcontact);
14881
14882 transmit_response_with_date(p, "200 OK", req);
14883 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "ChannelType: SIP\r\nPeer: SIP/%s\r\nPeerStatus: Registered\r\nAddress: %s\r\n", peer->name, ast_sockaddr_stringify(addr));
14884 peer->lastmsgssent = -1;
14885 res = 0;
14886 break;
14887 }
14888 ao2_unlock(peer);
14889 }
14890 }
14891 if (!res) {
14892 ast_devstate_changed(AST_DEVICE_UNKNOWN, "SIP/%s", peer->name);
14893 }
14894 if (res < 0) {
14895 switch (res) {
14896 case AUTH_SECRET_FAILED:
14897
14898 transmit_response(p, "403 Forbidden (Bad auth)", &p->initreq);
14899 if (global_authfailureevents) {
14900 const char *peer_addr = ast_strdupa(ast_sockaddr_stringify_addr(addr));
14901 const char *peer_port = ast_strdupa(ast_sockaddr_stringify_port(addr));
14902 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus",
14903 "ChannelType: SIP\r\n"
14904 "Peer: SIP/%s\r\n"
14905 "PeerStatus: Rejected\r\n"
14906 "Cause: AUTH_SECRET_FAILED\r\n"
14907 "Address: %s\r\n"
14908 "Port: %s\r\n",
14909 name, peer_addr, peer_port);
14910 }
14911 break;
14912 case AUTH_USERNAME_MISMATCH:
14913
14914
14915
14916
14917 case AUTH_NOT_FOUND:
14918 case AUTH_PEER_NOT_DYNAMIC:
14919 case AUTH_ACL_FAILED:
14920 if (sip_cfg.alwaysauthreject) {
14921 transmit_fake_auth_response(p, SIP_REGISTER, &p->initreq, XMIT_UNRELIABLE);
14922 if (global_authfailureevents) {
14923 const char *peer_addr = ast_strdupa(ast_sockaddr_stringify_addr(addr));
14924 const char *peer_port = ast_strdupa(ast_sockaddr_stringify_port(addr));
14925 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus",
14926 "ChannelType: SIP\r\n"
14927 "Peer: SIP/%s\r\n"
14928 "PeerStatus: Rejected\r\n"
14929 "Cause: %s\r\n"
14930 "Address: %s\r\n"
14931 "Port: %s\r\n",
14932 name,
14933 res == AUTH_PEER_NOT_DYNAMIC ? "AUTH_PEER_NOT_DYNAMIC" : "URI_NOT_FOUND",
14934 peer_addr, peer_port);
14935 }
14936 } else {
14937
14938 if (res == AUTH_PEER_NOT_DYNAMIC) {
14939 transmit_response(p, "403 Forbidden", &p->initreq);
14940 if (global_authfailureevents) {
14941 const char *peer_addr = ast_strdupa(ast_sockaddr_stringify_addr(addr));
14942 const char *peer_port = ast_strdupa(ast_sockaddr_stringify_port(addr));
14943 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus",
14944 "ChannelType: SIP\r\n"
14945 "Peer: SIP/%s\r\n"
14946 "PeerStatus: Rejected\r\n"
14947 "Cause: AUTH_PEER_NOT_DYNAMIC\r\n"
14948 "Address: %s\r\n"
14949 "Port: %s\r\n",
14950 name, peer_addr, peer_port);
14951 }
14952 } else {
14953 transmit_response(p, "404 Not found", &p->initreq);
14954 if (global_authfailureevents) {
14955 const char *peer_addr = ast_strdupa(ast_sockaddr_stringify_addr(addr));
14956 const char *peer_port = ast_strdupa(ast_sockaddr_stringify_port(addr));
14957 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus",
14958 "ChannelType: SIP\r\n"
14959 "Peer: SIP/%s\r\n"
14960 "PeerStatus: Rejected\r\n"
14961 "Cause: %s\r\n"
14962 "Address: %s\r\n"
14963 "Port: %s\r\n",
14964 name,
14965 (res == AUTH_USERNAME_MISMATCH) ? "AUTH_USERNAME_MISMATCH" : "URI_NOT_FOUND",
14966 peer_addr, peer_port);
14967 }
14968 }
14969 }
14970 break;
14971 case AUTH_BAD_TRANSPORT:
14972 default:
14973 break;
14974 }
14975 }
14976 if (peer) {
14977 unref_peer(peer, "register_verify: unref_peer: tossing stack peer pointer at end of func");
14978 }
14979
14980 return res;
14981 }
14982
14983
14984 static void sip_set_redirstr(struct sip_pvt *p, char *reason) {
14985
14986 if (!strcmp(reason, "unknown")) {
14987 ast_string_field_set(p, redircause, "UNKNOWN");
14988 } else if (!strcmp(reason, "user-busy")) {
14989 ast_string_field_set(p, redircause, "BUSY");
14990 } else if (!strcmp(reason, "no-answer")) {
14991 ast_string_field_set(p, redircause, "NOANSWER");
14992 } else if (!strcmp(reason, "unavailable")) {
14993 ast_string_field_set(p, redircause, "UNREACHABLE");
14994 } else if (!strcmp(reason, "unconditional")) {
14995 ast_string_field_set(p, redircause, "UNCONDITIONAL");
14996 } else if (!strcmp(reason, "time-of-day")) {
14997 ast_string_field_set(p, redircause, "UNKNOWN");
14998 } else if (!strcmp(reason, "do-not-disturb")) {
14999 ast_string_field_set(p, redircause, "UNKNOWN");
15000 } else if (!strcmp(reason, "deflection")) {
15001 ast_string_field_set(p, redircause, "UNKNOWN");
15002 } else if (!strcmp(reason, "follow-me")) {
15003 ast_string_field_set(p, redircause, "UNKNOWN");
15004 } else if (!strcmp(reason, "out-of-service")) {
15005 ast_string_field_set(p, redircause, "UNREACHABLE");
15006 } else if (!strcmp(reason, "away")) {
15007 ast_string_field_set(p, redircause, "UNREACHABLE");
15008 } else {
15009 ast_string_field_set(p, redircause, "UNKNOWN");
15010 }
15011 }
15012
15013
15014
15015
15016
15017 static int get_pai(struct sip_pvt *p, struct sip_request *req)
15018 {
15019 char pai[256];
15020 char privacy[64];
15021 char *cid_num = NULL;
15022 char *cid_name = NULL;
15023 char emptyname[1] = "";
15024 int callingpres = AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED;
15025 char *uri = NULL;
15026 int is_anonymous = 0, do_update = 1, no_name = 0;
15027
15028 ast_copy_string(pai, get_header(req, "P-Asserted-Identity"), sizeof(pai));
15029
15030 if (ast_strlen_zero(pai)) {
15031 return 0;
15032 }
15033
15034
15035 if (get_name_and_number(pai, &cid_name, &cid_num)) {
15036 return 0;
15037 }
15038
15039 if (global_shrinkcallerid && ast_is_shrinkable_phonenumber(cid_num)) {
15040 ast_shrink_phone_number(cid_num);
15041 }
15042
15043 uri = get_in_brackets(pai);
15044 if (!strncasecmp(uri, "sip:anonymous@anonymous.invalid", 31)) {
15045 callingpres = AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
15046
15047
15048
15049 ast_free(cid_num);
15050 is_anonymous = 1;
15051 cid_num = (char *)p->cid_num;
15052 }
15053
15054 ast_copy_string(privacy, get_header(req, "Privacy"), sizeof(privacy));
15055 if (!ast_strlen_zero(privacy) && strncmp(privacy, "id", 2)) {
15056 callingpres = AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
15057 }
15058 if (!cid_name) {
15059 no_name = 1;
15060 cid_name = (char *)emptyname;
15061 }
15062
15063 if (!strcasecmp(p->cid_num, cid_num) && !strcasecmp(p->cid_name, cid_name) && p->callingpres == callingpres) {
15064 do_update = 0;
15065 } else {
15066
15067 ast_string_field_set(p, cid_num, cid_num);
15068 ast_string_field_set(p, cid_name, cid_name);
15069 p->callingpres = callingpres;
15070
15071 if (p->owner) {
15072 ast_set_callerid(p->owner, cid_num, cid_name, NULL);
15073 p->owner->caller.id.name.presentation = callingpres;
15074 p->owner->caller.id.number.presentation = callingpres;
15075 }
15076 }
15077
15078
15079 if (!is_anonymous) {
15080 ast_free(cid_num);
15081 }
15082 if (!no_name) {
15083 ast_free(cid_name);
15084 }
15085
15086 return do_update;
15087 }
15088
15089
15090
15091
15092
15093 static int get_rpid(struct sip_pvt *p, struct sip_request *oreq)
15094 {
15095 char tmp[256];
15096 struct sip_request *req;
15097 char *cid_num = "";
15098 char *cid_name = "";
15099 int callingpres = AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED;
15100 char *privacy = "";
15101 char *screen = "";
15102 char *start, *end;
15103
15104 if (!ast_test_flag(&p->flags[0], SIP_TRUSTRPID))
15105 return 0;
15106 req = oreq;
15107 if (!req)
15108 req = &p->initreq;
15109 ast_copy_string(tmp, get_header(req, "Remote-Party-ID"), sizeof(tmp));
15110 if (ast_strlen_zero(tmp)) {
15111 return get_pai(p, req);
15112 }
15113
15114 start = tmp;
15115 if (*start == '"') {
15116 *start++ = '\0';
15117 end = strchr(start, '"');
15118 if (!end)
15119 return 0;
15120 *end++ = '\0';
15121 cid_name = start;
15122 start = ast_skip_blanks(end);
15123 }
15124
15125 if (*start != '<')
15126 return 0;
15127 *start++ = '\0';
15128 end = strchr(start, '@');
15129 if (!end)
15130 return 0;
15131 *end++ = '\0';
15132 if (strncasecmp(start, "sip:", 4))
15133 return 0;
15134 cid_num = start + 4;
15135 if (global_shrinkcallerid && ast_is_shrinkable_phonenumber(cid_num))
15136 ast_shrink_phone_number(cid_num);
15137 start = end;
15138
15139 end = strchr(start, '>');
15140 if (!end)
15141 return 0;
15142 *end++ = '\0';
15143 if (*end) {
15144 start = end;
15145 if (*start != ';')
15146 return 0;
15147 *start++ = '\0';
15148 while (!ast_strlen_zero(start)) {
15149 end = strchr(start, ';');
15150 if (end)
15151 *end++ = '\0';
15152 if (!strncasecmp(start, "privacy=", 8))
15153 privacy = start + 8;
15154 else if (!strncasecmp(start, "screen=", 7))
15155 screen = start + 7;
15156 start = end;
15157 }
15158
15159 if (!strcasecmp(privacy, "full")) {
15160 if (!strcasecmp(screen, "yes"))
15161 callingpres = AST_PRES_PROHIB_USER_NUMBER_PASSED_SCREEN;
15162 else if (!strcasecmp(screen, "no"))
15163 callingpres = AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
15164 } else {
15165 if (!strcasecmp(screen, "yes"))
15166 callingpres = AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN;
15167 else if (!strcasecmp(screen, "no"))
15168 callingpres = AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED;
15169 }
15170 }
15171
15172
15173 if (!strcasecmp(p->cid_num, cid_num) && !strcasecmp(p->cid_name, cid_name) && p->callingpres == callingpres)
15174 return 0;
15175
15176 ast_string_field_set(p, cid_num, cid_num);
15177 ast_string_field_set(p, cid_name, cid_name);
15178 p->callingpres = callingpres;
15179
15180 if (p->owner) {
15181 ast_set_callerid(p->owner, cid_num, cid_name, NULL);
15182 p->owner->caller.id.name.presentation = callingpres;
15183 p->owner->caller.id.number.presentation = callingpres;
15184 }
15185
15186 return 1;
15187 }
15188
15189
15190 static int get_rdnis(struct sip_pvt *p, struct sip_request *oreq, char **name, char **number, int *reason)
15191 {
15192 char tmp[256], *exten, *rexten, *rdomain, *rname = NULL;
15193 char *params, *reason_param = NULL;
15194 struct sip_request *req;
15195
15196 req = oreq ? oreq : &p->initreq;
15197
15198 ast_copy_string(tmp, get_header(req, "Diversion"), sizeof(tmp));
15199 if (ast_strlen_zero(tmp))
15200 return -1;
15201
15202 if ((params = strchr(tmp, '>'))) {
15203 params = strchr(params, ';');
15204 }
15205
15206 exten = get_in_brackets(tmp);
15207 if (!strncasecmp(exten, "sip:", 4)) {
15208 exten += 4;
15209 } else if (!strncasecmp(exten, "sips:", 5)) {
15210 exten += 5;
15211 } else {
15212 ast_log(LOG_WARNING, "Huh? Not an RDNIS SIP header (%s)?\n", exten);
15213 return -1;
15214 }
15215
15216
15217 if (params) {
15218 *params = '\0';
15219 params++;
15220 while (*params == ';' || *params == ' ')
15221 params++;
15222
15223 if ((reason_param = strcasestr(params, "reason="))) {
15224 char *end;
15225 reason_param+=7;
15226 if ((end = strchr(reason_param, ';'))) {
15227 *end = '\0';
15228 }
15229
15230 if (*reason_param == '"')
15231 ast_strip_quoted(reason_param, "\"", "\"");
15232 if (!ast_strlen_zero(reason_param)) {
15233 sip_set_redirstr(p, reason_param);
15234 if (p->owner) {
15235 pbx_builtin_setvar_helper(p->owner, "__PRIREDIRECTREASON", p->redircause);
15236 pbx_builtin_setvar_helper(p->owner, "__SIPREDIRECTREASON", reason_param);
15237 }
15238 }
15239 }
15240 }
15241
15242 rdomain = exten;
15243 rexten = strsep(&rdomain, "@");
15244 if (p->owner)
15245 pbx_builtin_setvar_helper(p->owner, "__SIPRDNISDOMAIN", rdomain);
15246
15247 if (sip_debug_test_pvt(p))
15248 ast_verbose("RDNIS for this call is %s (reason %s)\n", exten, reason ? reason_param : "");
15249
15250
15251
15252 if (*tmp == '\"') {
15253 char *end_quote;
15254 rname = tmp + 1;
15255 end_quote = strchr(rname, '\"');
15256 *end_quote = '\0';
15257 }
15258
15259 if (number) {
15260 *number = ast_strdup(rexten);
15261 }
15262
15263 if (name && rname) {
15264 *name = ast_strdup(rname);
15265 }
15266
15267 if (reason && !ast_strlen_zero(reason_param)) {
15268 *reason = sip_reason_str_to_code(reason_param);
15269 }
15270
15271 return 0;
15272 }
15273
15274
15275
15276
15277
15278
15279
15280
15281
15282
15283
15284
15285
15286
15287
15288 static enum sip_get_dest_result get_destination(struct sip_pvt *p, struct sip_request *oreq, int *cc_recall_core_id)
15289 {
15290 char tmp[256] = "", *uri, *unused_password, *domain;
15291 char tmpf[256] = "", *from = NULL;
15292 struct sip_request *req;
15293 char *decoded_uri;
15294
15295 req = oreq;
15296 if (!req) {
15297 req = &p->initreq;
15298 }
15299
15300
15301 if (req->rlPart2)
15302 ast_copy_string(tmp, REQ_OFFSET_TO_STR(req, rlPart2), sizeof(tmp));
15303
15304 uri = ast_strdupa(get_in_brackets(tmp));
15305
15306 if (parse_uri_legacy_check(uri, "sip:,sips:", &uri, &unused_password, &domain, NULL)) {
15307 ast_log(LOG_WARNING, "Not a SIP header (%s)?\n", uri);
15308 return SIP_GET_DEST_INVALID_URI;
15309 }
15310
15311 SIP_PEDANTIC_DECODE(domain);
15312 SIP_PEDANTIC_DECODE(uri);
15313
15314 extract_host_from_hostport(&domain);
15315
15316 if (ast_strlen_zero(uri)) {
15317
15318
15319
15320
15321
15322 uri = "s";
15323 }
15324
15325 ast_string_field_set(p, domain, domain);
15326
15327
15328
15329
15330
15331 ast_copy_string(tmpf, get_header(req, "From"), sizeof(tmpf));
15332 if (!ast_strlen_zero(tmpf)) {
15333 from = get_in_brackets(tmpf);
15334 if (parse_uri_legacy_check(from, "sip:,sips:", &from, NULL, &domain, NULL)) {
15335 ast_log(LOG_WARNING, "Not a SIP header (%s)?\n", from);
15336 return SIP_GET_DEST_INVALID_URI;
15337 }
15338
15339 SIP_PEDANTIC_DECODE(from);
15340 SIP_PEDANTIC_DECODE(domain);
15341
15342 extract_host_from_hostport(&domain);
15343
15344 ast_string_field_set(p, fromdomain, domain);
15345 }
15346
15347 if (!AST_LIST_EMPTY(&domain_list)) {
15348 char domain_context[AST_MAX_EXTENSION];
15349
15350 domain_context[0] = '\0';
15351 if (!check_sip_domain(p->domain, domain_context, sizeof(domain_context))) {
15352 if (!sip_cfg.allow_external_domains && (req->method == SIP_INVITE || req->method == SIP_REFER)) {
15353 ast_debug(1, "Got SIP %s to non-local domain '%s'; refusing request.\n", sip_methods[req->method].text, p->domain);
15354 return SIP_GET_DEST_REFUSED;
15355 }
15356 }
15357
15358
15359 if (!ast_test_flag(&p->flags[1], SIP_PAGE2_HAVEPEERCONTEXT) && !ast_strlen_zero(domain_context)) {
15360 ast_string_field_set(p, context, domain_context);
15361 }
15362 }
15363
15364
15365 if (req->method == SIP_SUBSCRIBE && !ast_strlen_zero(p->subscribecontext)) {
15366 ast_string_field_set(p, context, p->subscribecontext);
15367 }
15368
15369 if (sip_debug_test_pvt(p)) {
15370 ast_verbose("Looking for %s in %s (domain %s)\n", uri, p->context, p->domain);
15371 }
15372
15373
15374
15375 decoded_uri = ast_strdupa(uri);
15376 ast_uri_decode(decoded_uri);
15377
15378
15379 if (req->method == SIP_SUBSCRIBE) {
15380 char hint[AST_MAX_EXTENSION];
15381 int which = 0;
15382 if (ast_get_hint(hint, sizeof(hint), NULL, 0, NULL, p->context, uri) ||
15383 (ast_get_hint(hint, sizeof(hint), NULL, 0, NULL, p->context, decoded_uri) && (which = 1))) {
15384 if (!oreq) {
15385 ast_string_field_set(p, exten, which ? decoded_uri : uri);
15386 }
15387 return SIP_GET_DEST_EXTEN_FOUND;
15388 } else {
15389 return SIP_GET_DEST_EXTEN_NOT_FOUND;
15390 }
15391 } else {
15392 struct ast_cc_agent *agent;
15393
15394
15395
15396 if (ast_exists_extension(NULL, p->context, uri, 1, S_OR(p->cid_num, from))) {
15397 if (!oreq) {
15398 ast_string_field_set(p, exten, uri);
15399 }
15400 return SIP_GET_DEST_EXTEN_FOUND;
15401 }
15402 if (ast_exists_extension(NULL, p->context, decoded_uri, 1, S_OR(p->cid_num, from))
15403 || !strcmp(decoded_uri, ast_pickup_ext())) {
15404 if (!oreq) {
15405 ast_string_field_set(p, exten, decoded_uri);
15406 }
15407 return SIP_GET_DEST_EXTEN_FOUND;
15408 }
15409 if ((agent = find_sip_cc_agent_by_notify_uri(tmp))) {
15410 struct sip_cc_agent_pvt *agent_pvt = agent->private_data;
15411
15412
15413
15414 ast_string_field_set(p, exten, agent_pvt->original_exten);
15415
15416
15417
15418 ast_cc_agent_recalling(agent->core_id, "SIP caller %s is attempting recall",
15419 agent->device_name);
15420 if (cc_recall_core_id) {
15421 *cc_recall_core_id = agent->core_id;
15422 }
15423 ao2_ref(agent, -1);
15424 return SIP_GET_DEST_EXTEN_FOUND;
15425 }
15426 }
15427
15428 if (ast_test_flag(&global_flags[1], SIP_PAGE2_ALLOWOVERLAP)
15429 && (ast_canmatch_extension(NULL, p->context, uri, 1, S_OR(p->cid_num, from))
15430 || ast_canmatch_extension(NULL, p->context, decoded_uri, 1, S_OR(p->cid_num, from))
15431 || !strncmp(decoded_uri, ast_pickup_ext(), strlen(decoded_uri)))) {
15432
15433 return SIP_GET_DEST_EXTEN_MATCHMORE;
15434 }
15435
15436 return SIP_GET_DEST_EXTEN_NOT_FOUND;
15437 }
15438
15439
15440
15441
15442 static struct sip_pvt *get_sip_pvt_byid_locked(const char *callid, const char *totag, const char *fromtag)
15443 {
15444 struct sip_pvt *sip_pvt_ptr;
15445 struct sip_pvt tmp_dialog = {
15446 .callid = callid,
15447 };
15448
15449 if (totag) {
15450 ast_debug(4, "Looking for callid %s (fromtag %s totag %s)\n", callid, fromtag ? fromtag : "<no fromtag>", totag ? totag : "<no totag>");
15451 }
15452
15453
15454
15455 sip_pvt_ptr = ao2_t_find(dialogs, &tmp_dialog, OBJ_POINTER, "ao2_find of dialog in dialogs table");
15456 if (sip_pvt_ptr) {
15457
15458 sip_pvt_lock(sip_pvt_ptr);
15459 if (sip_cfg.pedanticsipchecking) {
15460 unsigned char frommismatch = 0, tomismatch = 0;
15461
15462 if (ast_strlen_zero(fromtag)) {
15463 sip_pvt_unlock(sip_pvt_ptr);
15464 ast_debug(4, "Matched %s call for callid=%s - no from tag specified, pedantic check fails\n",
15465 sip_pvt_ptr->outgoing_call == TRUE ? "OUTGOING": "INCOMING", sip_pvt_ptr->callid);
15466 return NULL;
15467 }
15468
15469 if (ast_strlen_zero(totag)) {
15470 sip_pvt_unlock(sip_pvt_ptr);
15471 ast_debug(4, "Matched %s call for callid=%s - no to tag specified, pedantic check fails\n",
15472 sip_pvt_ptr->outgoing_call == TRUE ? "OUTGOING": "INCOMING", sip_pvt_ptr->callid);
15473 return NULL;
15474 }
15475
15476
15477
15478
15479
15480
15481
15482
15483
15484
15485
15486
15487
15488
15489 frommismatch = !!strcmp(fromtag, sip_pvt_ptr->theirtag);
15490 tomismatch = !!strcmp(totag, sip_pvt_ptr->tag);
15491
15492 if (frommismatch || tomismatch) {
15493 sip_pvt_unlock(sip_pvt_ptr);
15494 if (frommismatch) {
15495 ast_debug(4, "Matched %s call for callid=%s - pedantic from tag check fails; their tag is %s our tag is %s\n",
15496 sip_pvt_ptr->outgoing_call == TRUE ? "OUTGOING": "INCOMING", sip_pvt_ptr->callid,
15497 fromtag, sip_pvt_ptr->theirtag);
15498 }
15499 if (tomismatch) {
15500 ast_debug(4, "Matched %s call for callid=%s - pedantic to tag check fails; their tag is %s our tag is %s\n",
15501 sip_pvt_ptr->outgoing_call == TRUE ? "OUTGOING": "INCOMING", sip_pvt_ptr->callid,
15502 totag, sip_pvt_ptr->tag);
15503 }
15504 return NULL;
15505 }
15506 }
15507
15508 if (totag)
15509 ast_debug(4, "Matched %s call - their tag is %s Our tag is %s\n",
15510 sip_pvt_ptr->outgoing_call == TRUE ? "OUTGOING": "INCOMING",
15511 sip_pvt_ptr->theirtag, sip_pvt_ptr->tag);
15512
15513
15514 while (sip_pvt_ptr->owner && ast_channel_trylock(sip_pvt_ptr->owner)) {
15515 sip_pvt_unlock(sip_pvt_ptr);
15516 usleep(1);
15517 sip_pvt_lock(sip_pvt_ptr);
15518 }
15519 }
15520
15521 return sip_pvt_ptr;
15522 }
15523
15524
15525
15526
15527
15528
15529
15530
15531 static int get_refer_info(struct sip_pvt *transferer, struct sip_request *outgoing_req)
15532 {
15533
15534 const char *p_referred_by = NULL;
15535 char *h_refer_to = NULL;
15536 char *h_referred_by = NULL;
15537 char *refer_to;
15538 const char *p_refer_to;
15539 char *referred_by_uri = NULL;
15540 char *ptr;
15541 struct sip_request *req = NULL;
15542 const char *transfer_context = NULL;
15543 struct sip_refer *referdata;
15544
15545
15546 req = outgoing_req;
15547 referdata = transferer->refer;
15548
15549 if (!req) {
15550 req = &transferer->initreq;
15551 }
15552
15553 p_refer_to = get_header(req, "Refer-To");
15554 if (ast_strlen_zero(p_refer_to)) {
15555 ast_log(LOG_WARNING, "Refer-To Header missing. Skipping transfer.\n");
15556 return -2;
15557 }
15558 h_refer_to = ast_strdupa(p_refer_to);
15559 refer_to = get_in_brackets(h_refer_to);
15560 if (!strncasecmp(refer_to, "sip:", 4)) {
15561 refer_to += 4;
15562 } else if (!strncasecmp(refer_to, "sips:", 5)) {
15563 refer_to += 5;
15564 } else {
15565 ast_log(LOG_WARNING, "Can't transfer to non-sip: URI. (Refer-to: %s)?\n", refer_to);
15566 return -3;
15567 }
15568
15569
15570 p_referred_by = get_header(req, "Referred-By");
15571
15572
15573 if (transferer->owner) {
15574 struct ast_channel *peer = ast_bridged_channel(transferer->owner);
15575 if (peer) {
15576 pbx_builtin_setvar_helper(peer, "SIPREFERRINGCONTEXT", transferer->context);
15577 pbx_builtin_setvar_helper(peer, "SIPREFERREDBYHDR", p_referred_by);
15578 }
15579 }
15580
15581 if (!ast_strlen_zero(p_referred_by)) {
15582 char *lessthan;
15583 h_referred_by = ast_strdupa(p_referred_by);
15584
15585
15586 ast_copy_string(referdata->referred_by_name, h_referred_by, sizeof(referdata->referred_by_name));
15587 if ((lessthan = strchr(referdata->referred_by_name, '<'))) {
15588 *(lessthan - 1) = '\0';
15589 }
15590
15591 referred_by_uri = get_in_brackets(h_referred_by);
15592
15593 if (!strncasecmp(referred_by_uri, "sip:", 4)) {
15594 referred_by_uri += 4;
15595 } else if (!strncasecmp(referred_by_uri, "sips:", 5)) {
15596 referred_by_uri += 5;
15597 } else {
15598 ast_log(LOG_WARNING, "Huh? Not a sip: header (Referred-by: %s). Skipping.\n", referred_by_uri);
15599 referred_by_uri = NULL;
15600 }
15601 }
15602
15603
15604 if ((ptr = strcasestr(refer_to, "replaces="))) {
15605 char *to = NULL, *from = NULL;
15606
15607
15608 referdata->attendedtransfer = 1;
15609 ast_copy_string(referdata->replaces_callid, ptr+9, sizeof(referdata->replaces_callid));
15610 ast_uri_decode(referdata->replaces_callid);
15611 if ((ptr = strchr(referdata->replaces_callid, ';'))) {
15612 *ptr++ = '\0';
15613 }
15614
15615 if (ptr) {
15616
15617 to = strcasestr(ptr, "to-tag=");
15618 from = strcasestr(ptr, "from-tag=");
15619 }
15620
15621
15622 if (to) {
15623 ptr = to + 7;
15624 if ((to = strchr(ptr, '&'))) {
15625 *to = '\0';
15626 }
15627 if ((to = strchr(ptr, ';'))) {
15628 *to = '\0';
15629 }
15630 ast_copy_string(referdata->replaces_callid_totag, ptr, sizeof(referdata->replaces_callid_totag));
15631 }
15632
15633 if (from) {
15634 ptr = from + 9;
15635 if ((to = strchr(ptr, '&'))) {
15636 *to = '\0';
15637 }
15638 if ((to = strchr(ptr, ';'))) {
15639 *to = '\0';
15640 }
15641 ast_copy_string(referdata->replaces_callid_fromtag, ptr, sizeof(referdata->replaces_callid_fromtag));
15642 }
15643
15644 if (!strcmp(referdata->replaces_callid, transferer->callid) &&
15645 (!sip_cfg.pedanticsipchecking ||
15646 (!strcmp(referdata->replaces_callid_fromtag, transferer->theirtag) &&
15647 !strcmp(referdata->replaces_callid_totag, transferer->tag)))) {
15648 ast_log(LOG_WARNING, "Got an attempt to replace own Call-ID on %s\n", transferer->callid);
15649 return -4;
15650 }
15651
15652 if (!sip_cfg.pedanticsipchecking) {
15653 ast_debug(2, "Attended transfer: Will use Replace-Call-ID : %s (No check of from/to tags)\n", referdata->replaces_callid );
15654 } else {
15655 ast_debug(2, "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>" );
15656 }
15657 }
15658
15659 if ((ptr = strchr(refer_to, '@'))) {
15660 char *urioption = NULL, *domain;
15661 int bracket = 0;
15662 *ptr++ = '\0';
15663
15664 if ((urioption = strchr(ptr, ';'))) {
15665 *urioption++ = '\0';
15666 }
15667
15668 domain = ptr;
15669
15670
15671 for (; *ptr != '\0'; ++ptr) {
15672 if (*ptr == ':' && bracket == 0) {
15673 *ptr = '\0';
15674 break;
15675 } else if (*ptr == '[') {
15676 ++bracket;
15677 } else if (*ptr == ']') {
15678 --bracket;
15679 }
15680 }
15681
15682 SIP_PEDANTIC_DECODE(domain);
15683 SIP_PEDANTIC_DECODE(urioption);
15684
15685
15686 ast_copy_string(referdata->refer_to_domain, domain, sizeof(referdata->refer_to_domain));
15687 if (urioption) {
15688 ast_copy_string(referdata->refer_to_urioption, urioption, sizeof(referdata->refer_to_urioption));
15689 }
15690 }
15691
15692 if ((ptr = strchr(refer_to, ';')))
15693 *ptr = '\0';
15694
15695 SIP_PEDANTIC_DECODE(refer_to);
15696 ast_copy_string(referdata->refer_to, refer_to, sizeof(referdata->refer_to));
15697
15698 if (referred_by_uri) {
15699 if ((ptr = strchr(referred_by_uri, ';')))
15700 *ptr = '\0';
15701 SIP_PEDANTIC_DECODE(referred_by_uri);
15702 ast_copy_string(referdata->referred_by, referred_by_uri, sizeof(referdata->referred_by));
15703 } else {
15704 referdata->referred_by[0] = '\0';
15705 }
15706
15707
15708 if (transferer->owner)
15709 transfer_context = pbx_builtin_getvar_helper(transferer->owner, "TRANSFER_CONTEXT");
15710
15711
15712 if (ast_strlen_zero(transfer_context)) {
15713 transfer_context = S_OR(transferer->owner->macrocontext,
15714 S_OR(transferer->context, sip_cfg.default_context));
15715 }
15716
15717 ast_copy_string(referdata->refer_to_context, transfer_context, sizeof(referdata->refer_to_context));
15718
15719
15720 if (referdata->attendedtransfer || ast_exists_extension(NULL, transfer_context, refer_to, 1, NULL) ) {
15721 if (sip_debug_test_pvt(transferer)) {
15722 ast_verbose("SIP transfer to extension %s@%s by %s\n", refer_to, transfer_context, referred_by_uri);
15723 }
15724
15725 return 0;
15726 }
15727 if (sip_debug_test_pvt(transferer))
15728 ast_verbose("Failed SIP Transfer to non-existing extension %s in context %s\n n", refer_to, transfer_context);
15729
15730
15731 return -1;
15732 }
15733
15734
15735
15736
15737
15738 static int get_also_info(struct sip_pvt *p, struct sip_request *oreq)
15739 {
15740 char tmp[256] = "", *c, *a;
15741 struct sip_request *req = oreq ? oreq : &p->initreq;
15742 struct sip_refer *referdata = NULL;
15743 const char *transfer_context = NULL;
15744
15745 if (!p->refer && !sip_refer_allocate(p))
15746 return -1;
15747
15748 referdata = p->refer;
15749
15750 ast_copy_string(tmp, get_header(req, "Also"), sizeof(tmp));
15751 c = get_in_brackets(tmp);
15752
15753 if (parse_uri_legacy_check(c, "sip:,sips:", &c, NULL, &a, NULL)) {
15754 ast_log(LOG_WARNING, "Huh? Not a SIP header in Also: transfer (%s)?\n", c);
15755 return -1;
15756 }
15757
15758 SIP_PEDANTIC_DECODE(c);
15759 SIP_PEDANTIC_DECODE(a);
15760
15761 if (!ast_strlen_zero(a)) {
15762 ast_copy_string(referdata->refer_to_domain, a, sizeof(referdata->refer_to_domain));
15763 }
15764
15765 if (sip_debug_test_pvt(p))
15766 ast_verbose("Looking for %s in %s\n", c, p->context);
15767
15768 if (p->owner)
15769 transfer_context = pbx_builtin_getvar_helper(p->owner, "TRANSFER_CONTEXT");
15770
15771
15772 if (ast_strlen_zero(transfer_context)) {
15773 transfer_context = S_OR(p->owner->macrocontext,
15774 S_OR(p->context, sip_cfg.default_context));
15775 }
15776 if (ast_exists_extension(NULL, transfer_context, c, 1, NULL)) {
15777
15778 ast_debug(1, "SIP Bye-also transfer to Extension %s@%s \n", c, transfer_context);
15779 ast_copy_string(referdata->refer_to, c, sizeof(referdata->refer_to));
15780 ast_copy_string(referdata->referred_by, "", sizeof(referdata->referred_by));
15781 ast_copy_string(referdata->refer_contact, "", sizeof(referdata->refer_contact));
15782 referdata->refer_call = dialog_unref(referdata->refer_call, "unreffing referdata->refer_call");
15783
15784 ast_string_field_set(p, context, transfer_context);
15785 return 0;
15786 } else if (ast_canmatch_extension(NULL, p->context, c, 1, NULL)) {
15787 return 1;
15788 }
15789
15790 return -1;
15791 }
15792
15793
15794
15795
15796
15797
15798
15799
15800
15801
15802
15803 static attribute_unused void check_via_response(struct sip_pvt *p, struct sip_request *req)
15804 {
15805 char via[256];
15806 char *cur, *opts;
15807
15808 ast_copy_string(via, get_header(req, "Via"), sizeof(via));
15809
15810
15811 opts = strchr(via, ',');
15812 if (opts)
15813 *opts = '\0';
15814
15815
15816 opts = strchr(via, ';');
15817 if (!opts)
15818 return;
15819 *opts++ = '\0';
15820 while ( (cur = strsep(&opts, ";")) ) {
15821 if (!strncmp(cur, "rport=", 6)) {
15822 int port = strtol(cur+6, NULL, 10);
15823
15824 ast_sockaddr_set_port(&p->ourip, port);
15825 } else if (!strncmp(cur, "received=", 9)) {
15826 if (ast_parse_arg(cur + 9, PARSE_ADDR, &p->ourip))
15827 ;
15828 }
15829 }
15830 }
15831
15832
15833 static void check_via(struct sip_pvt *p, struct sip_request *req)
15834 {
15835 char via[512];
15836 char *c, *maddr;
15837 struct ast_sockaddr tmp = { { 0, } };
15838 uint16_t port;
15839
15840 ast_copy_string(via, get_header(req, "Via"), sizeof(via));
15841
15842
15843 c = strchr(via, ',');
15844 if (c)
15845 *c = '\0';
15846
15847
15848 c = strstr(via, ";rport");
15849 if (c && (c[6] != '=')) {
15850 ast_set_flag(&p->flags[1], SIP_PAGE2_RPORT_PRESENT);
15851 ast_set_flag(&p->flags[0], SIP_NAT_RPORT_PRESENT);
15852 }
15853
15854
15855 maddr = strstr(via, "maddr=");
15856 if (maddr) {
15857 maddr += 6;
15858 c = maddr + strspn(maddr, "abcdefghijklmnopqrstuvwxyz"
15859 "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-.:[]");
15860 *c = '\0';
15861 }
15862
15863 c = strchr(via, ';');
15864 if (c)
15865 *c = '\0';
15866
15867 c = strchr(via, ' ');
15868 if (c) {
15869 *c = '\0';
15870 c = ast_skip_blanks(c+1);
15871 if (strcasecmp(via, "SIP/2.0/UDP") && strcasecmp(via, "SIP/2.0/TCP") && strcasecmp(via, "SIP/2.0/TLS")) {
15872 ast_log(LOG_WARNING, "Don't know how to respond via '%s'\n", via);
15873 return;
15874 }
15875
15876 if (maddr && ast_sockaddr_resolve_first(&p->sa, maddr, 0)) {
15877 p->sa = p->recv;
15878 }
15879
15880 ast_sockaddr_resolve_first(&tmp, c, 0);
15881 port = ast_sockaddr_port(&tmp);
15882 ast_sockaddr_set_port(&p->sa,
15883 port != 0 ? port : STANDARD_SIP_PORT);
15884
15885 if (sip_debug_test_pvt(p)) {
15886 ast_verbose("Sending to %s (%s)\n",
15887 ast_sockaddr_stringify(sip_real_dst(p)),
15888 sip_nat_mode(p));
15889 }
15890 }
15891 }
15892
15893
15894 static enum check_auth_result check_peer_ok(struct sip_pvt *p, char *of,
15895 struct sip_request *req, int sipmethod, struct ast_sockaddr *addr,
15896 struct sip_peer **authpeer,
15897 enum xmittype reliable, char *calleridname, char *uri2)
15898 {
15899 enum check_auth_result res;
15900 int debug = sip_debug_test_addr(addr);
15901 struct sip_peer *peer;
15902
15903 if (sipmethod == SIP_SUBSCRIBE) {
15904
15905
15906
15907 peer = find_peer(of, NULL, TRUE, FINDALLDEVICES, FALSE, 0);
15908 } else {
15909
15910 peer = find_peer(of, NULL, TRUE, FINDUSERS, FALSE, 0);
15911
15912
15913 if (!peer) {
15914 peer = find_peer(NULL, &p->recv, TRUE, FINDPEERS, FALSE, p->socket.type);
15915 }
15916 }
15917
15918 if (!peer) {
15919 if (debug) {
15920 ast_verbose("No matching peer for '%s' from '%s'\n",
15921 of, ast_sockaddr_stringify(&p->recv));
15922 }
15923 return AUTH_DONT_KNOW;
15924 }
15925
15926 if (!ast_apply_ha(peer->ha, addr)) {
15927 ast_debug(2, "Found peer '%s' for '%s', but fails host access\n", peer->name, of);
15928 unref_peer(peer, "unref_peer: check_peer_ok: from find_peer call, early return of AUTH_ACL_FAILED");
15929 return AUTH_ACL_FAILED;
15930 }
15931 if (debug)
15932 ast_verbose("Found peer '%s' for '%s' from %s\n",
15933 peer->name, of, ast_sockaddr_stringify(&p->recv));
15934
15935
15936
15937 if (p->rtp) {
15938 ast_rtp_codecs_packetization_set(ast_rtp_instance_get_codecs(p->rtp), p->rtp, &peer->prefs);
15939 p->autoframing = peer->autoframing;
15940 }
15941
15942
15943 ast_copy_flags(&p->flags[0], &peer->flags[0], SIP_FLAGS_TO_COPY);
15944 ast_copy_flags(&p->flags[1], &peer->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
15945 ast_copy_flags(&p->flags[2], &peer->flags[2], SIP_PAGE3_FLAGS_TO_COPY);
15946
15947 if (ast_test_flag(&p->flags[1], SIP_PAGE2_T38SUPPORT) && p->udptl) {
15948 p->t38_maxdatagram = peer->t38_maxdatagram;
15949 set_t38_capabilities(p);
15950 }
15951
15952
15953
15954 if (p->sipoptions)
15955 peer->sipoptions = p->sipoptions;
15956
15957 do_setnat(p);
15958
15959 ast_string_field_set(p, peersecret, peer->secret);
15960 ast_string_field_set(p, peermd5secret, peer->md5secret);
15961 ast_string_field_set(p, subscribecontext, peer->subscribecontext);
15962 ast_string_field_set(p, mohinterpret, peer->mohinterpret);
15963 ast_string_field_set(p, mohsuggest, peer->mohsuggest);
15964 if (!ast_strlen_zero(peer->parkinglot)) {
15965 ast_string_field_set(p, parkinglot, peer->parkinglot);
15966 }
15967 ast_string_field_set(p, engine, peer->engine);
15968 p->disallowed_methods = peer->disallowed_methods;
15969 set_pvt_allowed_methods(p, req);
15970 ast_cc_copy_config_params(p->cc_params, peer->cc_params);
15971 if (peer->callingpres)
15972 p->callingpres = peer->callingpres;
15973 if (peer->maxms && peer->lastms)
15974 p->timer_t1 = peer->lastms < global_t1min ? global_t1min : peer->lastms;
15975 else
15976 p->timer_t1 = peer->timer_t1;
15977
15978
15979 if (peer->timer_b)
15980 p->timer_b = peer->timer_b;
15981 else
15982 p->timer_b = 64 * p->timer_t1;
15983
15984 if (ast_test_flag(&peer->flags[0], SIP_INSECURE_INVITE)) {
15985
15986 ast_string_field_set(p, peersecret, NULL);
15987 ast_string_field_set(p, peermd5secret, NULL);
15988 }
15989 if (!(res = check_auth(p, req, peer->name, p->peersecret, p->peermd5secret, sipmethod, uri2, reliable, req->ignore))) {
15990 ast_copy_flags(&p->flags[0], &peer->flags[0], SIP_FLAGS_TO_COPY);
15991 ast_copy_flags(&p->flags[1], &peer->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
15992 ast_copy_flags(&p->flags[2], &peer->flags[2], SIP_PAGE3_FLAGS_TO_COPY);
15993
15994 if (peer->call_limit)
15995 ast_set_flag(&p->flags[0], SIP_CALL_LIMIT);
15996 ast_string_field_set(p, peername, peer->name);
15997 ast_string_field_set(p, authname, peer->name);
15998
15999 if (sipmethod == SIP_INVITE) {
16000
16001 ast_variables_destroy(p->chanvars);
16002 p->chanvars = copy_vars(peer->chanvars);
16003 }
16004
16005 if (authpeer) {
16006 ao2_t_ref(peer, 1, "copy pointer into (*authpeer)");
16007 (*authpeer) = peer;
16008 }
16009
16010 if (!ast_strlen_zero(peer->username)) {
16011 ast_string_field_set(p, username, peer->username);
16012
16013
16014 ast_string_field_set(p, authname, peer->username);
16015 }
16016 if (!get_rpid(p, req)) {
16017 if (!ast_strlen_zero(peer->cid_num)) {
16018 char *tmp = ast_strdupa(peer->cid_num);
16019 if (global_shrinkcallerid && ast_is_shrinkable_phonenumber(tmp))
16020 ast_shrink_phone_number(tmp);
16021 ast_string_field_set(p, cid_num, tmp);
16022 }
16023 if (!ast_strlen_zero(peer->cid_name))
16024 ast_string_field_set(p, cid_name, peer->cid_name);
16025 if (!ast_strlen_zero(peer->cid_tag))
16026 ast_string_field_set(p, cid_tag, peer->cid_tag);
16027 if (peer->callingpres)
16028 p->callingpres = peer->callingpres;
16029 }
16030 ast_string_field_set(p, fullcontact, peer->fullcontact);
16031
16032 if (!ast_strlen_zero(peer->context)) {
16033 ast_string_field_set(p, context, peer->context);
16034 }
16035 if (!ast_strlen_zero(peer->mwi_from)) {
16036 ast_string_field_set(p, mwi_from, peer->mwi_from);
16037 }
16038
16039 ast_string_field_set(p, peersecret, peer->secret);
16040 ast_string_field_set(p, peermd5secret, peer->md5secret);
16041 ast_string_field_set(p, language, peer->language);
16042 ast_string_field_set(p, accountcode, peer->accountcode);
16043 p->amaflags = peer->amaflags;
16044 p->callgroup = peer->callgroup;
16045 p->pickupgroup = peer->pickupgroup;
16046 p->capability = peer->capability;
16047 p->prefs = peer->prefs;
16048 p->jointcapability = peer->capability;
16049 if (peer->maxforwards > 0) {
16050 p->maxforwards = peer->maxforwards;
16051 }
16052 if (p->peercapability)
16053 p->jointcapability &= p->peercapability;
16054 p->maxcallbitrate = peer->maxcallbitrate;
16055 if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
16056 (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO))
16057 p->noncodeccapability |= AST_RTP_DTMF;
16058 else
16059 p->noncodeccapability &= ~AST_RTP_DTMF;
16060 p->jointnoncodeccapability = p->noncodeccapability;
16061 p->rtptimeout = peer->rtptimeout;
16062 p->rtpholdtimeout = peer->rtpholdtimeout;
16063 p->rtpkeepalive = peer->rtpkeepalive;
16064 if (!dialog_initialize_rtp(p)) {
16065 if (p->rtp) {
16066 ast_rtp_codecs_packetization_set(ast_rtp_instance_get_codecs(p->rtp), p->rtp, &peer->prefs);
16067 p->autoframing = peer->autoframing;
16068 }
16069 } else {
16070 res = AUTH_RTP_FAILED;
16071 }
16072 }
16073 unref_peer(peer, "check_peer_ok: unref_peer: tossing temp ptr to peer from find_peer");
16074 return res;
16075 }
16076
16077
16078
16079
16080
16081
16082
16083 static enum check_auth_result check_user_full(struct sip_pvt *p, struct sip_request *req,
16084 int sipmethod, const char *uri, enum xmittype reliable,
16085 struct ast_sockaddr *addr, struct sip_peer **authpeer)
16086 {
16087 char from[256] = "", *of, *name, *unused_password, *domain;
16088 enum check_auth_result res = AUTH_DONT_KNOW;
16089 char calleridname[50];
16090 char *uri2 = ast_strdupa(uri);
16091
16092 terminate_uri(uri2);
16093
16094 ast_copy_string(from, get_header(req, "From"), sizeof(from));
16095
16096
16097
16098 if (!(of = (char *) get_calleridname(from, calleridname, sizeof(calleridname)))) {
16099 ast_log(LOG_ERROR, "FROM header can not be parsed \n");
16100 return res;
16101 }
16102
16103 if (calleridname[0]) {
16104 ast_string_field_set(p, cid_name, calleridname);
16105 }
16106
16107 if (ast_strlen_zero(p->exten)) {
16108 char *t = uri2;
16109 if (!strncasecmp(t, "sip:", 4))
16110 t+= 4;
16111 else if (!strncasecmp(t, "sips:", 5))
16112 t += 5;
16113 ast_string_field_set(p, exten, t);
16114 t = strchr(p->exten, '@');
16115 if (t)
16116 *t = '\0';
16117
16118 if (ast_strlen_zero(p->our_contact))
16119 build_contact(p);
16120 }
16121
16122 of = get_in_brackets(of);
16123
16124
16125 ast_string_field_set(p, from, of);
16126
16127 if (parse_uri_legacy_check(of, "sip:,sips:", &name, &unused_password, &domain, NULL)) {
16128 ast_log(LOG_NOTICE, "From address missing 'sip:', using it anyway\n");
16129 }
16130
16131 SIP_PEDANTIC_DECODE(name);
16132 SIP_PEDANTIC_DECODE(domain);
16133
16134 extract_host_from_hostport(&domain);
16135
16136 if (ast_strlen_zero(domain)) {
16137
16138 ast_log(LOG_ERROR, "Empty domain name in FROM header\n");
16139 return res;
16140 }
16141
16142 if (ast_strlen_zero(name)) {
16143
16144
16145
16146 name = domain;
16147 } else {
16148
16149 char *tmp = ast_strdupa(name);
16150
16151
16152
16153 tmp = strsep(&tmp, ";");
16154 if (global_shrinkcallerid && ast_is_shrinkable_phonenumber(tmp)) {
16155 ast_shrink_phone_number(tmp);
16156 }
16157 ast_string_field_set(p, cid_num, tmp);
16158 }
16159
16160 if (global_match_auth_username) {
16161
16162
16163
16164
16165
16166
16167
16168
16169 const char *hdr = get_header(req, "Authorization");
16170 if (ast_strlen_zero(hdr)) {
16171 hdr = get_header(req, "Proxy-Authorization");
16172 }
16173
16174 if (!ast_strlen_zero(hdr) && (hdr = strstr(hdr, "username=\""))) {
16175 ast_copy_string(from, hdr + strlen("username=\""), sizeof(from));
16176 name = from;
16177 name = strsep(&name, "\"");
16178 }
16179 }
16180
16181 res = check_peer_ok(p, name, req, sipmethod, addr,
16182 authpeer, reliable, calleridname, uri2);
16183 if (res != AUTH_DONT_KNOW) {
16184 return res;
16185 }
16186
16187
16188 if (sip_cfg.allowguest) {
16189 get_rpid(p, req);
16190 p->rtptimeout = global_rtptimeout;
16191 p->rtpholdtimeout = global_rtpholdtimeout;
16192 p->rtpkeepalive = global_rtpkeepalive;
16193 if (!dialog_initialize_rtp(p)) {
16194 res = AUTH_SUCCESSFUL;
16195 } else {
16196 res = AUTH_RTP_FAILED;
16197 }
16198 } else if (sip_cfg.alwaysauthreject) {
16199 res = AUTH_FAKE_AUTH;
16200 } else {
16201 res = AUTH_SECRET_FAILED;
16202 }
16203
16204 if (ast_test_flag(&p->flags[1], SIP_PAGE2_RPORT_PRESENT)) {
16205 ast_set_flag(&p->flags[0], SIP_NAT_RPORT_PRESENT);
16206 }
16207
16208 return res;
16209 }
16210
16211
16212
16213
16214 static int check_user(struct sip_pvt *p, struct sip_request *req, int sipmethod, const char *uri, enum xmittype reliable, struct ast_sockaddr *addr)
16215 {
16216 return check_user_full(p, req, sipmethod, uri, reliable, addr, NULL);
16217 }
16218
16219
16220
16221
16222
16223
16224
16225
16226
16227 static int get_msg_text(char *buf, int len, struct sip_request *req)
16228 {
16229 int x;
16230 int linelen;
16231
16232 buf[0] = '\0';
16233 --len;
16234 for (x = 0; len && x < req->lines; ++x) {
16235 const char *line = REQ_OFFSET_TO_STR(req, line[x]);
16236 strncat(buf, line, len);
16237 linelen = strlen(buf);
16238 buf += linelen;
16239 len -= linelen;
16240 if (len) {
16241 strcat(buf, "\n");
16242 ++buf;
16243 --len;
16244 }
16245 }
16246 return 0;
16247 }
16248
16249
16250
16251
16252
16253 static void receive_message(struct sip_pvt *p, struct sip_request *req)
16254 {
16255 char buf[1400];
16256 char *bufp;
16257 struct ast_frame f;
16258 const char *content_type = get_header(req, "Content-Type");
16259
16260 if (strncmp(content_type, "text/plain", strlen("text/plain"))) {
16261 transmit_response(p, "415 Unsupported Media Type", req);
16262 if (!p->owner)
16263 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
16264 return;
16265 }
16266
16267 if (get_msg_text(buf, sizeof(buf), req)) {
16268 ast_log(LOG_WARNING, "Unable to retrieve text from %s\n", p->callid);
16269 transmit_response(p, "500 Internal Server Error", req);
16270 if (!p->owner) {
16271 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
16272 }
16273 return;
16274 }
16275
16276
16277
16278 bufp = buf + strlen(buf);
16279 while (--bufp >= buf && *bufp == '\n') {
16280 *bufp = '\0';
16281 }
16282
16283 if (p->owner) {
16284 if (sip_debug_test_pvt(p))
16285 ast_verbose("SIP Text message received: '%s'\n", buf);
16286 memset(&f, 0, sizeof(f));
16287 f.frametype = AST_FRAME_TEXT;
16288 f.subclass.integer = 0;
16289 f.offset = 0;
16290 f.data.ptr = buf;
16291 f.datalen = strlen(buf) + 1;
16292 ast_queue_frame(p->owner, &f);
16293 transmit_response(p, "202 Accepted", req);
16294 return;
16295 }
16296
16297
16298 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);
16299 transmit_response(p, "405 Method Not Allowed", req);
16300 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
16301 return;
16302 }
16303
16304
16305 static char *sip_show_inuse(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
16306 {
16307 #define FORMAT "%-25.25s %-15.15s %-15.15s \n"
16308 #define FORMAT2 "%-25.25s %-15.15s %-15.15s \n"
16309 char ilimits[40];
16310 char iused[40];
16311 int showall = FALSE;
16312 struct ao2_iterator i;
16313 struct sip_peer *peer;
16314
16315 switch (cmd) {
16316 case CLI_INIT:
16317 e->command = "sip show inuse";
16318 e->usage =
16319 "Usage: sip show inuse [all]\n"
16320 " List all SIP devices usage counters and limits.\n"
16321 " Add option \"all\" to show all devices, not only those with a limit.\n";
16322 return NULL;
16323 case CLI_GENERATE:
16324 return NULL;
16325 }
16326
16327 if (a->argc < 3)
16328 return CLI_SHOWUSAGE;
16329
16330 if (a->argc == 4 && !strcmp(a->argv[3], "all"))
16331 showall = TRUE;
16332
16333 ast_cli(a->fd, FORMAT, "* Peer name", "In use", "Limit");
16334
16335 i = ao2_iterator_init(peers, 0);
16336 while ((peer = ao2_t_iterator_next(&i, "iterate thru peer table"))) {
16337 ao2_lock(peer);
16338 if (peer->call_limit)
16339 snprintf(ilimits, sizeof(ilimits), "%d", peer->call_limit);
16340 else
16341 ast_copy_string(ilimits, "N/A", sizeof(ilimits));
16342 snprintf(iused, sizeof(iused), "%d/%d/%d", peer->inUse, peer->inRinging, peer->onHold);
16343 if (showall || peer->call_limit)
16344 ast_cli(a->fd, FORMAT2, peer->name, iused, ilimits);
16345 ao2_unlock(peer);
16346 unref_peer(peer, "toss iterator pointer");
16347 }
16348 ao2_iterator_destroy(&i);
16349
16350 return CLI_SUCCESS;
16351 #undef FORMAT
16352 #undef FORMAT2
16353 }
16354
16355
16356
16357 static char *transfermode2str(enum transfermodes mode)
16358 {
16359 if (mode == TRANSFER_OPENFORALL)
16360 return "open";
16361 else if (mode == TRANSFER_CLOSED)
16362 return "closed";
16363 return "strict";
16364 }
16365
16366
16367
16368
16369
16370
16371
16372 static const struct _map_x_s stmodes[] = {
16373 { SESSION_TIMER_MODE_ACCEPT, "Accept"},
16374 { SESSION_TIMER_MODE_ORIGINATE, "Originate"},
16375 { SESSION_TIMER_MODE_REFUSE, "Refuse"},
16376 { -1, NULL},
16377 };
16378
16379 static const char *stmode2str(enum st_mode m)
16380 {
16381 return map_x_s(stmodes, m, "Unknown");
16382 }
16383
16384 static enum st_mode str2stmode(const char *s)
16385 {
16386 return map_s_x(stmodes, s, -1);
16387 }
16388
16389
16390 static const struct _map_x_s strefreshers[] = {
16391 { SESSION_TIMER_REFRESHER_AUTO, "auto"},
16392 { SESSION_TIMER_REFRESHER_UAC, "uac"},
16393 { SESSION_TIMER_REFRESHER_UAS, "uas"},
16394 { -1, NULL},
16395 };
16396
16397 static const char *strefresher2str(enum st_refresher r)
16398 {
16399 return map_x_s(strefreshers, r, "Unknown");
16400 }
16401
16402 static enum st_refresher str2strefresher(const char *s)
16403 {
16404 return map_s_x(strefreshers, s, -1);
16405 }
16406
16407
16408 static int peer_status(struct sip_peer *peer, char *status, int statuslen)
16409 {
16410 int res = 0;
16411 if (peer->maxms) {
16412 if (peer->lastms < 0) {
16413 ast_copy_string(status, "UNREACHABLE", statuslen);
16414 } else if (peer->lastms > peer->maxms) {
16415 snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
16416 res = 1;
16417 } else if (peer->lastms) {
16418 snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
16419 res = 1;
16420 } else {
16421 ast_copy_string(status, "UNKNOWN", statuslen);
16422 }
16423 } else {
16424 ast_copy_string(status, "Unmonitored", statuslen);
16425
16426 res = -1;
16427 }
16428 return res;
16429 }
16430
16431
16432 static char *sip_show_tcp(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
16433 {
16434 struct sip_threadinfo *th;
16435 struct ao2_iterator i;
16436
16437 #define FORMAT2 "%-47.47s %9.9s %6.6s\n"
16438 #define FORMAT "%-47.47s %-9.9s %-6.6s\n"
16439
16440 switch (cmd) {
16441 case CLI_INIT:
16442 e->command = "sip show tcp";
16443 e->usage =
16444 "Usage: sip show tcp\n"
16445 " Lists all active TCP/TLS sessions.\n";
16446 return NULL;
16447 case CLI_GENERATE:
16448 return NULL;
16449 }
16450
16451 if (a->argc != 3)
16452 return CLI_SHOWUSAGE;
16453
16454 ast_cli(a->fd, FORMAT2, "Address", "Transport", "Type");
16455
16456 i = ao2_iterator_init(threadt, 0);
16457 while ((th = ao2_t_iterator_next(&i, "iterate through tcp threads for 'sip show tcp'"))) {
16458 ast_cli(a->fd, FORMAT,
16459 ast_sockaddr_stringify(&th->tcptls_session->remote_address),
16460 get_transport(th->type),
16461 (th->tcptls_session->client ? "Client" : "Server"));
16462 ao2_t_ref(th, -1, "decrement ref from iterator");
16463 }
16464 ao2_iterator_destroy(&i);
16465
16466 return CLI_SUCCESS;
16467 #undef FORMAT
16468 #undef FORMAT2
16469 }
16470
16471
16472 static char *sip_show_users(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
16473 {
16474 regex_t regexbuf;
16475 int havepattern = FALSE;
16476 struct ao2_iterator user_iter;
16477 struct sip_peer *user;
16478
16479 #define FORMAT "%-25.25s %-15.15s %-15.15s %-15.15s %-5.5s%-10.10s\n"
16480
16481 switch (cmd) {
16482 case CLI_INIT:
16483 e->command = "sip show users";
16484 e->usage =
16485 "Usage: sip show users [like <pattern>]\n"
16486 " Lists all known SIP users.\n"
16487 " Optional regular expression pattern is used to filter the user list.\n";
16488 return NULL;
16489 case CLI_GENERATE:
16490 return NULL;
16491 }
16492
16493 switch (a->argc) {
16494 case 5:
16495 if (!strcasecmp(a->argv[3], "like")) {
16496 if (regcomp(®exbuf, a->argv[4], REG_EXTENDED | REG_NOSUB))
16497 return CLI_SHOWUSAGE;
16498 havepattern = TRUE;
16499 } else
16500 return CLI_SHOWUSAGE;
16501 case 3:
16502 break;
16503 default:
16504 return CLI_SHOWUSAGE;
16505 }
16506
16507 ast_cli(a->fd, FORMAT, "Username", "Secret", "Accountcode", "Def.Context", "ACL", "ForcerPort");
16508
16509 user_iter = ao2_iterator_init(peers, 0);
16510 while ((user = ao2_t_iterator_next(&user_iter, "iterate thru peers table"))) {
16511 ao2_lock(user);
16512 if (!(user->type & SIP_TYPE_USER)) {
16513 ao2_unlock(user);
16514 unref_peer(user, "sip show users");
16515 continue;
16516 }
16517
16518 if (havepattern && regexec(®exbuf, user->name, 0, NULL, 0)) {
16519 ao2_unlock(user);
16520 unref_peer(user, "sip show users");
16521 continue;
16522 }
16523
16524 ast_cli(a->fd, FORMAT, user->name,
16525 user->secret,
16526 user->accountcode,
16527 user->context,
16528 AST_CLI_YESNO(user->ha != NULL),
16529 AST_CLI_YESNO(ast_test_flag(&user->flags[0], SIP_NAT_FORCE_RPORT)));
16530 ao2_unlock(user);
16531 unref_peer(user, "sip show users");
16532 }
16533 ao2_iterator_destroy(&user_iter);
16534
16535 if (havepattern)
16536 regfree(®exbuf);
16537
16538 return CLI_SUCCESS;
16539 #undef FORMAT
16540 }
16541
16542
16543 static int manager_show_registry(struct mansession *s, const struct message *m)
16544 {
16545 const char *id = astman_get_header(m, "ActionID");
16546 char idtext[256] = "";
16547 int total = 0;
16548
16549 if (!ast_strlen_zero(id))
16550 snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
16551
16552 astman_send_listack(s, m, "Registrations will follow", "start");
16553
16554 ASTOBJ_CONTAINER_TRAVERSE(®l, 1, do {
16555 ASTOBJ_RDLOCK(iterator);
16556 astman_append(s,
16557 "Event: RegistryEntry\r\n"
16558 "%s"
16559 "Host: %s\r\n"
16560 "Port: %d\r\n"
16561 "Username: %s\r\n"
16562 "Domain: %s\r\n"
16563 "DomainPort: %d\r\n"
16564 "Refresh: %d\r\n"
16565 "State: %s\r\n"
16566 "RegistrationTime: %ld\r\n"
16567 "\r\n",
16568 idtext,
16569 iterator->hostname,
16570 iterator->portno ? iterator->portno : STANDARD_SIP_PORT,
16571 iterator->username,
16572 S_OR(iterator->regdomain,iterator->hostname),
16573 iterator->regdomainport ? iterator->regdomainport : STANDARD_SIP_PORT,
16574 iterator->refresh,
16575 regstate2str(iterator->regstate),
16576 (long) iterator->regtime.tv_sec);
16577 ASTOBJ_UNLOCK(iterator);
16578 total++;
16579 } while(0));
16580
16581 astman_append(s,
16582 "Event: RegistrationsComplete\r\n"
16583 "EventList: Complete\r\n"
16584 "ListItems: %d\r\n"
16585 "%s"
16586 "\r\n", total, idtext);
16587
16588 return 0;
16589 }
16590
16591
16592
16593 static int manager_sip_show_peers(struct mansession *s, const struct message *m)
16594 {
16595 const char *id = astman_get_header(m, "ActionID");
16596 const char *a[] = {"sip", "show", "peers"};
16597 char idtext[256] = "";
16598 int total = 0;
16599
16600 if (!ast_strlen_zero(id))
16601 snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
16602
16603 astman_send_listack(s, m, "Peer status list will follow", "start");
16604
16605 _sip_show_peers(-1, &total, s, m, 3, a);
16606
16607 astman_append(s,
16608 "Event: PeerlistComplete\r\n"
16609 "EventList: Complete\r\n"
16610 "ListItems: %d\r\n"
16611 "%s"
16612 "\r\n", total, idtext);
16613 return 0;
16614 }
16615
16616
16617 static char *sip_show_peers(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
16618 {
16619 switch (cmd) {
16620 case CLI_INIT:
16621 e->command = "sip show peers";
16622 e->usage =
16623 "Usage: sip show peers [like <pattern>]\n"
16624 " Lists all known SIP peers.\n"
16625 " Optional regular expression pattern is used to filter the peer list.\n";
16626 return NULL;
16627 case CLI_GENERATE:
16628 return NULL;
16629 }
16630
16631 return _sip_show_peers(a->fd, NULL, NULL, NULL, a->argc, (const char **) a->argv);
16632 }
16633
16634 int peercomparefunc(const void *a, const void *b);
16635
16636 int peercomparefunc(const void *a, const void *b)
16637 {
16638 struct sip_peer **ap = (struct sip_peer **)a;
16639 struct sip_peer **bp = (struct sip_peer **)b;
16640 return strcmp((*ap)->name, (*bp)->name);
16641 }
16642
16643
16644
16645 static char *_sip_show_peers(int fd, int *total, struct mansession *s, const struct message *m, int argc, const char *argv[])
16646 {
16647 regex_t regexbuf;
16648 int havepattern = FALSE;
16649 struct sip_peer *peer;
16650 struct ao2_iterator i;
16651
16652
16653 #define FORMAT2 "%-25.25s %-39.39s %-3.3s %-10.10s %-3.3s %-8s %-10s %s\n"
16654 #define FORMAT "%-25.25s %-39.39s %-3.3s %-3.3s %-3.3s %-8d %-10s %s\n"
16655
16656 char name[256];
16657 int total_peers = 0;
16658 int peers_mon_online = 0;
16659 int peers_mon_offline = 0;
16660 int peers_unmon_offline = 0;
16661 int peers_unmon_online = 0;
16662 const char *id;
16663 char idtext[256] = "";
16664 int realtimepeers;
16665 int objcount = ao2_container_count(peers);
16666 struct sip_peer **peerarray;
16667 int k;
16668
16669
16670 realtimepeers = ast_check_realtime("sippeers");
16671 peerarray = ast_calloc(sizeof(struct sip_peer *), objcount);
16672
16673 if (s) {
16674 id = astman_get_header(m, "ActionID");
16675 if (!ast_strlen_zero(id))
16676 snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
16677 }
16678
16679 switch (argc) {
16680 case 5:
16681 if (!strcasecmp(argv[3], "like")) {
16682 if (regcomp(®exbuf, argv[4], REG_EXTENDED | REG_NOSUB))
16683 return CLI_SHOWUSAGE;
16684 havepattern = TRUE;
16685 } else
16686 return CLI_SHOWUSAGE;
16687 case 3:
16688 break;
16689 default:
16690 return CLI_SHOWUSAGE;
16691 }
16692
16693 if (!s)
16694 ast_cli(fd, FORMAT2, "Name/username", "Host", "Dyn", "Forcerport", "ACL", "Port", "Status", (realtimepeers ? "Realtime" : ""));
16695
16696
16697 i = ao2_iterator_init(peers, 0);
16698 while ((peer = ao2_t_iterator_next(&i, "iterate thru peers table"))) {
16699 ao2_lock(peer);
16700
16701 if (!(peer->type & SIP_TYPE_PEER)) {
16702 ao2_unlock(peer);
16703 unref_peer(peer, "unref peer because it's actually a user");
16704 continue;
16705 }
16706
16707 if (havepattern && regexec(®exbuf, peer->name, 0, NULL, 0)) {
16708 objcount--;
16709 ao2_unlock(peer);
16710 unref_peer(peer, "toss iterator peer ptr before continue");
16711 continue;
16712 }
16713
16714 peerarray[total_peers++] = peer;
16715 ao2_unlock(peer);
16716 }
16717 ao2_iterator_destroy(&i);
16718
16719 qsort(peerarray, total_peers, sizeof(struct sip_peer *), peercomparefunc);
16720
16721 for(k=0; k < total_peers; k++) {
16722 char status[20] = "";
16723 char srch[2000];
16724 char pstatus;
16725 peer = peerarray[k];
16726
16727 ao2_lock(peer);
16728 if (havepattern && regexec(®exbuf, peer->name, 0, NULL, 0)) {
16729 ao2_unlock(peer);
16730 peer = peerarray[k] = unref_peer(peer, "toss iterator peer ptr before continue");
16731 continue;
16732 }
16733
16734 if (!ast_strlen_zero(peer->username) && !s)
16735 snprintf(name, sizeof(name), "%s/%s", peer->name, peer->username);
16736 else
16737 ast_copy_string(name, peer->name, sizeof(name));
16738
16739 pstatus = peer_status(peer, status, sizeof(status));
16740 if (pstatus == 1)
16741 peers_mon_online++;
16742 else if (pstatus == 0)
16743 peers_mon_offline++;
16744 else {
16745 if (ast_sockaddr_isnull(&peer->addr) ||
16746 !ast_sockaddr_port(&peer->addr)) {
16747 peers_unmon_offline++;
16748 } else {
16749 peers_unmon_online++;
16750 }
16751 }
16752
16753 snprintf(srch, sizeof(srch), FORMAT, name,
16754 ast_sockaddr_isnull(&peer->addr) ? "(Unspecified)" : ast_sockaddr_stringify_addr(&peer->addr),
16755 peer->host_dynamic ? " D " : " ",
16756 ast_test_flag(&peer->flags[0], SIP_NAT_FORCE_RPORT) ? " N " : " ",
16757 peer->ha ? " A " : " ",
16758 ast_sockaddr_isnull(&peer->addr) ? 0 : ast_sockaddr_port(&peer->addr), status,
16759 realtimepeers ? (peer->is_realtime ? "Cached RT":"") : "");
16760
16761 if (!s) {
16762 ast_cli(fd, FORMAT, name,
16763 ast_sockaddr_isnull(&peer->addr) ? "(Unspecified)" : ast_sockaddr_stringify_addr(&peer->addr),
16764 peer->host_dynamic ? " D " : " ",
16765 ast_test_flag(&peer->flags[0], SIP_NAT_FORCE_RPORT) ? " N " : " ",
16766 peer->ha ? " A " : " ",
16767 ast_sockaddr_isnull(&peer->addr) ? 0 : ast_sockaddr_port(&peer->addr), status,
16768 realtimepeers ? (peer->is_realtime ? "Cached RT":"") : "");
16769 } else {
16770
16771 astman_append(s,
16772 "Event: PeerEntry\r\n%s"
16773 "Channeltype: SIP\r\n"
16774 "ObjectName: %s\r\n"
16775 "ChanObjectType: peer\r\n"
16776 "IPaddress: %s\r\n"
16777 "IPport: %d\r\n"
16778 "Dynamic: %s\r\n"
16779 "Forcerport: %s\r\n"
16780 "VideoSupport: %s\r\n"
16781 "TextSupport: %s\r\n"
16782 "ACL: %s\r\n"
16783 "Status: %s\r\n"
16784 "RealtimeDevice: %s\r\n\r\n",
16785 idtext,
16786 peer->name,
16787 ast_sockaddr_isnull(&peer->addr) ? "-none-" : ast_sockaddr_stringify_fmt(&peer->addr, AST_SOCKADDR_STR_HOST),
16788 ast_sockaddr_isnull(&peer->addr) ? 0 : ast_sockaddr_port(&peer->addr),
16789 peer->host_dynamic ? "yes" : "no",
16790 ast_test_flag(&peer->flags[0], SIP_NAT_FORCE_RPORT) ? "yes" : "no",
16791 ast_test_flag(&peer->flags[1], SIP_PAGE2_VIDEOSUPPORT) ? "yes" : "no",
16792 ast_test_flag(&peer->flags[1], SIP_PAGE2_TEXTSUPPORT) ? "yes" : "no",
16793 peer->ha ? "yes" : "no",
16794 status,
16795 realtimepeers ? (peer->is_realtime ? "yes":"no") : "no");
16796 }
16797 ao2_unlock(peer);
16798 peer = peerarray[k] = unref_peer(peer, "toss iterator peer ptr");
16799 }
16800
16801 if (!s)
16802 ast_cli(fd, "%d sip peers [Monitored: %d online, %d offline Unmonitored: %d online, %d offline]\n",
16803 total_peers, peers_mon_online, peers_mon_offline, peers_unmon_online, peers_unmon_offline);
16804
16805 if (havepattern)
16806 regfree(®exbuf);
16807
16808 if (total)
16809 *total = total_peers;
16810
16811 ast_free(peerarray);
16812
16813 return CLI_SUCCESS;
16814 #undef FORMAT
16815 #undef FORMAT2
16816 }
16817
16818 static int peer_dump_func(void *userobj, void *arg, int flags)
16819 {
16820 struct sip_peer *peer = userobj;
16821 int refc = ao2_t_ref(userobj, 0, "");
16822 struct ast_cli_args *a = (struct ast_cli_args *) arg;
16823
16824 ast_cli(a->fd, "name: %s\ntype: peer\nobjflags: %d\nrefcount: %d\n\n",
16825 peer->name, 0, refc);
16826 return 0;
16827 }
16828
16829 static int dialog_dump_func(void *userobj, void *arg, int flags)
16830 {
16831 struct sip_pvt *pvt = userobj;
16832 int refc = ao2_t_ref(userobj, 0, "");
16833 struct ast_cli_args *a = (struct ast_cli_args *) arg;
16834
16835 ast_cli(a->fd, "name: %s\ntype: dialog\nobjflags: %d\nrefcount: %d\n\n",
16836 pvt->callid, 0, refc);
16837 return 0;
16838 }
16839
16840
16841
16842 static char *sip_show_objects(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
16843 {
16844 char tmp[256];
16845
16846 switch (cmd) {
16847 case CLI_INIT:
16848 e->command = "sip show objects";
16849 e->usage =
16850 "Usage: sip show objects\n"
16851 " Lists status of known SIP objects\n";
16852 return NULL;
16853 case CLI_GENERATE:
16854 return NULL;
16855 }
16856
16857 if (a->argc != 3)
16858 return CLI_SHOWUSAGE;
16859 ast_cli(a->fd, "-= Peer objects: %d static, %d realtime, %d autocreate =-\n\n", speerobjs, rpeerobjs, apeerobjs);
16860 ao2_t_callback(peers, OBJ_NODATA, peer_dump_func, a, "initiate ao2_callback to dump peers");
16861 ast_cli(a->fd, "-= Peer objects by IP =-\n\n");
16862 ao2_t_callback(peers_by_ip, OBJ_NODATA, peer_dump_func, a, "initiate ao2_callback to dump peers_by_ip");
16863 ast_cli(a->fd, "-= Registry objects: %d =-\n\n", regobjs);
16864 ASTOBJ_CONTAINER_DUMP(a->fd, tmp, sizeof(tmp), ®l);
16865 ast_cli(a->fd, "-= Dialog objects:\n\n");
16866 ao2_t_callback(dialogs, OBJ_NODATA, dialog_dump_func, a, "initiate ao2_callback to dump dialogs");
16867 return CLI_SUCCESS;
16868 }
16869
16870 static void print_group(int fd, ast_group_t group, int crlf)
16871 {
16872 char buf[256];
16873 ast_cli(fd, crlf ? "%s\r\n" : "%s\n", ast_print_group(buf, sizeof(buf), group) );
16874 }
16875
16876
16877 static const struct _map_x_s dtmfstr[] = {
16878 { SIP_DTMF_RFC2833, "rfc2833" },
16879 { SIP_DTMF_INFO, "info" },
16880 { SIP_DTMF_SHORTINFO, "shortinfo" },
16881 { SIP_DTMF_INBAND, "inband" },
16882 { SIP_DTMF_AUTO, "auto" },
16883 { -1, NULL },
16884 };
16885
16886
16887 static const char *dtmfmode2str(int mode)
16888 {
16889 return map_x_s(dtmfstr, mode, "<error>");
16890 }
16891
16892
16893 static int str2dtmfmode(const char *str)
16894 {
16895 return map_s_x(dtmfstr, str, -1);
16896 }
16897
16898 static const struct _map_x_s insecurestr[] = {
16899 { SIP_INSECURE_PORT, "port" },
16900 { SIP_INSECURE_INVITE, "invite" },
16901 { SIP_INSECURE_PORT | SIP_INSECURE_INVITE, "port,invite" },
16902 { 0, "no" },
16903 { -1, NULL },
16904 };
16905
16906
16907 static const char *insecure2str(int mode)
16908 {
16909 return map_x_s(insecurestr, mode, "<error>");
16910 }
16911
16912 static const struct _map_x_s allowoverlapstr[] = {
16913 { SIP_PAGE2_ALLOWOVERLAP_YES, "Yes" },
16914 { SIP_PAGE2_ALLOWOVERLAP_DTMF, "DTMF" },
16915 { SIP_PAGE2_ALLOWOVERLAP_NO, "No" },
16916 { -1, NULL },
16917 };
16918
16919
16920 static const char *allowoverlap2str(int mode)
16921 {
16922 return map_x_s(allowoverlapstr, mode, "<error>");
16923 }
16924
16925
16926
16927
16928 static void cleanup_stale_contexts(char *new, char *old)
16929 {
16930 char *oldcontext, *newcontext, *stalecontext, *stringp, newlist[AST_MAX_CONTEXT];
16931
16932 while ((oldcontext = strsep(&old, "&"))) {
16933 stalecontext = '\0';
16934 ast_copy_string(newlist, new, sizeof(newlist));
16935 stringp = newlist;
16936 while ((newcontext = strsep(&stringp, "&"))) {
16937 if (!strcmp(newcontext, oldcontext)) {
16938
16939 stalecontext = '\0';
16940 break;
16941 } else if (strcmp(newcontext, oldcontext)) {
16942 stalecontext = oldcontext;
16943 }
16944
16945 }
16946 if (stalecontext)
16947 ast_context_destroy(ast_context_find(stalecontext), "SIP");
16948 }
16949 }
16950
16951
16952
16953
16954
16955
16956
16957
16958
16959
16960
16961 static int dialog_needdestroy(void *dialogobj, void *arg, int flags)
16962 {
16963 struct sip_pvt *dialog = dialogobj;
16964 time_t *t = arg;
16965
16966 if (sip_pvt_trylock(dialog)) {
16967
16968
16969 return 0;
16970 }
16971
16972
16973 check_rtp_timeout(dialog, *t);
16974
16975
16976 if (dialog->rtp && ast_rtp_instance_get_bridged(dialog->rtp)) {
16977 ast_debug(2, "Bridge still active. Delaying destroy of SIP dialog '%s' Method: %s\n", dialog->callid, sip_methods[dialog->method].text);
16978 sip_pvt_unlock(dialog);
16979 return 0;
16980 }
16981
16982 if (dialog->vrtp && ast_rtp_instance_get_bridged(dialog->vrtp)) {
16983 ast_debug(2, "Bridge still active. Delaying destroy of SIP dialog '%s' Method: %s\n", dialog->callid, sip_methods[dialog->method].text);
16984 sip_pvt_unlock(dialog);
16985 return 0;
16986 }
16987
16988
16989
16990
16991 if (dialog->needdestroy && !dialog->packets && !dialog->owner) {
16992
16993 if (dialog->rtp && ast_rtp_instance_get_bridged(dialog->rtp)) {
16994 ast_debug(2, "Bridge still active. Delaying destruction of SIP dialog '%s' Method: %s\n", dialog->callid, sip_methods[dialog->method].text);
16995 sip_pvt_unlock(dialog);
16996 return 0;
16997 }
16998
16999 if (dialog->vrtp && ast_rtp_instance_get_bridged(dialog->vrtp)) {
17000 ast_debug(2, "Bridge still active. Delaying destroy of SIP dialog '%s' Method: %s\n", dialog->callid, sip_methods[dialog->method].text);
17001 sip_pvt_unlock(dialog);
17002 return 0;
17003 }
17004
17005 sip_pvt_unlock(dialog);
17006
17007
17008 ao2_t_link(dialogs_to_destroy, dialog, "Link dialog for destruction");
17009 return 0;
17010 }
17011
17012 sip_pvt_unlock(dialog);
17013
17014 return 0;
17015 }
17016
17017
17018
17019
17020
17021
17022
17023
17024
17025
17026
17027 static int dialog_unlink_callback(void *obj, void *arg, int flags)
17028 {
17029 struct sip_pvt *dialog = obj;
17030
17031 dialog_unlink_all(dialog);
17032
17033 return CMP_MATCH;
17034 }
17035
17036
17037
17038 static char *sip_prune_realtime(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
17039 {
17040 struct sip_peer *peer, *pi;
17041 int prunepeer = FALSE;
17042 int multi = FALSE;
17043 const char *name = NULL;
17044 regex_t regexbuf;
17045 int havepattern = 0;
17046 struct ao2_iterator i;
17047 static const char * const choices[] = { "all", "like", NULL };
17048 char *cmplt;
17049
17050 if (cmd == CLI_INIT) {
17051 e->command = "sip prune realtime [peer|all]";
17052 e->usage =
17053 "Usage: sip prune realtime [peer [<name>|all|like <pattern>]|all]\n"
17054 " Prunes object(s) from the cache.\n"
17055 " Optional regular expression pattern is used to filter the objects.\n";
17056 return NULL;
17057 } else if (cmd == CLI_GENERATE) {
17058 if (a->pos == 4 && !strcasecmp(a->argv[3], "peer")) {
17059 cmplt = ast_cli_complete(a->word, choices, a->n);
17060 if (!cmplt)
17061 cmplt = complete_sip_peer(a->word, a->n - sizeof(choices), SIP_PAGE2_RTCACHEFRIENDS);
17062 return cmplt;
17063 }
17064 if (a->pos == 5 && !strcasecmp(a->argv[4], "like"))
17065 return complete_sip_peer(a->word, a->n, SIP_PAGE2_RTCACHEFRIENDS);
17066 return NULL;
17067 }
17068 switch (a->argc) {
17069 case 4:
17070 name = a->argv[3];
17071
17072 if (!strcasecmp(name, "peer") || !strcasecmp(name, "like"))
17073 return CLI_SHOWUSAGE;
17074 prunepeer = TRUE;
17075 if (!strcasecmp(name, "all")) {
17076 multi = TRUE;
17077 name = NULL;
17078 }
17079
17080 break;
17081 case 5:
17082
17083 name = a->argv[4];
17084 if (!strcasecmp(a->argv[3], "peer"))
17085 prunepeer = TRUE;
17086 else if (!strcasecmp(a->argv[3], "like")) {
17087 prunepeer = TRUE;
17088 multi = TRUE;
17089 } else
17090 return CLI_SHOWUSAGE;
17091 if (!strcasecmp(name, "like"))
17092 return CLI_SHOWUSAGE;
17093 if (!multi && !strcasecmp(name, "all")) {
17094 multi = TRUE;
17095 name = NULL;
17096 }
17097 break;
17098 case 6:
17099 name = a->argv[5];
17100 multi = TRUE;
17101
17102 if (strcasecmp(a->argv[4], "like"))
17103 return CLI_SHOWUSAGE;
17104 if (!strcasecmp(a->argv[3], "peer")) {
17105 prunepeer = TRUE;
17106 } else
17107 return CLI_SHOWUSAGE;
17108 break;
17109 default:
17110 return CLI_SHOWUSAGE;
17111 }
17112
17113 if (multi && name) {
17114 if (regcomp(®exbuf, name, REG_EXTENDED | REG_NOSUB)) {
17115 return CLI_SHOWUSAGE;
17116 }
17117 havepattern = 1;
17118 }
17119
17120 if (multi) {
17121 if (prunepeer) {
17122 int pruned = 0;
17123
17124 i = ao2_iterator_init(peers, 0);
17125 while ((pi = ao2_t_iterator_next(&i, "iterate thru peers table"))) {
17126 ao2_lock(pi);
17127 if (name && regexec(®exbuf, pi->name, 0, NULL, 0)) {
17128 ao2_unlock(pi);
17129 unref_peer(pi, "toss iterator peer ptr before continue");
17130 continue;
17131 };
17132 if (ast_test_flag(&pi->flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
17133 pi->the_mark = 1;
17134 pruned++;
17135 }
17136 ao2_unlock(pi);
17137 unref_peer(pi, "toss iterator peer ptr");
17138 }
17139 ao2_iterator_destroy(&i);
17140 if (pruned) {
17141 unlink_marked_peers_from_tables();
17142 ast_cli(a->fd, "%d peers pruned.\n", pruned);
17143 } else
17144 ast_cli(a->fd, "No peers found to prune.\n");
17145 }
17146 } else {
17147 if (prunepeer) {
17148 struct sip_peer tmp;
17149 ast_copy_string(tmp.name, name, sizeof(tmp.name));
17150 if ((peer = ao2_t_find(peers, &tmp, OBJ_POINTER | OBJ_UNLINK, "finding to unlink from peers"))) {
17151 if (!ast_sockaddr_isnull(&peer->addr)) {
17152 ao2_t_unlink(peers_by_ip, peer, "unlinking peer from peers_by_ip also");
17153 }
17154 if (!ast_test_flag(&peer->flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
17155 ast_cli(a->fd, "Peer '%s' is not a Realtime peer, cannot be pruned.\n", name);
17156
17157 ao2_t_link(peers, peer, "link peer into peer table");
17158 if (!ast_sockaddr_isnull(&peer->addr)) {
17159 ao2_t_link(peers_by_ip, peer, "link peer into peers_by_ip table");
17160 }
17161 } else
17162 ast_cli(a->fd, "Peer '%s' pruned.\n", name);
17163 unref_peer(peer, "sip_prune_realtime: unref_peer: tossing temp peer ptr");
17164 } else
17165 ast_cli(a->fd, "Peer '%s' not found.\n", name);
17166 }
17167 }
17168
17169 if (havepattern) {
17170 regfree(®exbuf);
17171 }
17172
17173 return CLI_SUCCESS;
17174 }
17175
17176
17177 static void print_codec_to_cli(int fd, struct ast_codec_pref *pref)
17178 {
17179 int x;
17180 format_t codec;
17181
17182 for(x = 0; x < 64 ; x++) {
17183 codec = ast_codec_pref_index(pref, x);
17184 if (!codec)
17185 break;
17186 ast_cli(fd, "%s", ast_getformatname(codec));
17187 ast_cli(fd, ":%d", pref->framing[x]);
17188 if (x < 31 && ast_codec_pref_index(pref, x + 1))
17189 ast_cli(fd, ",");
17190 }
17191 if (!x)
17192 ast_cli(fd, "none");
17193 }
17194
17195
17196 static const char *domain_mode_to_text(const enum domain_mode mode)
17197 {
17198 switch (mode) {
17199 case SIP_DOMAIN_AUTO:
17200 return "[Automatic]";
17201 case SIP_DOMAIN_CONFIG:
17202 return "[Configured]";
17203 }
17204
17205 return "";
17206 }
17207
17208
17209 static char *sip_show_domains(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
17210 {
17211 struct domain *d;
17212 #define FORMAT "%-40.40s %-20.20s %-16.16s\n"
17213
17214 switch (cmd) {
17215 case CLI_INIT:
17216 e->command = "sip show domains";
17217 e->usage =
17218 "Usage: sip show domains\n"
17219 " Lists all configured SIP local domains.\n"
17220 " Asterisk only responds to SIP messages to local domains.\n";
17221 return NULL;
17222 case CLI_GENERATE:
17223 return NULL;
17224 }
17225
17226 if (AST_LIST_EMPTY(&domain_list)) {
17227 ast_cli(a->fd, "SIP Domain support not enabled.\n\n");
17228 return CLI_SUCCESS;
17229 } else {
17230 ast_cli(a->fd, FORMAT, "Our local SIP domains:", "Context", "Set by");
17231 AST_LIST_LOCK(&domain_list);
17232 AST_LIST_TRAVERSE(&domain_list, d, list)
17233 ast_cli(a->fd, FORMAT, d->domain, S_OR(d->context, "(default)"),
17234 domain_mode_to_text(d->mode));
17235 AST_LIST_UNLOCK(&domain_list);
17236 ast_cli(a->fd, "\n");
17237 return CLI_SUCCESS;
17238 }
17239 }
17240 #undef FORMAT
17241
17242
17243 static int manager_sip_show_peer(struct mansession *s, const struct message *m)
17244 {
17245 const char *a[4];
17246 const char *peer;
17247
17248 peer = astman_get_header(m, "Peer");
17249 if (ast_strlen_zero(peer)) {
17250 astman_send_error(s, m, "Peer: <name> missing.");
17251 return 0;
17252 }
17253 a[0] = "sip";
17254 a[1] = "show";
17255 a[2] = "peer";
17256 a[3] = peer;
17257
17258 _sip_show_peer(1, -1, s, m, 4, a);
17259 astman_append(s, "\r\n" );
17260 return 0;
17261 }
17262
17263
17264 static char *sip_show_peer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
17265 {
17266 switch (cmd) {
17267 case CLI_INIT:
17268 e->command = "sip show peer";
17269 e->usage =
17270 "Usage: sip show peer <name> [load]\n"
17271 " Shows all details on one SIP peer and the current status.\n"
17272 " Option \"load\" forces lookup of peer in realtime storage.\n";
17273 return NULL;
17274 case CLI_GENERATE:
17275 return complete_sip_show_peer(a->line, a->word, a->pos, a->n);
17276 }
17277 return _sip_show_peer(0, a->fd, NULL, NULL, a->argc, (const char **) a->argv);
17278 }
17279
17280
17281 static char *_sip_qualify_peer(int type, int fd, struct mansession *s, const struct message *m, int argc, const char *argv[])
17282 {
17283 struct sip_peer *peer;
17284 int load_realtime;
17285
17286 if (argc < 4)
17287 return CLI_SHOWUSAGE;
17288
17289 load_realtime = (argc == 5 && !strcmp(argv[4], "load")) ? TRUE : FALSE;
17290 if ((peer = find_peer(argv[3], NULL, load_realtime, FINDPEERS, FALSE, 0))) {
17291 sip_poke_peer(peer, 1);
17292 unref_peer(peer, "qualify: done with peer");
17293 } else if (type == 0) {
17294 ast_cli(fd, "Peer '%s' not found\n", argv[3]);
17295 } else {
17296 astman_send_error(s, m, "Peer not found");
17297 }
17298 return CLI_SUCCESS;
17299 }
17300
17301
17302 static int manager_sip_qualify_peer(struct mansession *s, const struct message *m)
17303 {
17304 const char *a[4];
17305 const char *peer;
17306
17307 peer = astman_get_header(m, "Peer");
17308 if (ast_strlen_zero(peer)) {
17309 astman_send_error(s, m, "Peer: <name> missing.");
17310 return 0;
17311 }
17312 a[0] = "sip";
17313 a[1] = "qualify";
17314 a[2] = "peer";
17315 a[3] = peer;
17316
17317 _sip_qualify_peer(1, -1, s, m, 4, a);
17318 astman_append(s, "\r\n\r\n" );
17319 return 0;
17320 }
17321
17322
17323 static char *sip_qualify_peer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
17324 {
17325 switch (cmd) {
17326 case CLI_INIT:
17327 e->command = "sip qualify peer";
17328 e->usage =
17329 "Usage: sip qualify peer <name> [load]\n"
17330 " Requests a response from one SIP peer and the current status.\n"
17331 " Option \"load\" forces lookup of peer in realtime storage.\n";
17332 return NULL;
17333 case CLI_GENERATE:
17334 return complete_sip_show_peer(a->line, a->word, a->pos, a->n);
17335 }
17336 return _sip_qualify_peer(0, a->fd, NULL, NULL, a->argc, (const char **) a->argv);
17337 }
17338
17339
17340 static void peer_mailboxes_to_str(struct ast_str **mailbox_str, struct sip_peer *peer)
17341 {
17342 struct sip_mailbox *mailbox;
17343
17344 AST_LIST_TRAVERSE(&peer->mailboxes, mailbox, entry) {
17345 ast_str_append(mailbox_str, 0, "%s%s%s%s",
17346 mailbox->mailbox,
17347 ast_strlen_zero(mailbox->context) ? "" : "@",
17348 S_OR(mailbox->context, ""),
17349 AST_LIST_NEXT(mailbox, entry) ? "," : "");
17350 }
17351 }
17352
17353 static struct _map_x_s faxecmodes[] = {
17354 { SIP_PAGE2_T38SUPPORT_UDPTL, "None"},
17355 { SIP_PAGE2_T38SUPPORT_UDPTL_FEC, "FEC"},
17356 { SIP_PAGE2_T38SUPPORT_UDPTL_REDUNDANCY, "Redundancy"},
17357 { -1, NULL},
17358 };
17359
17360 static const char *faxec2str(int faxec)
17361 {
17362 return map_x_s(faxecmodes, faxec, "Unknown");
17363 }
17364
17365
17366 static char *_sip_show_peer(int type, int fd, struct mansession *s, const struct message *m, int argc, const char *argv[])
17367 {
17368 char status[30] = "";
17369 char cbuf[256];
17370 struct sip_peer *peer;
17371 char codec_buf[512];
17372 struct ast_codec_pref *pref;
17373 struct ast_variable *v;
17374 int x = 0, load_realtime;
17375 format_t codec = 0;
17376 int realtimepeers;
17377
17378 realtimepeers = ast_check_realtime("sippeers");
17379
17380 if (argc < 4)
17381 return CLI_SHOWUSAGE;
17382
17383 load_realtime = (argc == 5 && !strcmp(argv[4], "load")) ? TRUE : FALSE;
17384 peer = find_peer(argv[3], NULL, load_realtime, FINDPEERS, FALSE, 0);
17385
17386 if (s) {
17387 if (peer) {
17388 const char *id = astman_get_header(m, "ActionID");
17389
17390 astman_append(s, "Response: Success\r\n");
17391 if (!ast_strlen_zero(id))
17392 astman_append(s, "ActionID: %s\r\n", id);
17393 } else {
17394 snprintf (cbuf, sizeof(cbuf), "Peer %s not found.", argv[3]);
17395 astman_send_error(s, m, cbuf);
17396 return CLI_SUCCESS;
17397 }
17398 }
17399 if (peer && type==0 ) {
17400 struct ast_str *mailbox_str = ast_str_alloca(512);
17401 struct sip_auth_container *credentials;
17402
17403 ao2_lock(peer);
17404 credentials = peer->auth;
17405 if (credentials) {
17406 ao2_t_ref(credentials, +1, "Ref peer auth for show");
17407 }
17408 ao2_unlock(peer);
17409
17410 ast_cli(fd, "\n\n");
17411 ast_cli(fd, " * Name : %s\n", peer->name);
17412 if (realtimepeers) {
17413 ast_cli(fd, " Realtime peer: %s\n", peer->is_realtime ? "Yes, cached" : "No");
17414 }
17415 ast_cli(fd, " Secret : %s\n", ast_strlen_zero(peer->secret)?"<Not set>":"<Set>");
17416 ast_cli(fd, " MD5Secret : %s\n", ast_strlen_zero(peer->md5secret)?"<Not set>":"<Set>");
17417 ast_cli(fd, " Remote Secret: %s\n", ast_strlen_zero(peer->remotesecret)?"<Not set>":"<Set>");
17418 if (credentials) {
17419 struct sip_auth *auth;
17420
17421 AST_LIST_TRAVERSE(&credentials->list, auth, node) {
17422 ast_cli(fd, " Realm-auth : Realm %-15.15s User %-10.20s %s\n",
17423 auth->realm,
17424 auth->username,
17425 !ast_strlen_zero(auth->secret)
17426 ? "<Secret set>"
17427 : (!ast_strlen_zero(auth->md5secret)
17428 ? "<MD5secret set>" : "<Not set>"));
17429 }
17430 ao2_t_ref(credentials, -1, "Unref peer auth for show");
17431 }
17432 ast_cli(fd, " Context : %s\n", peer->context);
17433 ast_cli(fd, " Subscr.Cont. : %s\n", S_OR(peer->subscribecontext, "<Not set>") );
17434 ast_cli(fd, " Language : %s\n", peer->language);
17435 if (!ast_strlen_zero(peer->accountcode))
17436 ast_cli(fd, " Accountcode : %s\n", peer->accountcode);
17437 ast_cli(fd, " AMA flags : %s\n", ast_cdr_flags2str(peer->amaflags));
17438 ast_cli(fd, " Transfer mode: %s\n", transfermode2str(peer->allowtransfer));
17439 ast_cli(fd, " CallingPres : %s\n", ast_describe_caller_presentation(peer->callingpres));
17440 if (!ast_strlen_zero(peer->fromuser))
17441 ast_cli(fd, " FromUser : %s\n", peer->fromuser);
17442 if (!ast_strlen_zero(peer->fromdomain))
17443 ast_cli(fd, " FromDomain : %s Port %d\n", peer->fromdomain, (peer->fromdomainport) ? peer->fromdomainport : STANDARD_SIP_PORT);
17444 ast_cli(fd, " Callgroup : ");
17445 print_group(fd, peer->callgroup, 0);
17446 ast_cli(fd, " Pickupgroup : ");
17447 print_group(fd, peer->pickupgroup, 0);
17448 peer_mailboxes_to_str(&mailbox_str, peer);
17449 ast_cli(fd, " MOH Suggest : %s\n", peer->mohsuggest);
17450 ast_cli(fd, " Mailbox : %s\n", mailbox_str->str);
17451 ast_cli(fd, " VM Extension : %s\n", peer->vmexten);
17452 ast_cli(fd, " LastMsgsSent : %d/%d\n", (peer->lastmsgssent & 0x7fff0000) >> 16, peer->lastmsgssent & 0xffff);
17453 ast_cli(fd, " Call limit : %d\n", peer->call_limit);
17454 ast_cli(fd, " Max forwards : %d\n", peer->maxforwards);
17455 if (peer->busy_level)
17456 ast_cli(fd, " Busy level : %d\n", peer->busy_level);
17457 ast_cli(fd, " Dynamic : %s\n", AST_CLI_YESNO(peer->host_dynamic));
17458 ast_cli(fd, " Callerid : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
17459 ast_cli(fd, " MaxCallBR : %d kbps\n", peer->maxcallbitrate);
17460 ast_cli(fd, " Expire : %ld\n", ast_sched_when(sched, peer->expire));
17461 ast_cli(fd, " Insecure : %s\n", insecure2str(ast_test_flag(&peer->flags[0], SIP_INSECURE)));
17462 ast_cli(fd, " Force rport : %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[0], SIP_NAT_FORCE_RPORT)));
17463 ast_cli(fd, " ACL : %s\n", AST_CLI_YESNO(peer->ha != NULL));
17464 ast_cli(fd, " DirectMedACL : %s\n", AST_CLI_YESNO(peer->directmediaha != NULL));
17465 ast_cli(fd, " T.38 support : %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[1], SIP_PAGE2_T38SUPPORT)));
17466 ast_cli(fd, " T.38 EC mode : %s\n", faxec2str(ast_test_flag(&peer->flags[1], SIP_PAGE2_T38SUPPORT)));
17467 ast_cli(fd, " T.38 MaxDtgrm: %d\n", peer->t38_maxdatagram);
17468 ast_cli(fd, " DirectMedia : %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[0], SIP_DIRECT_MEDIA)));
17469 ast_cli(fd, " PromiscRedir : %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[0], SIP_PROMISCREDIR)));
17470 ast_cli(fd, " User=Phone : %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[0], SIP_USEREQPHONE)));
17471 ast_cli(fd, " Video Support: %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[1], SIP_PAGE2_VIDEOSUPPORT) || ast_test_flag(&peer->flags[1], SIP_PAGE2_VIDEOSUPPORT_ALWAYS)));
17472 ast_cli(fd, " Text Support : %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[1], SIP_PAGE2_TEXTSUPPORT)));
17473 ast_cli(fd, " Ign SDP ver : %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[1], SIP_PAGE2_IGNORESDPVERSION)));
17474 ast_cli(fd, " Trust RPID : %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[0], SIP_TRUSTRPID)));
17475 ast_cli(fd, " Send RPID : %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[0], SIP_SENDRPID)));
17476 ast_cli(fd, " Subscriptions: %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[1], SIP_PAGE2_ALLOWSUBSCRIBE)));
17477 ast_cli(fd, " Overlap dial : %s\n", allowoverlap2str(ast_test_flag(&peer->flags[1], SIP_PAGE2_ALLOWOVERLAP)));
17478 if (peer->outboundproxy)
17479 ast_cli(fd, " Outb. proxy : %s %s\n", ast_strlen_zero(peer->outboundproxy->name) ? "<not set>" : peer->outboundproxy->name,
17480 peer->outboundproxy->force ? "(forced)" : "");
17481
17482
17483 ast_cli(fd, " DTMFmode : %s\n", dtmfmode2str(ast_test_flag(&peer->flags[0], SIP_DTMF)));
17484 ast_cli(fd, " Timer T1 : %d\n", peer->timer_t1);
17485 ast_cli(fd, " Timer B : %d\n", peer->timer_b);
17486 ast_cli(fd, " ToHost : %s\n", peer->tohost);
17487 ast_cli(fd, " Addr->IP : %s\n", ast_sockaddr_stringify(&peer->addr));
17488 ast_cli(fd, " Defaddr->IP : %s\n", ast_sockaddr_stringify(&peer->defaddr));
17489 ast_cli(fd, " Prim.Transp. : %s\n", get_transport(peer->socket.type));
17490 ast_cli(fd, " Allowed.Trsp : %s\n", get_transport_list(peer->transports));
17491 if (!ast_strlen_zero(sip_cfg.regcontext))
17492 ast_cli(fd, " Reg. exten : %s\n", peer->regexten);
17493 ast_cli(fd, " Def. Username: %s\n", peer->username);
17494 ast_cli(fd, " SIP Options : ");
17495 if (peer->sipoptions) {
17496 int lastoption = -1;
17497 for (x = 0 ; x < ARRAY_LEN(sip_options); x++) {
17498 if (sip_options[x].id != lastoption) {
17499 if (peer->sipoptions & sip_options[x].id)
17500 ast_cli(fd, "%s ", sip_options[x].text);
17501 lastoption = x;
17502 }
17503 }
17504 } else
17505 ast_cli(fd, "(none)");
17506
17507 ast_cli(fd, "\n");
17508 ast_cli(fd, " Codecs : ");
17509 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
17510 ast_cli(fd, "%s\n", codec_buf);
17511 ast_cli(fd, " Codec Order : (");
17512 print_codec_to_cli(fd, &peer->prefs);
17513 ast_cli(fd, ")\n");
17514
17515 ast_cli(fd, " Auto-Framing : %s \n", AST_CLI_YESNO(peer->autoframing));
17516 ast_cli(fd, " Status : ");
17517 peer_status(peer, status, sizeof(status));
17518 ast_cli(fd, "%s\n", status);
17519 ast_cli(fd, " Useragent : %s\n", peer->useragent);
17520 ast_cli(fd, " Reg. Contact : %s\n", peer->fullcontact);
17521 ast_cli(fd, " Qualify Freq : %d ms\n", peer->qualifyfreq);
17522 if (peer->chanvars) {
17523 ast_cli(fd, " Variables :\n");
17524 for (v = peer->chanvars ; v ; v = v->next)
17525 ast_cli(fd, " %s = %s\n", v->name, v->value);
17526 }
17527
17528 ast_cli(fd, " Sess-Timers : %s\n", stmode2str(peer->stimer.st_mode_oper));
17529 ast_cli(fd, " Sess-Refresh : %s\n", strefresher2str(peer->stimer.st_ref));
17530 ast_cli(fd, " Sess-Expires : %d secs\n", peer->stimer.st_max_se);
17531 ast_cli(fd, " Min-Sess : %d secs\n", peer->stimer.st_min_se);
17532 ast_cli(fd, " RTP Engine : %s\n", peer->engine);
17533 ast_cli(fd, " Parkinglot : %s\n", peer->parkinglot);
17534 ast_cli(fd, " Use Reason : %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[1], SIP_PAGE2_Q850_REASON)));
17535 ast_cli(fd, " Encryption : %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[1], SIP_PAGE2_USE_SRTP)));
17536 ast_cli(fd, "\n");
17537 peer = unref_peer(peer, "sip_show_peer: unref_peer: done with peer ptr");
17538 } else if (peer && type == 1) {
17539 char buffer[256];
17540 struct ast_str *mailbox_str = ast_str_alloca(512);
17541 astman_append(s, "Channeltype: SIP\r\n");
17542 astman_append(s, "ObjectName: %s\r\n", peer->name);
17543 astman_append(s, "ChanObjectType: peer\r\n");
17544 astman_append(s, "SecretExist: %s\r\n", ast_strlen_zero(peer->secret)?"N":"Y");
17545 astman_append(s, "RemoteSecretExist: %s\r\n", ast_strlen_zero(peer->remotesecret)?"N":"Y");
17546 astman_append(s, "MD5SecretExist: %s\r\n", ast_strlen_zero(peer->md5secret)?"N":"Y");
17547 astman_append(s, "Context: %s\r\n", peer->context);
17548 astman_append(s, "Language: %s\r\n", peer->language);
17549 if (!ast_strlen_zero(peer->accountcode))
17550 astman_append(s, "Accountcode: %s\r\n", peer->accountcode);
17551 astman_append(s, "AMAflags: %s\r\n", ast_cdr_flags2str(peer->amaflags));
17552 astman_append(s, "CID-CallingPres: %s\r\n", ast_describe_caller_presentation(peer->callingpres));
17553 if (!ast_strlen_zero(peer->fromuser))
17554 astman_append(s, "SIP-FromUser: %s\r\n", peer->fromuser);
17555 if (!ast_strlen_zero(peer->fromdomain))
17556 astman_append(s, "SIP-FromDomain: %s\r\nSip-FromDomain-Port: %d\r\n", peer->fromdomain, (peer->fromdomainport) ? peer->fromdomainport : STANDARD_SIP_PORT);
17557 astman_append(s, "Callgroup: ");
17558 astman_append(s, "%s\r\n", ast_print_group(buffer, sizeof(buffer), peer->callgroup));
17559 astman_append(s, "Pickupgroup: ");
17560 astman_append(s, "%s\r\n", ast_print_group(buffer, sizeof(buffer), peer->pickupgroup));
17561 astman_append(s, "MOHSuggest: %s\r\n", peer->mohsuggest);
17562 peer_mailboxes_to_str(&mailbox_str, peer);
17563 astman_append(s, "VoiceMailbox: %s\r\n", mailbox_str->str);
17564 astman_append(s, "TransferMode: %s\r\n", transfermode2str(peer->allowtransfer));
17565 astman_append(s, "LastMsgsSent: %d\r\n", peer->lastmsgssent);
17566 astman_append(s, "Maxforwards: %d\r\n", peer->maxforwards);
17567 astman_append(s, "Call-limit: %d\r\n", peer->call_limit);
17568 astman_append(s, "Busy-level: %d\r\n", peer->busy_level);
17569 astman_append(s, "MaxCallBR: %d kbps\r\n", peer->maxcallbitrate);
17570 astman_append(s, "Dynamic: %s\r\n", peer->host_dynamic?"Y":"N");
17571 astman_append(s, "Callerid: %s\r\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, ""));
17572 astman_append(s, "RegExpire: %ld seconds\r\n", ast_sched_when(sched, peer->expire));
17573 astman_append(s, "SIP-AuthInsecure: %s\r\n", insecure2str(ast_test_flag(&peer->flags[0], SIP_INSECURE)));
17574 astman_append(s, "SIP-Forcerport: %s\r\n", (ast_test_flag(&peer->flags[0], SIP_NAT_FORCE_RPORT)?"Y":"N"));
17575 astman_append(s, "ACL: %s\r\n", (peer->ha?"Y":"N"));
17576 astman_append(s, "SIP-CanReinvite: %s\r\n", (ast_test_flag(&peer->flags[0], SIP_DIRECT_MEDIA)?"Y":"N"));
17577 astman_append(s, "SIP-DirectMedia: %s\r\n", (ast_test_flag(&peer->flags[0], SIP_DIRECT_MEDIA)?"Y":"N"));
17578 astman_append(s, "SIP-PromiscRedir: %s\r\n", (ast_test_flag(&peer->flags[0], SIP_PROMISCREDIR)?"Y":"N"));
17579 astman_append(s, "SIP-UserPhone: %s\r\n", (ast_test_flag(&peer->flags[0], SIP_USEREQPHONE)?"Y":"N"));
17580 astman_append(s, "SIP-VideoSupport: %s\r\n", (ast_test_flag(&peer->flags[1], SIP_PAGE2_VIDEOSUPPORT)?"Y":"N"));
17581 astman_append(s, "SIP-TextSupport: %s\r\n", (ast_test_flag(&peer->flags[1], SIP_PAGE2_TEXTSUPPORT)?"Y":"N"));
17582 astman_append(s, "SIP-T.38Support: %s\r\n", (ast_test_flag(&peer->flags[1], SIP_PAGE2_T38SUPPORT)?"Y":"N"));
17583 astman_append(s, "SIP-T.38EC: %s\r\n", faxec2str(ast_test_flag(&peer->flags[1], SIP_PAGE2_T38SUPPORT)));
17584 astman_append(s, "SIP-T.38MaxDtgrm: %d\r\n", peer->t38_maxdatagram);
17585 astman_append(s, "SIP-Sess-Timers: %s\r\n", stmode2str(peer->stimer.st_mode_oper));
17586 astman_append(s, "SIP-Sess-Refresh: %s\r\n", strefresher2str(peer->stimer.st_ref));
17587 astman_append(s, "SIP-Sess-Expires: %d\r\n", peer->stimer.st_max_se);
17588 astman_append(s, "SIP-Sess-Min: %d\r\n", peer->stimer.st_min_se);
17589 astman_append(s, "SIP-RTP-Engine: %s\r\n", peer->engine);
17590 astman_append(s, "SIP-Encryption: %s\r\n", ast_test_flag(&peer->flags[1], SIP_PAGE2_USE_SRTP) ? "Y" : "N");
17591
17592
17593 astman_append(s, "SIP-DTMFmode: %s\r\n", dtmfmode2str(ast_test_flag(&peer->flags[0], SIP_DTMF)));
17594 astman_append(s, "ToHost: %s\r\n", peer->tohost);
17595 astman_append(s, "Address-IP: %s\r\nAddress-Port: %d\r\n", ast_sockaddr_stringify_addr(&peer->addr), ast_sockaddr_port(&peer->addr));
17596 astman_append(s, "Default-addr-IP: %s\r\nDefault-addr-port: %d\r\n", ast_sockaddr_stringify_addr(&peer->defaddr), ast_sockaddr_port(&peer->defaddr));
17597 astman_append(s, "Default-Username: %s\r\n", peer->username);
17598 if (!ast_strlen_zero(sip_cfg.regcontext))
17599 astman_append(s, "RegExtension: %s\r\n", peer->regexten);
17600 astman_append(s, "Codecs: ");
17601 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
17602 astman_append(s, "%s\r\n", codec_buf);
17603 astman_append(s, "CodecOrder: ");
17604 pref = &peer->prefs;
17605 for(x = 0; x < 64 ; x++) {
17606 codec = ast_codec_pref_index(pref, x);
17607 if (!codec)
17608 break;
17609 astman_append(s, "%s", ast_getformatname(codec));
17610 if (x < 63 && ast_codec_pref_index(pref, x+1))
17611 astman_append(s, ",");
17612 }
17613
17614 astman_append(s, "\r\n");
17615 astman_append(s, "Status: ");
17616 peer_status(peer, status, sizeof(status));
17617 astman_append(s, "%s\r\n", status);
17618 astman_append(s, "SIP-Useragent: %s\r\n", peer->useragent);
17619 astman_append(s, "Reg-Contact: %s\r\n", peer->fullcontact);
17620 astman_append(s, "QualifyFreq: %d ms\r\n", peer->qualifyfreq);
17621 astman_append(s, "Parkinglot: %s\r\n", peer->parkinglot);
17622 if (peer->chanvars) {
17623 for (v = peer->chanvars ; v ; v = v->next) {
17624 astman_append(s, "ChanVariable: %s=%s\r\n", v->name, v->value);
17625 }
17626 }
17627 astman_append(s, "SIP-Use-Reason-Header: %s\r\n", (ast_test_flag(&peer->flags[1], SIP_PAGE2_Q850_REASON)) ? "Y" : "N");
17628
17629 peer = unref_peer(peer, "sip_show_peer: unref_peer: done with peer");
17630
17631 } else {
17632 ast_cli(fd, "Peer %s not found.\n", argv[3]);
17633 ast_cli(fd, "\n");
17634 }
17635
17636 return CLI_SUCCESS;
17637 }
17638
17639
17640 static char *complete_sip_user(const char *word, int state)
17641 {
17642 char *result = NULL;
17643 int wordlen = strlen(word);
17644 int which = 0;
17645 struct ao2_iterator user_iter;
17646 struct sip_peer *user;
17647
17648 user_iter = ao2_iterator_init(peers, 0);
17649 while ((user = ao2_t_iterator_next(&user_iter, "iterate thru peers table"))) {
17650 ao2_lock(user);
17651 if (!(user->type & SIP_TYPE_USER)) {
17652 ao2_unlock(user);
17653 unref_peer(user, "complete sip user");
17654 continue;
17655 }
17656
17657 if (!strncasecmp(word, user->name, wordlen) && ++which > state) {
17658 result = ast_strdup(user->name);
17659 }
17660 ao2_unlock(user);
17661 unref_peer(user, "complete sip user");
17662 if (result) {
17663 break;
17664 }
17665 }
17666 ao2_iterator_destroy(&user_iter);
17667 return result;
17668 }
17669
17670 static char *complete_sip_show_user(const char *line, const char *word, int pos, int state)
17671 {
17672 if (pos == 3)
17673 return complete_sip_user(word, state);
17674
17675 return NULL;
17676 }
17677
17678
17679 static char *sip_show_user(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
17680 {
17681 char cbuf[256];
17682 struct sip_peer *user;
17683 struct ast_variable *v;
17684 int load_realtime;
17685
17686 switch (cmd) {
17687 case CLI_INIT:
17688 e->command = "sip show user";
17689 e->usage =
17690 "Usage: sip show user <name> [load]\n"
17691 " Shows all details on one SIP user and the current status.\n"
17692 " Option \"load\" forces lookup of peer in realtime storage.\n";
17693 return NULL;
17694 case CLI_GENERATE:
17695 return complete_sip_show_user(a->line, a->word, a->pos, a->n);
17696 }
17697
17698 if (a->argc < 4)
17699 return CLI_SHOWUSAGE;
17700
17701
17702 load_realtime = (a->argc == 5 && !strcmp(a->argv[4], "load")) ? TRUE : FALSE;
17703
17704 if ((user = find_peer(a->argv[3], NULL, load_realtime, FINDUSERS, FALSE, 0))) {
17705 ao2_lock(user);
17706 ast_cli(a->fd, "\n\n");
17707 ast_cli(a->fd, " * Name : %s\n", user->name);
17708 ast_cli(a->fd, " Secret : %s\n", ast_strlen_zero(user->secret)?"<Not set>":"<Set>");
17709 ast_cli(a->fd, " MD5Secret : %s\n", ast_strlen_zero(user->md5secret)?"<Not set>":"<Set>");
17710 ast_cli(a->fd, " Context : %s\n", user->context);
17711 ast_cli(a->fd, " Language : %s\n", user->language);
17712 if (!ast_strlen_zero(user->accountcode))
17713 ast_cli(a->fd, " Accountcode : %s\n", user->accountcode);
17714 ast_cli(a->fd, " AMA flags : %s\n", ast_cdr_flags2str(user->amaflags));
17715 ast_cli(a->fd, " Transfer mode: %s\n", transfermode2str(user->allowtransfer));
17716 ast_cli(a->fd, " MaxCallBR : %d kbps\n", user->maxcallbitrate);
17717 ast_cli(a->fd, " CallingPres : %s\n", ast_describe_caller_presentation(user->callingpres));
17718 ast_cli(a->fd, " Call limit : %d\n", user->call_limit);
17719 ast_cli(a->fd, " Callgroup : ");
17720 print_group(a->fd, user->callgroup, 0);
17721 ast_cli(a->fd, " Pickupgroup : ");
17722 print_group(a->fd, user->pickupgroup, 0);
17723 ast_cli(a->fd, " Callerid : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), user->cid_name, user->cid_num, "<unspecified>"));
17724 ast_cli(a->fd, " ACL : %s\n", AST_CLI_YESNO(user->ha != NULL));
17725 ast_cli(a->fd, " Sess-Timers : %s\n", stmode2str(user->stimer.st_mode_oper));
17726 ast_cli(a->fd, " Sess-Refresh : %s\n", strefresher2str(user->stimer.st_ref));
17727 ast_cli(a->fd, " Sess-Expires : %d secs\n", user->stimer.st_max_se);
17728 ast_cli(a->fd, " Sess-Min-SE : %d secs\n", user->stimer.st_min_se);
17729 ast_cli(a->fd, " RTP Engine : %s\n", user->engine);
17730
17731 ast_cli(a->fd, " Codec Order : (");
17732 print_codec_to_cli(a->fd, &user->prefs);
17733 ast_cli(a->fd, ")\n");
17734
17735 ast_cli(a->fd, " Auto-Framing: %s \n", AST_CLI_YESNO(user->autoframing));
17736 if (user->chanvars) {
17737 ast_cli(a->fd, " Variables :\n");
17738 for (v = user->chanvars ; v ; v = v->next)
17739 ast_cli(a->fd, " %s = %s\n", v->name, v->value);
17740 }
17741
17742 ast_cli(a->fd, "\n");
17743
17744 ao2_unlock(user);
17745 unref_peer(user, "sip show user");
17746 } else {
17747 ast_cli(a->fd, "User %s not found.\n", a->argv[3]);
17748 ast_cli(a->fd, "\n");
17749 }
17750
17751 return CLI_SUCCESS;
17752 }
17753
17754
17755 static char *sip_show_sched(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
17756 {
17757 struct ast_str *cbuf;
17758 struct ast_cb_names cbnames = {9, { "retrans_pkt",
17759 "__sip_autodestruct",
17760 "expire_register",
17761 "auto_congest",
17762 "sip_reg_timeout",
17763 "sip_poke_peer_s",
17764 "sip_poke_noanswer",
17765 "sip_reregister",
17766 "sip_reinvite_retry"},
17767 { retrans_pkt,
17768 __sip_autodestruct,
17769 expire_register,
17770 auto_congest,
17771 sip_reg_timeout,
17772 sip_poke_peer_s,
17773 sip_poke_noanswer,
17774 sip_reregister,
17775 sip_reinvite_retry}};
17776
17777 switch (cmd) {
17778 case CLI_INIT:
17779 e->command = "sip show sched";
17780 e->usage =
17781 "Usage: sip show sched\n"
17782 " Shows stats on what's in the sched queue at the moment\n";
17783 return NULL;
17784 case CLI_GENERATE:
17785 return NULL;
17786 }
17787
17788 cbuf = ast_str_alloca(2048);
17789
17790 ast_cli(a->fd, "\n");
17791 ast_sched_report(sched, &cbuf, &cbnames);
17792 ast_cli(a->fd, "%s", cbuf->str);
17793
17794 return CLI_SUCCESS;
17795 }
17796
17797
17798 static char *sip_show_registry(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
17799 {
17800 #define FORMAT2 "%-39.39s %-6.6s %-12.12s %8.8s %-20.20s %-25.25s\n"
17801 #define FORMAT "%-39.39s %-6.6s %-12.12s %8d %-20.20s %-25.25s\n"
17802 char host[80];
17803 char user[80];
17804 char tmpdat[256];
17805 struct ast_tm tm;
17806 int counter = 0;
17807
17808 switch (cmd) {
17809 case CLI_INIT:
17810 e->command = "sip show registry";
17811 e->usage =
17812 "Usage: sip show registry\n"
17813 " Lists all registration requests and status.\n";
17814 return NULL;
17815 case CLI_GENERATE:
17816 return NULL;
17817 }
17818
17819 if (a->argc != 3)
17820 return CLI_SHOWUSAGE;
17821 ast_cli(a->fd, FORMAT2, "Host", "dnsmgr", "Username", "Refresh", "State", "Reg.Time");
17822
17823 ASTOBJ_CONTAINER_TRAVERSE(®l, 1, do {
17824 ASTOBJ_RDLOCK(iterator);
17825 snprintf(host, sizeof(host), "%s:%d", iterator->hostname, iterator->portno ? iterator->portno : STANDARD_SIP_PORT);
17826 snprintf(user, sizeof(user), "%s", iterator->username);
17827 if (!ast_strlen_zero(iterator->regdomain)) {
17828 snprintf(tmpdat, sizeof(tmpdat), "%s", user);
17829 snprintf(user, sizeof(user), "%s@%s", tmpdat, iterator->regdomain);}
17830 if (iterator->regdomainport) {
17831 snprintf(tmpdat, sizeof(tmpdat), "%s", user);
17832 snprintf(user, sizeof(user), "%s:%d", tmpdat, iterator->regdomainport);}
17833 if (iterator->regtime.tv_sec) {
17834 ast_localtime(&iterator->regtime, &tm, NULL);
17835 ast_strftime(tmpdat, sizeof(tmpdat), "%a, %d %b %Y %T", &tm);
17836 } else
17837 tmpdat[0] = '\0';
17838 ast_cli(a->fd, FORMAT, host, (iterator->dnsmgr) ? "Y" : "N", user, iterator->refresh, regstate2str(iterator->regstate), tmpdat);
17839 ASTOBJ_UNLOCK(iterator);
17840 counter++;
17841 } while(0));
17842 ast_cli(a->fd, "%d SIP registrations.\n", counter);
17843 return CLI_SUCCESS;
17844 #undef FORMAT
17845 #undef FORMAT2
17846 }
17847
17848
17849
17850
17851
17852 static char *sip_unregister(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
17853 {
17854 struct sip_peer *peer;
17855 int load_realtime = 0;
17856
17857 switch (cmd) {
17858 case CLI_INIT:
17859 e->command = "sip unregister";
17860 e->usage =
17861 "Usage: sip unregister <peer>\n"
17862 " Unregister (force expiration) a SIP peer from the registry\n";
17863 return NULL;
17864 case CLI_GENERATE:
17865 return complete_sip_unregister(a->line, a->word, a->pos, a->n);
17866 }
17867
17868 if (a->argc != 3)
17869 return CLI_SHOWUSAGE;
17870
17871 if ((peer = find_peer(a->argv[2], NULL, load_realtime, FINDPEERS, TRUE, 0))) {
17872 if (peer->expire > 0) {
17873 AST_SCHED_DEL_UNREF(sched, peer->expire,
17874 unref_peer(peer, "remove register expire ref"));
17875 expire_register(ref_peer(peer, "ref for expire_register"));
17876 ast_cli(a->fd, "Unregistered peer \'%s\'\n\n", a->argv[2]);
17877 } else {
17878 ast_cli(a->fd, "Peer %s not registered\n", a->argv[2]);
17879 }
17880 unref_peer(peer, "sip_unregister: unref_peer via sip_unregister: done with peer from find_peer call");
17881 } else {
17882 ast_cli(a->fd, "Peer unknown: \'%s\'. Not unregistered.\n", a->argv[2]);
17883 }
17884
17885 return CLI_SUCCESS;
17886 }
17887
17888
17889 static int show_chanstats_cb(void *__cur, void *__arg, int flags)
17890 {
17891 #define FORMAT2 "%-15.15s %-11.11s %-8.8s %-10.10s %-10.10s ( %%) %-6.6s %-10.10s %-10.10s ( %%) %-6.6s\n"
17892 #define FORMAT "%-15.15s %-11.11s %-8.8s %-10.10u%-1.1s %-10.10u (%5.2f%%) %-6.4lf %-10.10u%-1.1s %-10.10u (%5.2f%%) %-6.4lf\n"
17893 struct sip_pvt *cur = __cur;
17894 struct ast_rtp_instance_stats stats;
17895 char durbuf[10];
17896 int duration;
17897 int durh, durm, durs;
17898 struct ast_channel *c = cur->owner;
17899 struct __show_chan_arg *arg = __arg;
17900 int fd = arg->fd;
17901
17902
17903 if (cur->subscribed != NONE)
17904 return 0;
17905
17906 if (!cur->rtp) {
17907 if (sipdebug) {
17908 ast_cli(fd, "%-15.15s %-11.11s (inv state: %s) -- %s\n",
17909 ast_sockaddr_stringify_addr(&cur->sa), cur->callid,
17910 invitestate2string[cur->invitestate].desc,
17911 "-- No RTP active");
17912 }
17913 return 0;
17914 }
17915
17916 ast_rtp_instance_get_stats(cur->rtp, &stats, AST_RTP_INSTANCE_STAT_ALL);
17917
17918 if (c && c->cdr && !ast_tvzero(c->cdr->start)) {
17919 duration = (int)(ast_tvdiff_ms(ast_tvnow(), c->cdr->start) / 1000);
17920 durh = duration / 3600;
17921 durm = (duration % 3600) / 60;
17922 durs = duration % 60;
17923 snprintf(durbuf, sizeof(durbuf), "%02d:%02d:%02d", durh, durm, durs);
17924 } else {
17925 durbuf[0] = '\0';
17926 }
17927
17928 ast_cli(fd, FORMAT,
17929 ast_sockaddr_stringify_addr(&cur->sa),
17930 cur->callid,
17931 durbuf,
17932 stats.rxcount > (unsigned int) 100000 ? (unsigned int) (stats.rxcount)/(unsigned int) 1000 : stats.rxcount,
17933 stats.rxcount > (unsigned int) 100000 ? "K":" ",
17934 stats.rxploss,
17935 (stats.rxcount + stats.rxploss) > 0 ? (double) stats.rxploss / (stats.rxcount + stats.rxploss) * 100 : 0,
17936 stats.rxjitter,
17937 stats.txcount > (unsigned int) 100000 ? (unsigned int) (stats.txcount)/(unsigned int) 1000 : stats.txcount,
17938 stats.txcount > (unsigned int) 100000 ? "K":" ",
17939 stats.txploss,
17940 stats.txcount > 0 ? (double) stats.txploss / stats.txcount * 100 : 0,
17941 stats.txjitter
17942 );
17943 arg->numchans++;
17944
17945 return 0;
17946 }
17947
17948
17949 static char *sip_show_channelstats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
17950 {
17951 struct __show_chan_arg arg = { .fd = a->fd, .numchans = 0 };
17952
17953 switch (cmd) {
17954 case CLI_INIT:
17955 e->command = "sip show channelstats";
17956 e->usage =
17957 "Usage: sip show channelstats\n"
17958 " Lists all currently active SIP channel's RTCP statistics.\n"
17959 " Note that calls in the much optimized RTP P2P bridge mode will not show any packets here.";
17960 return NULL;
17961 case CLI_GENERATE:
17962 return NULL;
17963 }
17964
17965 if (a->argc != 3)
17966 return CLI_SHOWUSAGE;
17967
17968 ast_cli(a->fd, FORMAT2, "Peer", "Call ID", "Duration", "Recv: Pack", "Lost", "Jitter", "Send: Pack", "Lost", "Jitter");
17969
17970 ao2_t_callback(dialogs, OBJ_NODATA, show_chanstats_cb, &arg, "callback to sip show chanstats");
17971 ast_cli(a->fd, "%d active SIP channel%s\n", arg.numchans, (arg.numchans != 1) ? "s" : "");
17972 return CLI_SUCCESS;
17973 }
17974 #undef FORMAT
17975 #undef FORMAT2
17976
17977
17978 static char *sip_show_settings(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
17979 {
17980 int realtimepeers;
17981 int realtimeregs;
17982 char codec_buf[SIPBUFSIZE];
17983 const char *msg;
17984 struct sip_auth_container *credentials;
17985
17986 switch (cmd) {
17987 case CLI_INIT:
17988 e->command = "sip show settings";
17989 e->usage =
17990 "Usage: sip show settings\n"
17991 " Provides detailed list of the configuration of the SIP channel.\n";
17992 return NULL;
17993 case CLI_GENERATE:
17994 return NULL;
17995 }
17996
17997 if (a->argc != 3)
17998 return CLI_SHOWUSAGE;
17999
18000 realtimepeers = ast_check_realtime("sippeers");
18001 realtimeregs = ast_check_realtime("sipregs");
18002
18003 ast_mutex_lock(&authl_lock);
18004 credentials = authl;
18005 if (credentials) {
18006 ao2_t_ref(credentials, +1, "Ref global auth for show");
18007 }
18008 ast_mutex_unlock(&authl_lock);
18009
18010 ast_cli(a->fd, "\n\nGlobal Settings:\n");
18011 ast_cli(a->fd, "----------------\n");
18012 ast_cli(a->fd, " UDP Bindaddress: %s\n", ast_sockaddr_stringify(&bindaddr));
18013 if (ast_sockaddr_is_ipv6(&bindaddr) && ast_sockaddr_is_any(&bindaddr)) {
18014 ast_cli(a->fd, " ** Additional Info:\n");
18015 ast_cli(a->fd, " [::] may include IPv4 in addition to IPv6, if such a feature is enabled in the OS.\n");
18016 }
18017 ast_cli(a->fd, " TCP SIP Bindaddress: %s\n",
18018 sip_cfg.tcp_enabled != FALSE ?
18019 ast_sockaddr_stringify(&sip_tcp_desc.local_address) :
18020 "Disabled");
18021 ast_cli(a->fd, " TLS SIP Bindaddress: %s\n",
18022 default_tls_cfg.enabled != FALSE ?
18023 ast_sockaddr_stringify(&sip_tls_desc.local_address) :
18024 "Disabled");
18025 ast_cli(a->fd, " Videosupport: %s\n", AST_CLI_YESNO(ast_test_flag(&global_flags[1], SIP_PAGE2_VIDEOSUPPORT)));
18026 ast_cli(a->fd, " Textsupport: %s\n", AST_CLI_YESNO(ast_test_flag(&global_flags[1], SIP_PAGE2_TEXTSUPPORT)));
18027 ast_cli(a->fd, " Ignore SDP sess. ver.: %s\n", AST_CLI_YESNO(ast_test_flag(&global_flags[1], SIP_PAGE2_IGNORESDPVERSION)));
18028 ast_cli(a->fd, " AutoCreate Peer: %s\n", AST_CLI_YESNO(sip_cfg.autocreatepeer));
18029 ast_cli(a->fd, " Match Auth Username: %s\n", AST_CLI_YESNO(global_match_auth_username));
18030 ast_cli(a->fd, " Allow unknown access: %s\n", AST_CLI_YESNO(sip_cfg.allowguest));
18031 ast_cli(a->fd, " Allow subscriptions: %s\n", AST_CLI_YESNO(ast_test_flag(&global_flags[1], SIP_PAGE2_ALLOWSUBSCRIBE)));
18032 ast_cli(a->fd, " Allow overlap dialing: %s\n", allowoverlap2str(ast_test_flag(&global_flags[1], SIP_PAGE2_ALLOWOVERLAP)));
18033 ast_cli(a->fd, " Allow promisc. redir: %s\n", AST_CLI_YESNO(ast_test_flag(&global_flags[0], SIP_PROMISCREDIR)));
18034 ast_cli(a->fd, " Enable call counters: %s\n", AST_CLI_YESNO(global_callcounter));
18035 ast_cli(a->fd, " SIP domain support: %s\n", AST_CLI_YESNO(!AST_LIST_EMPTY(&domain_list)));
18036 ast_cli(a->fd, " Realm. auth: %s\n", AST_CLI_YESNO(credentials != NULL));
18037 if (credentials) {
18038 struct sip_auth *auth;
18039
18040 AST_LIST_TRAVERSE(&credentials->list, auth, node) {
18041 ast_cli(a->fd, " Realm. auth entry: Realm %-15.15s User %-10.20s %s\n",
18042 auth->realm,
18043 auth->username,
18044 !ast_strlen_zero(auth->secret)
18045 ? "<Secret set>"
18046 : (!ast_strlen_zero(auth->md5secret)
18047 ? "<MD5secret set>" : "<Not set>"));
18048 }
18049 ao2_t_ref(credentials, -1, "Unref global auth for show");
18050 }
18051 ast_cli(a->fd, " Our auth realm %s\n", sip_cfg.realm);
18052 ast_cli(a->fd, " Use domains as realms: %s\n", AST_CLI_YESNO(sip_cfg.domainsasrealm));
18053 ast_cli(a->fd, " Call to non-local dom.: %s\n", AST_CLI_YESNO(sip_cfg.allow_external_domains));
18054 ast_cli(a->fd, " URI user is phone no: %s\n", AST_CLI_YESNO(ast_test_flag(&global_flags[0], SIP_USEREQPHONE)));
18055 ast_cli(a->fd, " Always auth rejects: %s\n", AST_CLI_YESNO(sip_cfg.alwaysauthreject));
18056 ast_cli(a->fd, " Direct RTP setup: %s\n", AST_CLI_YESNO(sip_cfg.directrtpsetup));
18057 ast_cli(a->fd, " User Agent: %s\n", global_useragent);
18058 ast_cli(a->fd, " SDP Session Name: %s\n", ast_strlen_zero(global_sdpsession) ? "-" : global_sdpsession);
18059 ast_cli(a->fd, " SDP Owner Name: %s\n", ast_strlen_zero(global_sdpowner) ? "-" : global_sdpowner);
18060 ast_cli(a->fd, " Reg. context: %s\n", S_OR(sip_cfg.regcontext, "(not set)"));
18061 ast_cli(a->fd, " Regexten on Qualify: %s\n", AST_CLI_YESNO(sip_cfg.regextenonqualify));
18062 ast_cli(a->fd, " Legacy userfield parse: %s\n", AST_CLI_YESNO(sip_cfg.legacy_useroption_parsing));
18063 ast_cli(a->fd, " Caller ID: %s\n", default_callerid);
18064 if ((default_fromdomainport) && (default_fromdomainport != STANDARD_SIP_PORT)) {
18065 ast_cli(a->fd, " From: Domain: %s:%d\n", default_fromdomain, default_fromdomainport);
18066 } else {
18067 ast_cli(a->fd, " From: Domain: %s\n", default_fromdomain);
18068 }
18069 ast_cli(a->fd, " Record SIP history: %s\n", AST_CLI_ONOFF(recordhistory));
18070 ast_cli(a->fd, " Call Events: %s\n", AST_CLI_ONOFF(sip_cfg.callevents));
18071 ast_cli(a->fd, " Auth. Failure Events: %s\n", AST_CLI_ONOFF(global_authfailureevents));
18072
18073 ast_cli(a->fd, " T.38 support: %s\n", AST_CLI_YESNO(ast_test_flag(&global_flags[1], SIP_PAGE2_T38SUPPORT)));
18074 ast_cli(a->fd, " T.38 EC mode: %s\n", faxec2str(ast_test_flag(&global_flags[1], SIP_PAGE2_T38SUPPORT)));
18075 ast_cli(a->fd, " T.38 MaxDtgrm: %d\n", global_t38_maxdatagram);
18076 if (!realtimepeers && !realtimeregs)
18077 ast_cli(a->fd, " SIP realtime: Disabled\n" );
18078 else
18079 ast_cli(a->fd, " SIP realtime: Enabled\n" );
18080 ast_cli(a->fd, " Qualify Freq : %d ms\n", global_qualifyfreq);
18081 ast_cli(a->fd, " Q.850 Reason header: %s\n", AST_CLI_YESNO(ast_test_flag(&global_flags[1], SIP_PAGE2_Q850_REASON)));
18082 ast_cli(a->fd, " Store SIP_CAUSE: %s\n", AST_CLI_YESNO(global_store_sip_cause));
18083 ast_cli(a->fd, "\nNetwork QoS Settings:\n");
18084 ast_cli(a->fd, "---------------------------\n");
18085 ast_cli(a->fd, " IP ToS SIP: %s\n", ast_tos2str(global_tos_sip));
18086 ast_cli(a->fd, " IP ToS RTP audio: %s\n", ast_tos2str(global_tos_audio));
18087 ast_cli(a->fd, " IP ToS RTP video: %s\n", ast_tos2str(global_tos_video));
18088 ast_cli(a->fd, " IP ToS RTP text: %s\n", ast_tos2str(global_tos_text));
18089 ast_cli(a->fd, " 802.1p CoS SIP: %d\n", global_cos_sip);
18090 ast_cli(a->fd, " 802.1p CoS RTP audio: %d\n", global_cos_audio);
18091 ast_cli(a->fd, " 802.1p CoS RTP video: %d\n", global_cos_video);
18092 ast_cli(a->fd, " 802.1p CoS RTP text: %d\n", global_cos_text);
18093 ast_cli(a->fd, " Jitterbuffer enabled: %s\n", AST_CLI_YESNO(ast_test_flag(&global_jbconf, AST_JB_ENABLED)));
18094 if (ast_test_flag(&global_jbconf, AST_JB_ENABLED)) {
18095 ast_cli(a->fd, " Jitterbuffer forced: %s\n", AST_CLI_YESNO(ast_test_flag(&global_jbconf, AST_JB_FORCED)));
18096 ast_cli(a->fd, " Jitterbuffer max size: %ld\n", global_jbconf.max_size);
18097 ast_cli(a->fd, " Jitterbuffer resync: %ld\n", global_jbconf.resync_threshold);
18098 ast_cli(a->fd, " Jitterbuffer impl: %s\n", global_jbconf.impl);
18099 if (!strcasecmp(global_jbconf.impl, "adaptive")) {
18100 ast_cli(a->fd, " Jitterbuffer tgt extra: %ld\n", global_jbconf.target_extra);
18101 }
18102 ast_cli(a->fd, " Jitterbuffer log: %s\n", AST_CLI_YESNO(ast_test_flag(&global_jbconf, AST_JB_LOG)));
18103 }
18104
18105 ast_cli(a->fd, "\nNetwork Settings:\n");
18106 ast_cli(a->fd, "---------------------------\n");
18107
18108 if (localaddr == NULL)
18109 msg = "Disabled, no localnet list";
18110 else if (ast_sockaddr_isnull(&externaddr))
18111 msg = "Disabled";
18112 else if (!ast_strlen_zero(externhost))
18113 msg = "Enabled using externhost";
18114 else
18115 msg = "Enabled using externaddr";
18116 ast_cli(a->fd, " SIP address remapping: %s\n", msg);
18117 ast_cli(a->fd, " Externhost: %s\n", S_OR(externhost, "<none>"));
18118 ast_cli(a->fd, " Externaddr: %s\n", ast_sockaddr_stringify(&externaddr));
18119 ast_cli(a->fd, " Externrefresh: %d\n", externrefresh);
18120 {
18121 struct ast_ha *d;
18122 const char *prefix = "Localnet:";
18123
18124 for (d = localaddr; d ; prefix = "", d = d->next) {
18125 const char *addr = ast_strdupa(ast_sockaddr_stringify_addr(&d->addr));
18126 const char *mask = ast_strdupa(ast_sockaddr_stringify_addr(&d->netmask));
18127 ast_cli(a->fd, " %-24s%s/%s\n", prefix, addr, mask);
18128 }
18129 }
18130 ast_cli(a->fd, "\nGlobal Signalling Settings:\n");
18131 ast_cli(a->fd, "---------------------------\n");
18132 ast_cli(a->fd, " Codecs: ");
18133 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, sip_cfg.capability);
18134 ast_cli(a->fd, "%s\n", codec_buf);
18135 ast_cli(a->fd, " Codec Order: ");
18136 print_codec_to_cli(a->fd, &default_prefs);
18137 ast_cli(a->fd, "\n");
18138 ast_cli(a->fd, " Relax DTMF: %s\n", AST_CLI_YESNO(global_relaxdtmf));
18139 ast_cli(a->fd, " RFC2833 Compensation: %s\n", AST_CLI_YESNO(ast_test_flag(&global_flags[1], SIP_PAGE2_RFC2833_COMPENSATE)));
18140 ast_cli(a->fd, " Symmetric RTP: %s\n", AST_CLI_YESNO(ast_test_flag(&global_flags[1], SIP_PAGE2_SYMMETRICRTP)));
18141 ast_cli(a->fd, " Compact SIP headers: %s\n", AST_CLI_YESNO(sip_cfg.compactheaders));
18142 ast_cli(a->fd, " RTP Keepalive: %d %s\n", global_rtpkeepalive, global_rtpkeepalive ? "" : "(Disabled)" );
18143 ast_cli(a->fd, " RTP Timeout: %d %s\n", global_rtptimeout, global_rtptimeout ? "" : "(Disabled)" );
18144 ast_cli(a->fd, " RTP Hold Timeout: %d %s\n", global_rtpholdtimeout, global_rtpholdtimeout ? "" : "(Disabled)");
18145 ast_cli(a->fd, " MWI NOTIFY mime type: %s\n", default_notifymime);
18146 ast_cli(a->fd, " DNS SRV lookup: %s\n", AST_CLI_YESNO(sip_cfg.srvlookup));
18147 ast_cli(a->fd, " Pedantic SIP support: %s\n", AST_CLI_YESNO(sip_cfg.pedanticsipchecking));
18148 ast_cli(a->fd, " Reg. min duration %d secs\n", min_expiry);
18149 ast_cli(a->fd, " Reg. max duration: %d secs\n", max_expiry);
18150 ast_cli(a->fd, " Reg. default duration: %d secs\n", default_expiry);
18151 ast_cli(a->fd, " Outbound reg. timeout: %d secs\n", global_reg_timeout);
18152 ast_cli(a->fd, " Outbound reg. attempts: %d\n", global_regattempts_max);
18153 ast_cli(a->fd, " Notify ringing state: %s\n", AST_CLI_YESNO(sip_cfg.notifyringing));
18154 if (sip_cfg.notifyringing) {
18155 ast_cli(a->fd, " Include CID: %s%s\n",
18156 AST_CLI_YESNO(sip_cfg.notifycid),
18157 sip_cfg.notifycid == IGNORE_CONTEXT ? " (Ignoring context)" : "");
18158 }
18159 ast_cli(a->fd, " Notify hold state: %s\n", AST_CLI_YESNO(sip_cfg.notifyhold));
18160 ast_cli(a->fd, " SIP Transfer mode: %s\n", transfermode2str(sip_cfg.allowtransfer));
18161 ast_cli(a->fd, " Max Call Bitrate: %d kbps\n", default_maxcallbitrate);
18162 ast_cli(a->fd, " Auto-Framing: %s\n", AST_CLI_YESNO(global_autoframing));
18163 ast_cli(a->fd, " Outb. proxy: %s %s\n", ast_strlen_zero(sip_cfg.outboundproxy.name) ? "<not set>" : sip_cfg.outboundproxy.name,
18164 sip_cfg.outboundproxy.force ? "(forced)" : "");
18165 ast_cli(a->fd, " Session Timers: %s\n", stmode2str(global_st_mode));
18166 ast_cli(a->fd, " Session Refresher: %s\n", strefresher2str (global_st_refresher));
18167 ast_cli(a->fd, " Session Expires: %d secs\n", global_max_se);
18168 ast_cli(a->fd, " Session Min-SE: %d secs\n", global_min_se);
18169 ast_cli(a->fd, " Timer T1: %d\n", global_t1);
18170 ast_cli(a->fd, " Timer T1 minimum: %d\n", global_t1min);
18171 ast_cli(a->fd, " Timer B: %d\n", global_timer_b);
18172 ast_cli(a->fd, " No premature media: %s\n", AST_CLI_YESNO(global_prematuremediafilter));
18173 ast_cli(a->fd, " Max forwards: %d\n", sip_cfg.default_max_forwards);
18174
18175 ast_cli(a->fd, "\nDefault Settings:\n");
18176 ast_cli(a->fd, "-----------------\n");
18177 ast_cli(a->fd, " Allowed transports: %s\n", get_transport_list(default_transports));
18178 ast_cli(a->fd, " Outbound transport: %s\n", get_transport(default_primary_transport));
18179 ast_cli(a->fd, " Context: %s\n", sip_cfg.default_context);
18180 ast_cli(a->fd, " Force rport: %s\n", AST_CLI_YESNO(ast_test_flag(&global_flags[0], SIP_NAT_FORCE_RPORT)));
18181 ast_cli(a->fd, " DTMF: %s\n", dtmfmode2str(ast_test_flag(&global_flags[0], SIP_DTMF)));
18182 ast_cli(a->fd, " Qualify: %d\n", default_qualify);
18183 ast_cli(a->fd, " Use ClientCode: %s\n", AST_CLI_YESNO(ast_test_flag(&global_flags[0], SIP_USECLIENTCODE)));
18184 ast_cli(a->fd, " Progress inband: %s\n", (ast_test_flag(&global_flags[0], SIP_PROG_INBAND) == SIP_PROG_INBAND_NEVER) ? "Never" : (AST_CLI_YESNO(ast_test_flag(&global_flags[0], SIP_PROG_INBAND) != SIP_PROG_INBAND_NO)));
18185 ast_cli(a->fd, " Language: %s\n", default_language);
18186 ast_cli(a->fd, " MOH Interpret: %s\n", default_mohinterpret);
18187 ast_cli(a->fd, " MOH Suggest: %s\n", default_mohsuggest);
18188 ast_cli(a->fd, " Voice Mail Extension: %s\n", default_vmexten);
18189
18190
18191 if (realtimepeers || realtimeregs) {
18192 ast_cli(a->fd, "\nRealtime SIP Settings:\n");
18193 ast_cli(a->fd, "----------------------\n");
18194 ast_cli(a->fd, " Realtime Peers: %s\n", AST_CLI_YESNO(realtimepeers));
18195 ast_cli(a->fd, " Realtime Regs: %s\n", AST_CLI_YESNO(realtimeregs));
18196 ast_cli(a->fd, " Cache Friends: %s\n", AST_CLI_YESNO(ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS)));
18197 ast_cli(a->fd, " Update: %s\n", AST_CLI_YESNO(sip_cfg.peer_rtupdate));
18198 ast_cli(a->fd, " Ignore Reg. Expire: %s\n", AST_CLI_YESNO(sip_cfg.ignore_regexpire));
18199 ast_cli(a->fd, " Save sys. name: %s\n", AST_CLI_YESNO(sip_cfg.rtsave_sysname));
18200 ast_cli(a->fd, " Auto Clear: %d (%s)\n", sip_cfg.rtautoclear, ast_test_flag(&global_flags[1], SIP_PAGE2_RTAUTOCLEAR) ? "Enabled" : "Disabled");
18201 }
18202 ast_cli(a->fd, "\n----\n");
18203 return CLI_SUCCESS;
18204 }
18205
18206 static char *sip_show_mwi(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
18207 {
18208 #define FORMAT "%-30.30s %-12.12s %-10.10s %-10.10s\n"
18209 char host[80];
18210
18211 switch (cmd) {
18212 case CLI_INIT:
18213 e->command = "sip show mwi";
18214 e->usage =
18215 "Usage: sip show mwi\n"
18216 " Provides a list of MWI subscriptions and status.\n";
18217 return NULL;
18218 case CLI_GENERATE:
18219 return NULL;
18220 }
18221
18222 ast_cli(a->fd, FORMAT, "Host", "Username", "Mailbox", "Subscribed");
18223
18224 ASTOBJ_CONTAINER_TRAVERSE(&submwil, 1, do {
18225 ASTOBJ_RDLOCK(iterator);
18226 snprintf(host, sizeof(host), "%s:%d", iterator->hostname, iterator->portno ? iterator->portno : STANDARD_SIP_PORT);
18227 ast_cli(a->fd, FORMAT, host, iterator->username, iterator->mailbox, AST_CLI_YESNO(iterator->subscribed));
18228 ASTOBJ_UNLOCK(iterator);
18229 } while(0));
18230
18231 return CLI_SUCCESS;
18232 #undef FORMAT
18233 }
18234
18235
18236
18237 static const char *subscription_type2str(enum subscriptiontype subtype)
18238 {
18239 int i;
18240
18241 for (i = 1; i < ARRAY_LEN(subscription_types); i++) {
18242 if (subscription_types[i].type == subtype) {
18243 return subscription_types[i].text;
18244 }
18245 }
18246 return subscription_types[0].text;
18247 }
18248
18249
18250 static const struct cfsubscription_types *find_subscription_type(enum subscriptiontype subtype)
18251 {
18252 int i;
18253
18254 for (i = 1; i < ARRAY_LEN(subscription_types); i++) {
18255 if (subscription_types[i].type == subtype) {
18256 return &subscription_types[i];
18257 }
18258 }
18259 return &subscription_types[0];
18260 }
18261
18262
18263
18264
18265
18266
18267
18268
18269 #define FORMAT4 "%-15.15s %-15.15s %-15.15s %-15.15s %-13.13s %-15.15s %-10.10s %-6.6d\n"
18270 #define FORMAT3 "%-15.15s %-15.15s %-15.15s %-15.15s %-13.13s %-15.15s %-10.10s %-6.6s\n"
18271 #define FORMAT2 "%-15.15s %-15.15s %-15.15s %-15.15s %-7.7s %-15.15s %-10.10s %-10.10s\n"
18272 #define FORMAT "%-15.15s %-15.15s %-15.15s %-15.15s %-3.3s %-3.3s %-15.15s %-10.10s %-10.10s\n"
18273
18274
18275 static int show_channels_cb(void *__cur, void *__arg, int flags)
18276 {
18277 struct sip_pvt *cur = __cur;
18278 struct __show_chan_arg *arg = __arg;
18279 const struct ast_sockaddr *dst = sip_real_dst(cur);
18280
18281
18282 if (cur->subscribed == NONE && !arg->subscriptions) {
18283
18284 const char *referstatus = cur->refer ? referstatus2str(cur->refer->status) : "";
18285 char formatbuf[SIPBUFSIZE/2];
18286
18287 ast_cli(arg->fd, FORMAT, ast_sockaddr_stringify_addr(dst),
18288 S_OR(cur->username, S_OR(cur->cid_num, "(None)")),
18289 cur->callid,
18290 ast_getformatname_multiple(formatbuf, sizeof(formatbuf), cur->owner ? cur->owner->nativeformats : 0),
18291 AST_CLI_YESNO(ast_test_flag(&cur->flags[1], SIP_PAGE2_CALL_ONHOLD)),
18292 cur->needdestroy ? "(d)" : "",
18293 cur->lastmsg ,
18294 referstatus,
18295 cur->relatedpeer ? cur->relatedpeer->name : "<guest>"
18296 );
18297 arg->numchans++;
18298 }
18299 if (cur->subscribed != NONE && arg->subscriptions) {
18300 struct ast_str *mailbox_str = ast_str_alloca(512);
18301 if (cur->subscribed == MWI_NOTIFICATION && cur->relatedpeer)
18302 peer_mailboxes_to_str(&mailbox_str, cur->relatedpeer);
18303 ast_cli(arg->fd, FORMAT4, ast_sockaddr_stringify_addr(dst),
18304 S_OR(cur->username, S_OR(cur->cid_num, "(None)")),
18305 cur->callid,
18306
18307 cur->subscribed == MWI_NOTIFICATION ? "--" : cur->subscribeuri,
18308 cur->subscribed == MWI_NOTIFICATION ? "<none>" : ast_extension_state2str(cur->laststate),
18309 subscription_type2str(cur->subscribed),
18310 cur->subscribed == MWI_NOTIFICATION ? S_OR(mailbox_str->str, "<none>") : "<none>",
18311 cur->expiry
18312 );
18313 arg->numchans++;
18314 }
18315 return 0;
18316 }
18317
18318
18319
18320
18321
18322
18323 static char *sip_show_channels(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
18324 {
18325 struct __show_chan_arg arg = { .fd = a->fd, .numchans = 0 };
18326
18327
18328 if (cmd == CLI_INIT) {
18329 e->command = "sip show {channels|subscriptions}";
18330 e->usage =
18331 "Usage: sip show channels\n"
18332 " Lists all currently active SIP calls (dialogs).\n"
18333 "Usage: sip show subscriptions\n"
18334 " Lists active SIP subscriptions.\n";
18335 return NULL;
18336 } else if (cmd == CLI_GENERATE)
18337 return NULL;
18338
18339 if (a->argc != e->args)
18340 return CLI_SHOWUSAGE;
18341 arg.subscriptions = !strcasecmp(a->argv[e->args - 1], "subscriptions");
18342 if (!arg.subscriptions)
18343 ast_cli(arg.fd, FORMAT2, "Peer", "User/ANR", "Call ID", "Format", "Hold", "Last Message", "Expiry", "Peer");
18344 else
18345 ast_cli(arg.fd, FORMAT3, "Peer", "User", "Call ID", "Extension", "Last state", "Type", "Mailbox", "Expiry");
18346
18347
18348 ao2_t_callback(dialogs, OBJ_NODATA, show_channels_cb, &arg, "callback to show channels");
18349
18350
18351 ast_cli(arg.fd, "%d active SIP %s%s\n", arg.numchans,
18352 (arg.subscriptions ? "subscription" : "dialog"),
18353 ESS(arg.numchans));
18354 return CLI_SUCCESS;
18355 #undef FORMAT
18356 #undef FORMAT2
18357 #undef FORMAT3
18358 }
18359
18360
18361
18362
18363
18364
18365 static char *complete_sipch(const char *line, const char *word, int pos, int state)
18366 {
18367 int which=0;
18368 struct sip_pvt *cur;
18369 char *c = NULL;
18370 int wordlen = strlen(word);
18371 struct ao2_iterator i;
18372
18373 if (pos != 3) {
18374 return NULL;
18375 }
18376
18377 i = ao2_iterator_init(dialogs, 0);
18378 while ((cur = ao2_t_iterator_next(&i, "iterate thru dialogs"))) {
18379 sip_pvt_lock(cur);
18380 if (!strncasecmp(word, cur->callid, wordlen) && ++which > state) {
18381 c = ast_strdup(cur->callid);
18382 sip_pvt_unlock(cur);
18383 dialog_unref(cur, "drop ref in iterator loop break");
18384 break;
18385 }
18386 sip_pvt_unlock(cur);
18387 dialog_unref(cur, "drop ref in iterator loop");
18388 }
18389 ao2_iterator_destroy(&i);
18390 return c;
18391 }
18392
18393
18394
18395 static char *complete_sip_peer(const char *word, int state, int flags2)
18396 {
18397 char *result = NULL;
18398 int wordlen = strlen(word);
18399 int which = 0;
18400 struct ao2_iterator i = ao2_iterator_init(peers, 0);
18401 struct sip_peer *peer;
18402
18403 while ((peer = ao2_t_iterator_next(&i, "iterate thru peers table"))) {
18404
18405 if (!strncasecmp(word, peer->name, wordlen) &&
18406 (!flags2 || ast_test_flag(&peer->flags[1], flags2)) &&
18407 ++which > state)
18408 result = ast_strdup(peer->name);
18409 unref_peer(peer, "toss iterator peer ptr before break");
18410 if (result) {
18411 break;
18412 }
18413 }
18414 ao2_iterator_destroy(&i);
18415 return result;
18416 }
18417
18418
18419 static char *complete_sip_registered_peer(const char *word, int state, int flags2)
18420 {
18421 char *result = NULL;
18422 int wordlen = strlen(word);
18423 int which = 0;
18424 struct ao2_iterator i;
18425 struct sip_peer *peer;
18426
18427 i = ao2_iterator_init(peers, 0);
18428 while ((peer = ao2_t_iterator_next(&i, "iterate thru peers table"))) {
18429 if (!strncasecmp(word, peer->name, wordlen) &&
18430 (!flags2 || ast_test_flag(&peer->flags[1], flags2)) &&
18431 ++which > state && peer->expire > 0)
18432 result = ast_strdup(peer->name);
18433 if (result) {
18434 unref_peer(peer, "toss iterator peer ptr before break");
18435 break;
18436 }
18437 unref_peer(peer, "toss iterator peer ptr");
18438 }
18439 ao2_iterator_destroy(&i);
18440 return result;
18441 }
18442
18443
18444 static char *complete_sip_show_history(const char *line, const char *word, int pos, int state)
18445 {
18446 if (pos == 3)
18447 return complete_sipch(line, word, pos, state);
18448
18449 return NULL;
18450 }
18451
18452
18453 static char *complete_sip_show_peer(const char *line, const char *word, int pos, int state)
18454 {
18455 if (pos == 3) {
18456 return complete_sip_peer(word, state, 0);
18457 }
18458
18459 return NULL;
18460 }
18461
18462
18463 static char *complete_sip_unregister(const char *line, const char *word, int pos, int state)
18464 {
18465 if (pos == 2)
18466 return complete_sip_registered_peer(word, state, 0);
18467
18468 return NULL;
18469 }
18470
18471
18472 static char *complete_sipnotify(const char *line, const char *word, int pos, int state)
18473 {
18474 char *c = NULL;
18475
18476 if (pos == 2) {
18477 int which = 0;
18478 char *cat = NULL;
18479 int wordlen = strlen(word);
18480
18481
18482
18483 if (!notify_types)
18484 return NULL;
18485
18486 while ( (cat = ast_category_browse(notify_types, cat)) ) {
18487 if (!strncasecmp(word, cat, wordlen) && ++which > state) {
18488 c = ast_strdup(cat);
18489 break;
18490 }
18491 }
18492 return c;
18493 }
18494
18495 if (pos > 2)
18496 return complete_sip_peer(word, state, 0);
18497
18498 return NULL;
18499 }
18500
18501
18502 static char *sip_show_channel(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
18503 {
18504 struct sip_pvt *cur;
18505 size_t len;
18506 int found = 0;
18507 struct ao2_iterator i;
18508
18509 switch (cmd) {
18510 case CLI_INIT:
18511 e->command = "sip show channel";
18512 e->usage =
18513 "Usage: sip show channel <call-id>\n"
18514 " Provides detailed status on a given SIP dialog (identified by SIP call-id).\n";
18515 return NULL;
18516 case CLI_GENERATE:
18517 return complete_sipch(a->line, a->word, a->pos, a->n);
18518 }
18519
18520 if (a->argc != 4)
18521 return CLI_SHOWUSAGE;
18522 len = strlen(a->argv[3]);
18523
18524 i = ao2_iterator_init(dialogs, 0);
18525 while ((cur = ao2_t_iterator_next(&i, "iterate thru dialogs"))) {
18526 sip_pvt_lock(cur);
18527
18528 if (!strncasecmp(cur->callid, a->argv[3], len)) {
18529 char formatbuf[SIPBUFSIZE/2];
18530 ast_cli(a->fd, "\n");
18531 if (cur->subscribed != NONE)
18532 ast_cli(a->fd, " * Subscription (type: %s)\n", subscription_type2str(cur->subscribed));
18533 else
18534 ast_cli(a->fd, " * SIP Call\n");
18535 ast_cli(a->fd, " Curr. trans. direction: %s\n", ast_test_flag(&cur->flags[0], SIP_OUTGOING) ? "Outgoing" : "Incoming");
18536 ast_cli(a->fd, " Call-ID: %s\n", cur->callid);
18537 ast_cli(a->fd, " Owner channel ID: %s\n", cur->owner ? cur->owner->name : "<none>");
18538 ast_cli(a->fd, " Our Codec Capability: %s\n", ast_getformatname_multiple(formatbuf, sizeof(formatbuf), cur->capability));
18539 ast_cli(a->fd, " Non-Codec Capability (DTMF): %d\n", cur->noncodeccapability);
18540 ast_cli(a->fd, " Their Codec Capability: %s\n", ast_getformatname_multiple(formatbuf, sizeof(formatbuf), cur->peercapability));
18541 ast_cli(a->fd, " Joint Codec Capability: %s\n", ast_getformatname_multiple(formatbuf, sizeof(formatbuf), cur->jointcapability));
18542 ast_cli(a->fd, " Format: %s\n", ast_getformatname_multiple(formatbuf, sizeof(formatbuf), cur->owner ? cur->owner->nativeformats : 0) );
18543 ast_cli(a->fd, " T.38 support %s\n", AST_CLI_YESNO(cur->udptl != NULL));
18544 ast_cli(a->fd, " Video support %s\n", AST_CLI_YESNO(cur->vrtp != NULL));
18545 ast_cli(a->fd, " MaxCallBR: %d kbps\n", cur->maxcallbitrate);
18546 ast_cli(a->fd, " Theoretical Address: %s\n", ast_sockaddr_stringify(&cur->sa));
18547 ast_cli(a->fd, " Received Address: %s\n", ast_sockaddr_stringify(&cur->recv));
18548 ast_cli(a->fd, " SIP Transfer mode: %s\n", transfermode2str(cur->allowtransfer));
18549 ast_cli(a->fd, " Force rport: %s\n", AST_CLI_YESNO(ast_test_flag(&cur->flags[0], SIP_NAT_FORCE_RPORT)));
18550 if (ast_sockaddr_isnull(&cur->redirip)) {
18551 ast_cli(a->fd,
18552 " Audio IP: %s (local)\n",
18553 ast_sockaddr_stringify_addr(&cur->ourip));
18554 } else {
18555 ast_cli(a->fd,
18556 " Audio IP: %s (Outside bridge)\n",
18557 ast_sockaddr_stringify_addr(&cur->redirip));
18558 }
18559 ast_cli(a->fd, " Our Tag: %s\n", cur->tag);
18560 ast_cli(a->fd, " Their Tag: %s\n", cur->theirtag);
18561 ast_cli(a->fd, " SIP User agent: %s\n", cur->useragent);
18562 if (!ast_strlen_zero(cur->username))
18563 ast_cli(a->fd, " Username: %s\n", cur->username);
18564 if (!ast_strlen_zero(cur->peername))
18565 ast_cli(a->fd, " Peername: %s\n", cur->peername);
18566 if (!ast_strlen_zero(cur->uri))
18567 ast_cli(a->fd, " Original uri: %s\n", cur->uri);
18568 if (!ast_strlen_zero(cur->cid_num))
18569 ast_cli(a->fd, " Caller-ID: %s\n", cur->cid_num);
18570 ast_cli(a->fd, " Need Destroy: %s\n", AST_CLI_YESNO(cur->needdestroy));
18571 ast_cli(a->fd, " Last Message: %s\n", cur->lastmsg);
18572 ast_cli(a->fd, " Promiscuous Redir: %s\n", AST_CLI_YESNO(ast_test_flag(&cur->flags[0], SIP_PROMISCREDIR)));
18573 ast_cli(a->fd, " Route: %s\n", cur->route ? cur->route->hop : "N/A");
18574 ast_cli(a->fd, " DTMF Mode: %s\n", dtmfmode2str(ast_test_flag(&cur->flags[0], SIP_DTMF)));
18575 ast_cli(a->fd, " SIP Options: ");
18576 if (cur->sipoptions) {
18577 int x;
18578 for (x = 0 ; x < ARRAY_LEN(sip_options); x++) {
18579 if (cur->sipoptions & sip_options[x].id)
18580 ast_cli(a->fd, "%s ", sip_options[x].text);
18581 }
18582 ast_cli(a->fd, "\n");
18583 } else
18584 ast_cli(a->fd, "(none)\n");
18585
18586 if (!cur->stimer)
18587 ast_cli(a->fd, " Session-Timer: Uninitiallized\n");
18588 else {
18589 ast_cli(a->fd, " Session-Timer: %s\n", cur->stimer->st_active ? "Active" : "Inactive");
18590 if (cur->stimer->st_active == TRUE) {
18591 ast_cli(a->fd, " S-Timer Interval: %d\n", cur->stimer->st_interval);
18592 ast_cli(a->fd, " S-Timer Refresher: %s\n", strefresher2str(cur->stimer->st_ref));
18593 ast_cli(a->fd, " S-Timer Expirys: %d\n", cur->stimer->st_expirys);
18594 ast_cli(a->fd, " S-Timer Sched Id: %d\n", cur->stimer->st_schedid);
18595 ast_cli(a->fd, " S-Timer Peer Sts: %s\n", cur->stimer->st_active_peer_ua ? "Active" : "Inactive");
18596 ast_cli(a->fd, " S-Timer Cached Min-SE: %d\n", cur->stimer->st_cached_min_se);
18597 ast_cli(a->fd, " S-Timer Cached SE: %d\n", cur->stimer->st_cached_max_se);
18598 ast_cli(a->fd, " S-Timer Cached Ref: %s\n", strefresher2str(cur->stimer->st_cached_ref));
18599 ast_cli(a->fd, " S-Timer Cached Mode: %s\n", stmode2str(cur->stimer->st_cached_mode));
18600 }
18601 }
18602
18603 ast_cli(a->fd, "\n\n");
18604
18605 found++;
18606 }
18607
18608 sip_pvt_unlock(cur);
18609
18610 ao2_t_ref(cur, -1, "toss dialog ptr set by iterator_next");
18611 }
18612 ao2_iterator_destroy(&i);
18613
18614 if (!found)
18615 ast_cli(a->fd, "No such SIP Call ID starting with '%s'\n", a->argv[3]);
18616
18617 return CLI_SUCCESS;
18618 }
18619
18620
18621 static char *sip_show_history(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
18622 {
18623 struct sip_pvt *cur;
18624 size_t len;
18625 int found = 0;
18626 struct ao2_iterator i;
18627
18628 switch (cmd) {
18629 case CLI_INIT:
18630 e->command = "sip show history";
18631 e->usage =
18632 "Usage: sip show history <call-id>\n"
18633 " Provides detailed dialog history on a given SIP call (specified by call-id).\n";
18634 return NULL;
18635 case CLI_GENERATE:
18636 return complete_sip_show_history(a->line, a->word, a->pos, a->n);
18637 }
18638
18639 if (a->argc != 4)
18640 return CLI_SHOWUSAGE;
18641
18642 if (!recordhistory)
18643 ast_cli(a->fd, "\n***Note: History recording is currently DISABLED. Use 'sip set history on' to ENABLE.\n");
18644
18645 len = strlen(a->argv[3]);
18646
18647 i = ao2_iterator_init(dialogs, 0);
18648 while ((cur = ao2_t_iterator_next(&i, "iterate thru dialogs"))) {
18649 sip_pvt_lock(cur);
18650 if (!strncasecmp(cur->callid, a->argv[3], len)) {
18651 struct sip_history *hist;
18652 int x = 0;
18653
18654 ast_cli(a->fd, "\n");
18655 if (cur->subscribed != NONE)
18656 ast_cli(a->fd, " * Subscription\n");
18657 else
18658 ast_cli(a->fd, " * SIP Call\n");
18659 if (cur->history)
18660 AST_LIST_TRAVERSE(cur->history, hist, list)
18661 ast_cli(a->fd, "%d. %s\n", ++x, hist->event);
18662 if (x == 0)
18663 ast_cli(a->fd, "Call '%s' has no history\n", cur->callid);
18664 found++;
18665 }
18666 sip_pvt_unlock(cur);
18667 ao2_t_ref(cur, -1, "toss dialog ptr from iterator_next");
18668 }
18669 ao2_iterator_destroy(&i);
18670
18671 if (!found)
18672 ast_cli(a->fd, "No such SIP Call ID starting with '%s'\n", a->argv[3]);
18673
18674 return CLI_SUCCESS;
18675 }
18676
18677
18678 static void sip_dump_history(struct sip_pvt *dialog)
18679 {
18680 int x = 0;
18681 struct sip_history *hist;
18682 static int errmsg = 0;
18683
18684 if (!dialog)
18685 return;
18686
18687 if (!option_debug && !sipdebug) {
18688 if (!errmsg) {
18689 ast_log(LOG_NOTICE, "You must have debugging enabled (SIP or Asterisk) in order to dump SIP history.\n");
18690 errmsg = 1;
18691 }
18692 return;
18693 }
18694
18695 ast_debug(1, "\n---------- SIP HISTORY for '%s' \n", dialog->callid);
18696 if (dialog->subscribed)
18697 ast_debug(1, " * Subscription\n");
18698 else
18699 ast_debug(1, " * SIP Call\n");
18700 if (dialog->history)
18701 AST_LIST_TRAVERSE(dialog->history, hist, list)
18702 ast_debug(1, " %-3.3d. %s\n", ++x, hist->event);
18703 if (!x)
18704 ast_debug(1, "Call '%s' has no history\n", dialog->callid);
18705 ast_debug(1, "\n---------- END SIP HISTORY for '%s' \n", dialog->callid);
18706 }
18707
18708
18709
18710 static void handle_request_info(struct sip_pvt *p, struct sip_request *req)
18711 {
18712 char buf[1024] = "";
18713 unsigned int event;
18714 const char *c = get_header(req, "Content-Type");
18715
18716
18717 if (!strcasecmp(c, "application/dtmf-relay") ||
18718 !strcasecmp(c, "application/vnd.nortelnetworks.digits") ||
18719 !strcasecmp(c, "application/dtmf")) {
18720 unsigned int duration = 0;
18721
18722 if (!p->owner) {
18723 transmit_response(p, "481 Call leg/transaction does not exist", req);
18724 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
18725 return;
18726 }
18727
18728
18729
18730 if (strcasecmp(c, "application/dtmf")) {
18731 const char *msg_body;
18732
18733 if ( ast_strlen_zero(msg_body = get_body(req, "Signal", '='))
18734 && ast_strlen_zero(msg_body = get_body(req, "d", '='))) {
18735 ast_log(LOG_WARNING, "Unable to retrieve DTMF signal for INFO message on "
18736 "call %s\n", p->callid);
18737 transmit_response(p, "200 OK", req);
18738 return;
18739 }
18740 ast_copy_string(buf, msg_body, sizeof(buf));
18741
18742 if (!ast_strlen_zero((msg_body = get_body(req, "Duration", '=')))) {
18743 sscanf(msg_body, "%30u", &duration);
18744 }
18745 } else {
18746
18747 get_msg_text(buf, sizeof(buf), req);
18748 }
18749
18750
18751 if (ast_strlen_zero(buf)) {
18752 transmit_response(p, "200 OK", req);
18753 return;
18754 }
18755
18756 if (!duration) {
18757 duration = 100;
18758 }
18759
18760 if (buf[0] == '*') {
18761 event = 10;
18762 } else if (buf[0] == '#') {
18763 event = 11;
18764 } else if (buf[0] == '!') {
18765 event = 16;
18766 } else if ('A' <= buf[0] && buf[0] <= 'D') {
18767 event = 12 + buf[0] - 'A';
18768 } else if ('a' <= buf[0] && buf[0] <= 'd') {
18769 event = 12 + buf[0] - 'a';
18770 } else if ((sscanf(buf, "%30u", &event) != 1) || event > 16) {
18771 ast_log(AST_LOG_WARNING, "Unable to convert DTMF event signal code to a valid "
18772 "value for INFO message on call %s\n", p->callid);
18773 transmit_response(p, "200 OK", req);
18774 return;
18775 }
18776
18777 if (event == 16) {
18778
18779 struct ast_frame f = { AST_FRAME_CONTROL, { AST_CONTROL_FLASH, } };
18780 ast_queue_frame(p->owner, &f);
18781 if (sipdebug) {
18782 ast_verbose("* DTMF-relay event received: FLASH\n");
18783 }
18784 } else {
18785
18786 struct ast_frame f = { AST_FRAME_DTMF, };
18787 if (event < 10) {
18788 f.subclass.integer = '0' + event;
18789 } else if (event == 10) {
18790 f.subclass.integer = '*';
18791 } else if (event == 11) {
18792 f.subclass.integer = '#';
18793 } else {
18794 f.subclass.integer = 'A' + (event - 12);
18795 }
18796 f.len = duration;
18797 ast_queue_frame(p->owner, &f);
18798 if (sipdebug) {
18799 ast_verbose("* DTMF-relay event received: %c\n", (int) f.subclass.integer);
18800 }
18801 }
18802 transmit_response(p, "200 OK", req);
18803 return;
18804 } else if (!strcasecmp(c, "application/media_control+xml")) {
18805
18806 if (p->owner)
18807 ast_queue_control(p->owner, AST_CONTROL_VIDUPDATE);
18808 transmit_response(p, "200 OK", req);
18809 return;
18810 } else if (!ast_strlen_zero(c = get_header(req, "X-ClientCode"))) {
18811
18812 if (ast_test_flag(&p->flags[0], SIP_USECLIENTCODE)) {
18813 if (p->owner && p->owner->cdr)
18814 ast_cdr_setuserfield(p->owner, c);
18815 if (p->owner && ast_bridged_channel(p->owner) && ast_bridged_channel(p->owner)->cdr)
18816 ast_cdr_setuserfield(ast_bridged_channel(p->owner), c);
18817 transmit_response(p, "200 OK", req);
18818 } else {
18819 transmit_response(p, "403 Forbidden", req);
18820 }
18821 return;
18822 } else if (!ast_strlen_zero(c = get_header(req, "Record"))) {
18823
18824
18825
18826
18827
18828
18829
18830 struct ast_call_feature *feat;
18831 int j;
18832 struct ast_frame f = { AST_FRAME_DTMF, };
18833
18834 if (!p->owner) {
18835 transmit_response(p, "481 Call leg/transaction does not exist", req);
18836 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
18837 return;
18838 }
18839
18840
18841 ast_rdlock_call_features();
18842 feat = ast_find_call_feature("automon");
18843 if (!feat || ast_strlen_zero(feat->exten)) {
18844 ast_log(LOG_WARNING, "Recording requested, but no One Touch Monitor registered. (See features.conf)\n");
18845
18846 transmit_response(p, "403 Forbidden", req);
18847 ast_unlock_call_features();
18848 return;
18849 }
18850
18851 f.len = 100;
18852 for (j=0; j < strlen(feat->exten); j++) {
18853 f.subclass.integer = feat->exten[j];
18854 ast_queue_frame(p->owner, &f);
18855 if (sipdebug)
18856 ast_verbose("* DTMF-relay event faked: %c\n", f.subclass.integer);
18857 }
18858 ast_unlock_call_features();
18859
18860 ast_debug(1, "Got a Request to Record the channel, state %s\n", c);
18861 transmit_response(p, "200 OK", req);
18862 return;
18863 } else if (ast_strlen_zero(c = get_header(req, "Content-Length")) || !strcasecmp(c, "0")) {
18864
18865 transmit_response(p, "200 OK", req);
18866 return;
18867 }
18868
18869
18870
18871
18872 ast_log(LOG_WARNING, "Unable to parse INFO message from %s. Content %s\n", p->callid, buf);
18873 transmit_response(p, "415 Unsupported media type", req);
18874 return;
18875 }
18876
18877
18878 static char *sip_do_debug_ip(int fd, const char *arg)
18879 {
18880 if (ast_sockaddr_resolve_first(&debugaddr, arg, 0)) {
18881 return CLI_SHOWUSAGE;
18882 }
18883
18884 ast_cli(fd, "SIP Debugging Enabled for IP: %s\n", ast_sockaddr_stringify_addr(&debugaddr));
18885 sipdebug |= sip_debug_console;
18886
18887 return CLI_SUCCESS;
18888 }
18889
18890
18891 static char *sip_do_debug_peer(int fd, const char *arg)
18892 {
18893 struct sip_peer *peer = find_peer(arg, NULL, TRUE, FINDPEERS, FALSE, 0);
18894 if (!peer)
18895 ast_cli(fd, "No such peer '%s'\n", arg);
18896 else if (ast_sockaddr_isnull(&peer->addr))
18897 ast_cli(fd, "Unable to get IP address of peer '%s'\n", arg);
18898 else {
18899 ast_sockaddr_copy(&debugaddr, &peer->addr);
18900 ast_cli(fd, "SIP Debugging Enabled for IP: %s\n", ast_sockaddr_stringify_addr(&debugaddr));
18901 sipdebug |= sip_debug_console;
18902 }
18903 if (peer)
18904 unref_peer(peer, "sip_do_debug_peer: unref_peer, from find_peer call");
18905 return CLI_SUCCESS;
18906 }
18907
18908
18909 static char *sip_do_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
18910 {
18911 int oldsipdebug = sipdebug & sip_debug_console;
18912 const char *what;
18913
18914 if (cmd == CLI_INIT) {
18915 e->command = "sip set debug {on|off|ip|peer}";
18916 e->usage =
18917 "Usage: sip set debug {off|on|ip addr[:port]|peer peername}\n"
18918 " Globally disables dumping of SIP packets,\n"
18919 " or enables it either globally or for a (single)\n"
18920 " IP address or registered peer.\n";
18921 return NULL;
18922 } else if (cmd == CLI_GENERATE) {
18923 if (a->pos == 4 && !strcasecmp(a->argv[3], "peer"))
18924 return complete_sip_peer(a->word, a->n, 0);
18925 return NULL;
18926 }
18927
18928 what = a->argv[e->args-1];
18929 if (a->argc == e->args) {
18930 if (!strcasecmp(what, "on")) {
18931 sipdebug |= sip_debug_console;
18932 sipdebug_text = 1;
18933 memset(&debugaddr, 0, sizeof(debugaddr));
18934 ast_cli(a->fd, "SIP Debugging %senabled\n", oldsipdebug ? "re-" : "");
18935 return CLI_SUCCESS;
18936 } else if (!strcasecmp(what, "off")) {
18937 sipdebug &= ~sip_debug_console;
18938 sipdebug_text = 0;
18939 ast_cli(a->fd, "SIP Debugging Disabled\n");
18940 return CLI_SUCCESS;
18941 }
18942 } else if (a->argc == e->args +1) {
18943 if (!strcasecmp(what, "ip"))
18944 return sip_do_debug_ip(a->fd, a->argv[e->args]);
18945 else if (!strcasecmp(what, "peer"))
18946 return sip_do_debug_peer(a->fd, a->argv[e->args]);
18947 }
18948 return CLI_SHOWUSAGE;
18949 }
18950
18951
18952 static char *sip_cli_notify(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
18953 {
18954 struct ast_variable *varlist;
18955 int i;
18956
18957 switch (cmd) {
18958 case CLI_INIT:
18959 e->command = "sip notify";
18960 e->usage =
18961 "Usage: sip notify <type> <peer> [<peer>...]\n"
18962 " Send a NOTIFY message to a SIP peer or peers\n"
18963 " Message types are defined in sip_notify.conf\n";
18964 return NULL;
18965 case CLI_GENERATE:
18966 return complete_sipnotify(a->line, a->word, a->pos, a->n);
18967 }
18968
18969 if (a->argc < 4)
18970 return CLI_SHOWUSAGE;
18971
18972 if (!notify_types) {
18973 ast_cli(a->fd, "No %s file found, or no types listed there\n", notify_config);
18974 return CLI_FAILURE;
18975 }
18976
18977 varlist = ast_variable_browse(notify_types, a->argv[2]);
18978
18979 if (!varlist) {
18980 ast_cli(a->fd, "Unable to find notify type '%s'\n", a->argv[2]);
18981 return CLI_FAILURE;
18982 }
18983
18984 for (i = 3; i < a->argc; i++) {
18985 struct sip_pvt *p;
18986 char buf[512];
18987 struct ast_variable *header, *var;
18988
18989 if (!(p = sip_alloc(NULL, NULL, 0, SIP_NOTIFY, NULL))) {
18990 ast_log(LOG_WARNING, "Unable to build sip pvt data for notify (memory/socket error)\n");
18991 return CLI_FAILURE;
18992 }
18993
18994 if (create_addr(p, a->argv[i], NULL, 1, NULL)) {
18995
18996 dialog_unlink_all(p);
18997 dialog_unref(p, "unref dialog inside for loop" );
18998
18999 ast_cli(a->fd, "Could not create address for '%s'\n", a->argv[i]);
19000 continue;
19001 }
19002
19003
19004 ast_set_flag(&p->flags[0], SIP_OUTGOING);
19005 sip_notify_allocate(p);
19006 p->notify->headers = header = ast_variable_new("Subscription-State", "terminated", "");
19007
19008 for (var = varlist; var; var = var->next) {
19009 ast_copy_string(buf, var->value, sizeof(buf));
19010 ast_unescape_semicolon(buf);
19011
19012 if (!strcasecmp(var->name, "Content")) {
19013 if (ast_str_strlen(p->notify->content))
19014 ast_str_append(&p->notify->content, 0, "\r\n");
19015 ast_str_append(&p->notify->content, 0, "%s", buf);
19016 } else if (!strcasecmp(var->name, "Content-Length")) {
19017 ast_log(LOG_WARNING, "it is not necessary to specify Content-Length in sip_notify.conf, ignoring");
19018 } else {
19019 header->next = ast_variable_new(var->name, buf, "");
19020 header = header->next;
19021 }
19022 }
19023
19024
19025 ast_cli(a->fd, "Sending NOTIFY of type '%s' to '%s'\n", a->argv[2], a->argv[i]);
19026 sip_scheddestroy(p, SIP_TRANS_TIMEOUT);
19027 transmit_invite(p, SIP_NOTIFY, 0, 2, NULL);
19028 dialog_unref(p, "bump down the count of p since we're done with it.");
19029 }
19030
19031 return CLI_SUCCESS;
19032 }
19033
19034
19035 static char *sip_set_history(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
19036 {
19037 switch (cmd) {
19038 case CLI_INIT:
19039 e->command = "sip set history {on|off}";
19040 e->usage =
19041 "Usage: sip set history {on|off}\n"
19042 " Enables/Disables recording of SIP dialog history for debugging purposes.\n"
19043 " Use 'sip show history' to view the history of a call number.\n";
19044 return NULL;
19045 case CLI_GENERATE:
19046 return NULL;
19047 }
19048
19049 if (a->argc != e->args)
19050 return CLI_SHOWUSAGE;
19051
19052 if (!strncasecmp(a->argv[e->args - 1], "on", 2)) {
19053 recordhistory = TRUE;
19054 ast_cli(a->fd, "SIP History Recording Enabled (use 'sip show history')\n");
19055 } else if (!strncasecmp(a->argv[e->args - 1], "off", 3)) {
19056 recordhistory = FALSE;
19057 ast_cli(a->fd, "SIP History Recording Disabled\n");
19058 } else {
19059 return CLI_SHOWUSAGE;
19060 }
19061 return CLI_SUCCESS;
19062 }
19063
19064
19065 static int do_register_auth(struct sip_pvt *p, struct sip_request *req, enum sip_auth_type code)
19066 {
19067 char *header, *respheader;
19068 char digest[1024];
19069
19070 p->authtries++;
19071 auth_headers(code, &header, &respheader);
19072 memset(digest, 0, sizeof(digest));
19073 if (reply_digest(p, req, header, SIP_REGISTER, digest, sizeof(digest))) {
19074
19075
19076 if (sip_debug_test_pvt(p) && p->registry)
19077 ast_verbose("No authentication challenge, sending blank registration to domain/host name %s\n", p->registry->hostname);
19078
19079 return -1;
19080 }
19081 if (p->do_history)
19082 append_history(p, "RegistryAuth", "Try: %d", p->authtries);
19083 if (sip_debug_test_pvt(p) && p->registry)
19084 ast_verbose("Responding to challenge, registration to domain/host name %s\n", p->registry->hostname);
19085 return transmit_register(p->registry, SIP_REGISTER, digest, respheader);
19086 }
19087
19088
19089 static int do_proxy_auth(struct sip_pvt *p, struct sip_request *req, enum sip_auth_type code, int sipmethod, int init)
19090 {
19091 char *header, *respheader;
19092 char digest[1024];
19093
19094 if (!p->options && !(p->options = ast_calloc(1, sizeof(*p->options))))
19095 return -2;
19096
19097 p->authtries++;
19098 auth_headers(code, &header, &respheader);
19099 ast_debug(2, "Auth attempt %d on %s\n", p->authtries, sip_methods[sipmethod].text);
19100 memset(digest, 0, sizeof(digest));
19101 if (reply_digest(p, req, header, sipmethod, digest, sizeof(digest) )) {
19102
19103 return -1;
19104 }
19105
19106 p->options->auth = digest;
19107 p->options->authheader = respheader;
19108 return transmit_invite(p, sipmethod, sipmethod == SIP_INVITE, init, NULL);
19109 }
19110
19111
19112
19113
19114
19115 static int reply_digest(struct sip_pvt *p, struct sip_request *req, char *header, int sipmethod, char *digest, int digest_len)
19116 {
19117 char tmp[512];
19118 char *c;
19119 char oldnonce[256];
19120
19121
19122 const struct x {
19123 const char *key;
19124 const ast_string_field *field;
19125 } *i, keys[] = {
19126 { "realm=", &p->realm },
19127 { "nonce=", &p->nonce },
19128 { "opaque=", &p->opaque },
19129 { "qop=", &p->qop },
19130 { "domain=", &p->domain },
19131 { NULL, 0 },
19132 };
19133
19134 ast_copy_string(tmp, get_header(req, header), sizeof(tmp));
19135 if (ast_strlen_zero(tmp))
19136 return -1;
19137 if (strncasecmp(tmp, "Digest ", strlen("Digest "))) {
19138 ast_log(LOG_WARNING, "missing Digest.\n");
19139 return -1;
19140 }
19141 c = tmp + strlen("Digest ");
19142 ast_copy_string(oldnonce, p->nonce, sizeof(oldnonce));
19143 while (c && *(c = ast_skip_blanks(c))) {
19144 for (i = keys; i->key != NULL; i++) {
19145 char *src, *separator;
19146 if (strncasecmp(c, i->key, strlen(i->key)) != 0)
19147 continue;
19148
19149 c += strlen(i->key);
19150 if (*c == '"') {
19151 src = ++c;
19152 separator = "\"";
19153 } else {
19154 src = c;
19155 separator = ",";
19156 }
19157 strsep(&c, separator);
19158 ast_string_field_ptr_set(p, i->field, src);
19159 break;
19160 }
19161 if (i->key == NULL)
19162 strsep(&c, ",");
19163 }
19164
19165 if (strcmp(p->nonce, oldnonce))
19166 p->noncecount = 0;
19167
19168
19169 if (p->registry) {
19170 struct sip_registry *r = p->registry;
19171
19172 if (strcmp(r->nonce, p->nonce)) {
19173 ast_string_field_set(r, realm, p->realm);
19174 ast_string_field_set(r, nonce, p->nonce);
19175 ast_string_field_set(r, authdomain, p->domain);
19176 ast_string_field_set(r, opaque, p->opaque);
19177 ast_string_field_set(r, qop, p->qop);
19178 r->noncecount = 0;
19179 }
19180 }
19181 return build_reply_digest(p, sipmethod, digest, digest_len);
19182 }
19183
19184
19185
19186
19187
19188
19189 static int build_reply_digest(struct sip_pvt *p, int method, char* digest, int digest_len)
19190 {
19191 char a1[256];
19192 char a2[256];
19193 char a1_hash[256];
19194 char a2_hash[256];
19195 char resp[256];
19196 char resp_hash[256];
19197 char uri[256];
19198 char opaque[256] = "";
19199 char cnonce[80];
19200 const char *username;
19201 const char *secret;
19202 const char *md5secret;
19203 struct sip_auth *auth;
19204 struct sip_auth_container *credentials;
19205
19206 if (!ast_strlen_zero(p->domain))
19207 snprintf(uri, sizeof(uri), "%s:%s", p->socket.type == SIP_TRANSPORT_TLS ? "sips" : "sip", p->domain);
19208 else if (!ast_strlen_zero(p->uri))
19209 ast_copy_string(uri, p->uri, sizeof(uri));
19210 else
19211 snprintf(uri, sizeof(uri), "%s:%s@%s", p->socket.type == SIP_TRANSPORT_TLS ? "sips" : "sip", p->username, ast_sockaddr_stringify_host_remote(&p->sa));
19212
19213 snprintf(cnonce, sizeof(cnonce), "%08lx", ast_random());
19214
19215
19216 ao2_lock(p);
19217 credentials = p->peerauth;
19218 if (credentials) {
19219 ao2_t_ref(credentials, +1, "Ref peer auth for digest");
19220 }
19221 ao2_unlock(p);
19222 auth = find_realm_authentication(credentials, p->realm);
19223 if (!auth) {
19224
19225 if (credentials) {
19226 ao2_t_ref(credentials, -1, "Unref peer auth for digest");
19227 }
19228 ast_mutex_lock(&authl_lock);
19229 credentials = authl;
19230 if (credentials) {
19231 ao2_t_ref(credentials, +1, "Ref global auth for digest");
19232 }
19233 ast_mutex_unlock(&authl_lock);
19234 auth = find_realm_authentication(credentials, p->realm);
19235 }
19236
19237 if (auth) {
19238 ast_debug(3, "use realm [%s] from peer [%s][%s]\n", auth->username, p->peername, p->username);
19239 username = auth->username;
19240 secret = auth->secret;
19241 md5secret = auth->md5secret;
19242 if (sipdebug)
19243 ast_debug(1, "Using realm %s authentication for call %s\n", p->realm, p->callid);
19244 } else {
19245
19246 username = p->authname;
19247 secret = p->relatedpeer
19248 && !ast_strlen_zero(p->relatedpeer->remotesecret)
19249 ? p->relatedpeer->remotesecret : p->peersecret;
19250 md5secret = p->peermd5secret;
19251 }
19252 if (ast_strlen_zero(username)) {
19253
19254 if (credentials) {
19255 ao2_t_ref(credentials, -1, "Unref auth for digest");
19256 }
19257 return -1;
19258 }
19259
19260
19261 snprintf(a1, sizeof(a1), "%s:%s:%s", username, p->realm, secret);
19262 snprintf(a2, sizeof(a2), "%s:%s", sip_methods[method].text, uri);
19263 if (!ast_strlen_zero(md5secret))
19264 ast_copy_string(a1_hash, md5secret, sizeof(a1_hash));
19265 else
19266 ast_md5_hash(a1_hash, a1);
19267 ast_md5_hash(a2_hash, a2);
19268
19269 p->noncecount++;
19270 if (!ast_strlen_zero(p->qop))
19271 snprintf(resp, sizeof(resp), "%s:%s:%08x:%s:%s:%s", a1_hash, p->nonce, p->noncecount, cnonce, "auth", a2_hash);
19272 else
19273 snprintf(resp, sizeof(resp), "%s:%s:%s", a1_hash, p->nonce, a2_hash);
19274 ast_md5_hash(resp_hash, resp);
19275
19276
19277 if (!ast_strlen_zero(p->opaque)) {
19278 snprintf(opaque, sizeof(opaque), ", opaque=\"%s\"", p->opaque);
19279 }
19280
19281
19282 if (!ast_strlen_zero(p->qop))
19283 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);
19284 else
19285 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);
19286
19287 append_history(p, "AuthResp", "Auth response sent for %s in realm %s - nc %d", username, p->realm, p->noncecount);
19288
19289 if (credentials) {
19290 ao2_t_ref(credentials, -1, "Unref auth for digest");
19291 }
19292 return 0;
19293 }
19294
19295
19296 static int func_header_read(struct ast_channel *chan, const char *function, char *data, char *buf, size_t len)
19297 {
19298 struct sip_pvt *p;
19299 const char *content = NULL;
19300 AST_DECLARE_APP_ARGS(args,
19301 AST_APP_ARG(header);
19302 AST_APP_ARG(number);
19303 );
19304 int i, number, start = 0;
19305
19306 if (ast_strlen_zero(data)) {
19307 ast_log(LOG_WARNING, "This function requires a header name.\n");
19308 return -1;
19309 }
19310
19311 ast_channel_lock(chan);
19312 if (!IS_SIP_TECH(chan->tech)) {
19313 ast_log(LOG_WARNING, "This function can only be used on SIP channels.\n");
19314 ast_channel_unlock(chan);
19315 return -1;
19316 }
19317
19318 AST_STANDARD_APP_ARGS(args, data);
19319 if (!args.number) {
19320 number = 1;
19321 } else {
19322 sscanf(args.number, "%30d", &number);
19323 if (number < 1)
19324 number = 1;
19325 }
19326
19327 p = chan->tech_pvt;
19328
19329
19330 if (!p) {
19331 ast_channel_unlock(chan);
19332 return -1;
19333 }
19334
19335 for (i = 0; i < number; i++)
19336 content = __get_header(&p->initreq, args.header, &start);
19337
19338 if (ast_strlen_zero(content)) {
19339 ast_channel_unlock(chan);
19340 return -1;
19341 }
19342
19343 ast_copy_string(buf, content, len);
19344 ast_channel_unlock(chan);
19345
19346 return 0;
19347 }
19348
19349 static struct ast_custom_function sip_header_function = {
19350 .name = "SIP_HEADER",
19351 .read = func_header_read,
19352 };
19353
19354
19355 static int func_check_sipdomain(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
19356 {
19357 if (ast_strlen_zero(data)) {
19358 ast_log(LOG_WARNING, "CHECKSIPDOMAIN requires an argument - A domain name\n");
19359 return -1;
19360 }
19361 if (check_sip_domain(data, NULL, 0))
19362 ast_copy_string(buf, data, len);
19363 else
19364 buf[0] = '\0';
19365 return 0;
19366 }
19367
19368 static struct ast_custom_function checksipdomain_function = {
19369 .name = "CHECKSIPDOMAIN",
19370 .read = func_check_sipdomain,
19371 };
19372
19373
19374 static int function_sippeer(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
19375 {
19376 struct sip_peer *peer;
19377 char *colname;
19378
19379 if ((colname = strchr(data, ':'))) {
19380 static int deprecation_warning = 0;
19381 *colname++ = '\0';
19382 if (deprecation_warning++ % 10 == 0)
19383 ast_log(LOG_WARNING, "SIPPEER(): usage of ':' to separate arguments is deprecated. Please use ',' instead.\n");
19384 } else if ((colname = strchr(data, ',')))
19385 *colname++ = '\0';
19386 else
19387 colname = "ip";
19388
19389 if (!(peer = find_peer(data, NULL, TRUE, FINDPEERS, FALSE, 0)))
19390 return -1;
19391
19392 if (!strcasecmp(colname, "ip")) {
19393 ast_copy_string(buf, ast_sockaddr_stringify_addr(&peer->addr), len);
19394 } else if (!strcasecmp(colname, "port")) {
19395 snprintf(buf, len, "%d", ast_sockaddr_port(&peer->addr));
19396 } else if (!strcasecmp(colname, "status")) {
19397 peer_status(peer, buf, len);
19398 } else if (!strcasecmp(colname, "language")) {
19399 ast_copy_string(buf, peer->language, len);
19400 } else if (!strcasecmp(colname, "regexten")) {
19401 ast_copy_string(buf, peer->regexten, len);
19402 } else if (!strcasecmp(colname, "limit")) {
19403 snprintf(buf, len, "%d", peer->call_limit);
19404 } else if (!strcasecmp(colname, "busylevel")) {
19405 snprintf(buf, len, "%d", peer->busy_level);
19406 } else if (!strcasecmp(colname, "curcalls")) {
19407 snprintf(buf, len, "%d", peer->inUse);
19408 } else if (!strcasecmp(colname, "maxforwards")) {
19409 snprintf(buf, len, "%d", peer->maxforwards);
19410 } else if (!strcasecmp(colname, "accountcode")) {
19411 ast_copy_string(buf, peer->accountcode, len);
19412 } else if (!strcasecmp(colname, "callgroup")) {
19413 ast_print_group(buf, len, peer->callgroup);
19414 } else if (!strcasecmp(colname, "pickupgroup")) {
19415 ast_print_group(buf, len, peer->pickupgroup);
19416 } else if (!strcasecmp(colname, "useragent")) {
19417 ast_copy_string(buf, peer->useragent, len);
19418 } else if (!strcasecmp(colname, "mailbox")) {
19419 struct ast_str *mailbox_str = ast_str_alloca(512);
19420 peer_mailboxes_to_str(&mailbox_str, peer);
19421 ast_copy_string(buf, mailbox_str->str, len);
19422 } else if (!strcasecmp(colname, "context")) {
19423 ast_copy_string(buf, peer->context, len);
19424 } else if (!strcasecmp(colname, "expire")) {
19425 snprintf(buf, len, "%d", peer->expire);
19426 } else if (!strcasecmp(colname, "dynamic")) {
19427 ast_copy_string(buf, peer->host_dynamic ? "yes" : "no", len);
19428 } else if (!strcasecmp(colname, "callerid_name")) {
19429 ast_copy_string(buf, peer->cid_name, len);
19430 } else if (!strcasecmp(colname, "callerid_num")) {
19431 ast_copy_string(buf, peer->cid_num, len);
19432 } else if (!strcasecmp(colname, "codecs")) {
19433 ast_getformatname_multiple(buf, len -1, peer->capability);
19434 } else if (!strcasecmp(colname, "encryption")) {
19435 snprintf(buf, len, "%d", ast_test_flag(&peer->flags[1], SIP_PAGE2_USE_SRTP));
19436 } else if (!strncasecmp(colname, "chanvar[", 8)) {
19437 char *chanvar=colname + 8;
19438 struct ast_variable *v;
19439
19440 chanvar = strsep(&chanvar, "]");
19441 for (v = peer->chanvars ; v ; v = v->next) {
19442 if (!strcasecmp(v->name, chanvar)) {
19443 ast_copy_string(buf, v->value, len);
19444 }
19445 }
19446 } else if (!strncasecmp(colname, "codec[", 6)) {
19447 char *codecnum;
19448 format_t codec = 0;
19449
19450 codecnum = colname + 6;
19451 codecnum = strsep(&codecnum, "]");
19452 if((codec = ast_codec_pref_index(&peer->prefs, atoi(codecnum)))) {
19453 ast_copy_string(buf, ast_getformatname(codec), len);
19454 } else {
19455 buf[0] = '\0';
19456 }
19457 } else {
19458 buf[0] = '\0';
19459 }
19460
19461 unref_peer(peer, "unref_peer from function_sippeer, just before return");
19462
19463 return 0;
19464 }
19465
19466
19467 static struct ast_custom_function sippeer_function = {
19468 .name = "SIPPEER",
19469 .read = function_sippeer,
19470 };
19471
19472
19473 static int function_sipchaninfo_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
19474 {
19475 struct sip_pvt *p;
19476 static int deprecated = 0;
19477
19478 *buf = 0;
19479
19480 if (!data) {
19481 ast_log(LOG_WARNING, "This function requires a parameter name.\n");
19482 return -1;
19483 }
19484
19485 ast_channel_lock(chan);
19486 if (!IS_SIP_TECH(chan->tech)) {
19487 ast_log(LOG_WARNING, "This function can only be used on SIP channels.\n");
19488 ast_channel_unlock(chan);
19489 return -1;
19490 }
19491
19492 if (deprecated++ % 20 == 0) {
19493
19494 ast_log(LOG_WARNING, "SIPCHANINFO() is deprecated. Please transition to using CHANNEL().\n");
19495 }
19496
19497 p = chan->tech_pvt;
19498
19499
19500 if (!p) {
19501 ast_channel_unlock(chan);
19502 return -1;
19503 }
19504
19505 if (!strcasecmp(data, "peerip")) {
19506 ast_copy_string(buf, ast_sockaddr_stringify_addr(&p->sa), len);
19507 } else if (!strcasecmp(data, "recvip")) {
19508 ast_copy_string(buf, ast_sockaddr_stringify_addr(&p->recv), len);
19509 } else if (!strcasecmp(data, "from")) {
19510 ast_copy_string(buf, p->from, len);
19511 } else if (!strcasecmp(data, "uri")) {
19512 ast_copy_string(buf, p->uri, len);
19513 } else if (!strcasecmp(data, "useragent")) {
19514 ast_copy_string(buf, p->useragent, len);
19515 } else if (!strcasecmp(data, "peername")) {
19516 ast_copy_string(buf, p->peername, len);
19517 } else if (!strcasecmp(data, "t38passthrough")) {
19518 if (p->t38.state == T38_DISABLED) {
19519 ast_copy_string(buf, "0", len);
19520 } else {
19521 ast_copy_string(buf, "1", len);
19522 }
19523 } else {
19524 ast_channel_unlock(chan);
19525 return -1;
19526 }
19527 ast_channel_unlock(chan);
19528
19529 return 0;
19530 }
19531
19532
19533 static struct ast_custom_function sipchaninfo_function = {
19534 .name = "SIPCHANINFO",
19535 .read = function_sipchaninfo_read,
19536 };
19537
19538
19539
19540
19541 static void change_redirecting_information(struct sip_pvt *p, struct sip_request *req,
19542 struct ast_party_redirecting *redirecting,
19543 struct ast_set_party_redirecting *update_redirecting, int set_call_forward)
19544 {
19545 char *redirecting_from_name = NULL;
19546 char *redirecting_from_number = NULL;
19547 char *redirecting_to_name = NULL;
19548 char *redirecting_to_number = NULL;
19549 int reason = AST_REDIRECTING_REASON_UNCONDITIONAL;
19550 int is_response = req->method == SIP_RESPONSE;
19551 int res = 0;
19552
19553 res = get_rdnis(p, req, &redirecting_from_name, &redirecting_from_number, &reason);
19554 if (res == -1) {
19555 if (is_response) {
19556 get_name_and_number(get_header(req, "TO"), &redirecting_from_name, &redirecting_from_number);
19557 } else {
19558 return;
19559 }
19560 }
19561
19562
19563
19564
19565
19566 if (is_response) {
19567 parse_moved_contact(p, req, &redirecting_to_name, &redirecting_to_number, set_call_forward);
19568 } else {
19569 get_name_and_number(get_header(req, "TO"), &redirecting_to_name, &redirecting_to_number);
19570 }
19571
19572 if (!ast_strlen_zero(redirecting_from_number)) {
19573 ast_debug(3, "Got redirecting from number %s\n", redirecting_from_number);
19574 update_redirecting->from.number = 1;
19575 redirecting->from.number.valid = 1;
19576 ast_free(redirecting->from.number.str);
19577 redirecting->from.number.str = redirecting_from_number;
19578 }
19579 if (!ast_strlen_zero(redirecting_from_name)) {
19580 ast_debug(3, "Got redirecting from name %s\n", redirecting_from_name);
19581 update_redirecting->from.name = 1;
19582 redirecting->from.name.valid = 1;
19583 ast_free(redirecting->from.name.str);
19584 redirecting->from.name.str = redirecting_from_name;
19585 }
19586 if (!ast_strlen_zero(p->cid_tag)) {
19587 ast_free(redirecting->from.tag);
19588 redirecting->from.tag = ast_strdup(p->cid_tag);
19589 ast_free(redirecting->to.tag);
19590 redirecting->to.tag = ast_strdup(p->cid_tag);
19591 }
19592 if (!ast_strlen_zero(redirecting_to_number)) {
19593 ast_debug(3, "Got redirecting to number %s\n", redirecting_to_number);
19594 update_redirecting->to.number = 1;
19595 redirecting->to.number.valid = 1;
19596 ast_free(redirecting->to.number.str);
19597 redirecting->to.number.str = redirecting_to_number;
19598 }
19599 if (!ast_strlen_zero(redirecting_to_name)) {
19600 ast_debug(3, "Got redirecting to name %s\n", redirecting_from_number);
19601 update_redirecting->to.name = 1;
19602 redirecting->to.name.valid = 1;
19603 ast_free(redirecting->to.name.str);
19604 redirecting->to.name.str = redirecting_to_name;
19605 }
19606 redirecting->reason = reason;
19607 }
19608
19609
19610
19611
19612
19613
19614
19615 static void parse_moved_contact(struct sip_pvt *p, struct sip_request *req, char **name, char **number, int set_call_forward)
19616 {
19617 char contact[SIPBUFSIZE];
19618 char *contact_name = NULL;
19619 char *contact_number = NULL;
19620 char *separator, *trans;
19621 char *domain;
19622 enum sip_transport transport = SIP_TRANSPORT_UDP;
19623
19624 ast_copy_string(contact, get_header(req, "Contact"), sizeof(contact));
19625 if ((separator = strchr(contact, ',')))
19626 *separator = '\0';
19627
19628 contact_number = get_in_brackets(contact);
19629 if ((trans = strcasestr(contact_number, ";transport="))) {
19630 trans += 11;
19631
19632 if ((separator = strchr(trans, ';')))
19633 *separator = '\0';
19634
19635 if (!strncasecmp(trans, "tcp", 3))
19636 transport = SIP_TRANSPORT_TCP;
19637 else if (!strncasecmp(trans, "tls", 3))
19638 transport = SIP_TRANSPORT_TLS;
19639 else {
19640 if (strncasecmp(trans, "udp", 3))
19641 ast_debug(1, "received contact with an invalid transport, '%s'\n", contact_number);
19642
19643 transport = SIP_TRANSPORT_UDP;
19644 }
19645 }
19646 contact_number = remove_uri_parameters(contact_number);
19647
19648 if (p->socket.tcptls_session) {
19649 ao2_ref(p->socket.tcptls_session, -1);
19650 p->socket.tcptls_session = NULL;
19651 }
19652
19653 set_socket_transport(&p->socket, transport);
19654
19655 if (set_call_forward && ast_test_flag(&p->flags[0], SIP_PROMISCREDIR)) {
19656 char *host = NULL;
19657 if (!strncasecmp(contact_number, "sip:", 4))
19658 contact_number += 4;
19659 else if (!strncasecmp(contact_number, "sips:", 5))
19660 contact_number += 5;
19661 separator = strchr(contact_number, '/');
19662 if (separator)
19663 *separator = '\0';
19664 if ((host = strchr(contact_number, '@'))) {
19665 *host++ = '\0';
19666 ast_debug(2, "Found promiscuous redirection to 'SIP/%s::::%s@%s'\n", contact_number, get_transport(transport), host);
19667 if (p->owner)
19668 ast_string_field_build(p->owner, call_forward, "SIP/%s::::%s@%s", contact_number, get_transport(transport), host);
19669 } else {
19670 ast_debug(2, "Found promiscuous redirection to 'SIP/::::%s@%s'\n", get_transport(transport), contact_number);
19671 if (p->owner)
19672 ast_string_field_build(p->owner, call_forward, "SIP/::::%s@%s", get_transport(transport), contact_number);
19673 }
19674 } else {
19675 separator = strchr(contact, '@');
19676 if (separator) {
19677 *separator++ = '\0';
19678 domain = separator;
19679 } else {
19680
19681 domain = contact;
19682 }
19683 separator = strchr(contact, '/');
19684 if (separator)
19685 *separator = '\0';
19686
19687 if (!strncasecmp(contact_number, "sip:", 4))
19688 contact_number += 4;
19689 else if (!strncasecmp(contact_number, "sips:", 5))
19690 contact_number += 5;
19691 separator = strchr(contact_number, ';');
19692 if (separator)
19693 *separator = '\0';
19694 ast_uri_decode(contact_number);
19695 if (set_call_forward) {
19696 ast_debug(2, "Received 302 Redirect to extension '%s' (domain %s)\n", contact_number, domain);
19697 if (p->owner) {
19698 pbx_builtin_setvar_helper(p->owner, "SIPDOMAIN", domain);
19699 ast_string_field_set(p->owner, call_forward, contact_number);
19700 }
19701 }
19702 }
19703
19704
19705
19706 if (*contact == '\"') {
19707 contact_name = contact + 1;
19708 if (!(separator = (char *)find_closing_quote(contact_name, NULL))) {
19709 ast_log(LOG_NOTICE, "No closing quote on name in Contact header? %s\n", contact);
19710 }
19711 *separator = '\0';
19712 }
19713
19714 if (name && !ast_strlen_zero(contact_name)) {
19715 *name = ast_strdup(contact_name);
19716 }
19717 if (number) {
19718 *number = ast_strdup(contact_number);
19719 }
19720 }
19721
19722
19723
19724
19725
19726
19727 static void check_pendings(struct sip_pvt *p)
19728 {
19729 if (ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
19730
19731 if (p->invitestate == INV_PROCEEDING || p->invitestate == INV_EARLY_MEDIA) {
19732 p->invitestate = INV_CANCELLED;
19733 transmit_request(p, SIP_CANCEL, p->lastinvite, XMIT_RELIABLE, FALSE);
19734
19735
19736 } else {
19737
19738
19739 if (p->pendinginvite)
19740 return;
19741
19742 if (p->owner) {
19743 ast_softhangup_nolock(p->owner, AST_SOFTHANGUP_DEV);
19744 }
19745
19746 transmit_request_with_auth(p, SIP_BYE, 0, XMIT_RELIABLE, TRUE);
19747 }
19748 ast_clear_flag(&p->flags[0], SIP_PENDINGBYE);
19749 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
19750 } else if (ast_test_flag(&p->flags[0], SIP_NEEDREINVITE)) {
19751
19752 if (p->pendinginvite || p->invitestate == INV_CALLING || p->invitestate == INV_PROCEEDING || p->invitestate == INV_EARLY_MEDIA || p->waitid > 0) {
19753 ast_debug(2, "NOT Sending pending reinvite (yet) on '%s'\n", p->callid);
19754 } else {
19755 ast_debug(2, "Sending pending reinvite on '%s'\n", p->callid);
19756
19757 transmit_reinvite_with_sdp(p, (p->t38.state == T38_LOCAL_REINVITE ? TRUE : FALSE), FALSE);
19758 ast_clear_flag(&p->flags[0], SIP_NEEDREINVITE);
19759 }
19760 }
19761 }
19762
19763
19764
19765
19766
19767 static int sip_reinvite_retry(const void *data)
19768 {
19769 struct sip_pvt *p = (struct sip_pvt *) data;
19770 struct ast_channel *owner;
19771
19772 sip_pvt_lock(p);
19773 while ((owner = p->owner) && ast_channel_trylock(owner)) {
19774 sip_pvt_unlock(p);
19775 usleep(1);
19776 sip_pvt_lock(p);
19777 }
19778 ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
19779 p->waitid = -1;
19780 check_pendings(p);
19781 sip_pvt_unlock(p);
19782 if (owner) {
19783 ast_channel_unlock(owner);
19784 }
19785 dialog_unref(p, "unref the dialog ptr from sip_reinvite_retry, because it held a dialog ptr");
19786 return 0;
19787 }
19788
19789
19790
19791
19792
19793
19794 static void handle_response_update(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno)
19795 {
19796 if (p->options) {
19797 p->options->auth_type = (resp == 401 ? WWW_AUTH : PROXY_AUTH);
19798 }
19799 if ((p->authtries == MAX_AUTHTRIES) || do_proxy_auth(p, req, resp, SIP_UPDATE, 1)) {
19800 ast_log(LOG_NOTICE, "Failed to authenticate on UPDATE to '%s'\n", get_header(&p->initreq, "From"));
19801 }
19802 }
19803
19804 static void cc_handle_publish_error(struct sip_pvt *pvt, const int resp, struct sip_request *req, struct sip_epa_entry *epa_entry)
19805 {
19806 struct cc_epa_entry *cc_entry = epa_entry->instance_data;
19807 struct sip_monitor_instance *monitor_instance = ao2_callback(sip_monitor_instances, 0,
19808 find_sip_monitor_instance_by_suspension_entry, epa_entry);
19809 const char *min_expires;
19810
19811 if (!monitor_instance) {
19812 ast_log(LOG_WARNING, "Can't find monitor_instance corresponding to epa_entry %p.\n", epa_entry);
19813 return;
19814 }
19815
19816 if (resp != 423) {
19817 ast_cc_monitor_failed(cc_entry->core_id, monitor_instance->device_name,
19818 "Received error response to our PUBLISH");
19819 ao2_ref(monitor_instance, -1);
19820 return;
19821 }
19822
19823
19824
19825
19826
19827
19828
19829
19830
19831 min_expires = get_header(req, "Min-Expires");
19832 if (ast_strlen_zero(min_expires)) {
19833 pvt->expiry *= 2;
19834 if (pvt->expiry < 0) {
19835
19836 ast_cc_monitor_failed(cc_entry->core_id, monitor_instance->device_name,
19837 "PUBLISH expiry overflowed");
19838 ao2_ref(monitor_instance, -1);
19839 return;
19840 }
19841 } else if (sscanf(min_expires, "%d", &pvt->expiry) != 1) {
19842 ast_cc_monitor_failed(cc_entry->core_id, monitor_instance->device_name,
19843 "Min-Expires has non-numeric value");
19844 ao2_ref(monitor_instance, -1);
19845 return;
19846 }
19847
19848
19849
19850 transmit_invite(pvt, SIP_PUBLISH, FALSE, 0, NULL);
19851 ao2_ref(monitor_instance, -1);
19852 }
19853
19854 static void handle_response_publish(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno)
19855 {
19856 struct sip_epa_entry *epa_entry = p->epa_entry;
19857 const char *etag = get_header(req, "Sip-ETag");
19858
19859 ast_assert(epa_entry != NULL);
19860
19861 if (resp == 401 || resp == 407) {
19862 ast_string_field_set(p, theirtag, NULL);
19863 if (p->options) {
19864 p->options->auth_type = (resp == 401 ? WWW_AUTH : PROXY_AUTH);
19865 }
19866 if ((p->authtries == MAX_AUTHTRIES) || do_proxy_auth(p, req, resp, SIP_PUBLISH, 0)) {
19867 ast_log(LOG_NOTICE, "Failed to authenticate on PUBLISH to '%s'\n", get_header(&p->initreq, "From"));
19868 pvt_set_needdestroy(p, "Failed to authenticate on PUBLISH");
19869 sip_alreadygone(p);
19870 }
19871 return;
19872 }
19873
19874 if (resp == 501 || resp == 405) {
19875 mark_method_unallowed(&p->allowed_methods, SIP_PUBLISH);
19876 }
19877
19878 if (resp == 200) {
19879 p->authtries = 0;
19880
19881
19882
19883 if (!ast_strlen_zero(etag)) {
19884 ast_copy_string(epa_entry->entity_tag, etag, sizeof(epa_entry->entity_tag));
19885 }
19886
19887
19888
19889
19890 if (epa_entry->static_data->handle_ok) {
19891 epa_entry->static_data->handle_ok(p, req, epa_entry);
19892 }
19893 } else {
19894
19895
19896
19897
19898 if (epa_entry->static_data->handle_error) {
19899 epa_entry->static_data->handle_error(p, resp, req, epa_entry);
19900 }
19901 }
19902 }
19903
19904
19905 static void handle_response_invite(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno)
19906 {
19907 int outgoing = ast_test_flag(&p->flags[0], SIP_OUTGOING);
19908 int res = 0;
19909 int xmitres = 0;
19910 int reinvite = (p->owner && p->owner->_state == AST_STATE_UP);
19911 char *p_hdrval;
19912 int rtn;
19913 struct ast_party_connected_line connected;
19914 struct ast_set_party_connected_line update_connected;
19915
19916 if (reinvite)
19917 ast_debug(4, "SIP response %d to RE-invite on %s call %s\n", resp, outgoing ? "outgoing" : "incoming", p->callid);
19918 else
19919 ast_debug(4, "SIP response %d to standard invite\n", resp);
19920
19921 if (p->alreadygone) {
19922 ast_debug(1, "Got response on call that is already terminated: %s (ignoring)\n", p->callid);
19923 return;
19924 }
19925
19926
19927
19928 AST_SCHED_DEL_UNREF(sched, p->initid, dialog_unref(p, "when you delete the initid sched, you should dec the refcount for the stored dialog ptr"));
19929
19930
19931
19932
19933 if (resp > 100 && resp < 200 && resp!=101 && resp != 180 && resp != 181 && resp != 182 && resp != 183)
19934 resp = 183;
19935
19936
19937 if (resp >= 100 && resp < 200 && p->invitestate == INV_CALLING)
19938 p->invitestate = INV_PROCEEDING;
19939
19940
19941 if (resp >= 300 && (p->invitestate == INV_CALLING || p->invitestate == INV_PROCEEDING || p->invitestate == INV_EARLY_MEDIA ))
19942 p->invitestate = INV_COMPLETED;
19943
19944
19945 if ((resp == 200 || resp >= 300) && p->pendinginvite && seqno == p->pendinginvite)
19946 p->pendinginvite = 0;
19947
19948
19949
19950
19951 if (!reinvite) {
19952 set_pvt_allowed_methods(p, req);
19953 }
19954
19955 switch (resp) {
19956 case 100:
19957 case 101:
19958 if (!req->ignore && p->invitestate != INV_CANCELLED && sip_cancel_destroy(p))
19959 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
19960 check_pendings(p);
19961 break;
19962
19963 case 180:
19964 case 182:
19965 if (!req->ignore && p->invitestate != INV_CANCELLED && sip_cancel_destroy(p))
19966 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
19967
19968
19969
19970 parse_ok_contact(p, req);
19971 if (!reinvite) {
19972 build_route(p, req, 1, resp);
19973 }
19974 if (!req->ignore && p->owner) {
19975 if (get_rpid(p, req)) {
19976
19977 ast_party_connected_line_init(&connected);
19978 memset(&update_connected, 0, sizeof(update_connected));
19979
19980 update_connected.id.number = 1;
19981 connected.id.number.valid = 1;
19982 connected.id.number.str = (char *) p->cid_num;
19983 connected.id.number.presentation = p->callingpres;
19984
19985 update_connected.id.name = 1;
19986 connected.id.name.valid = 1;
19987 connected.id.name.str = (char *) p->cid_name;
19988 connected.id.name.presentation = p->callingpres;
19989
19990 connected.id.tag = (char *) p->cid_tag;
19991 connected.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
19992 ast_channel_queue_connected_line_update(p->owner, &connected,
19993 &update_connected);
19994 }
19995 sip_handle_cc(p, req, AST_CC_CCNR);
19996 ast_queue_control(p->owner, AST_CONTROL_RINGING);
19997 if (p->owner->_state != AST_STATE_UP) {
19998 ast_setstate(p->owner, AST_STATE_RINGING);
19999 }
20000 }
20001 if (find_sdp(req)) {
20002 if (p->invitestate != INV_CANCELLED)
20003 p->invitestate = INV_EARLY_MEDIA;
20004 res = process_sdp(p, req, SDP_T38_NONE);
20005 if (!req->ignore && p->owner) {
20006
20007 ast_queue_control(p->owner, AST_CONTROL_PROGRESS);
20008 }
20009 ast_rtp_instance_activate(p->rtp);
20010 }
20011 check_pendings(p);
20012 break;
20013
20014 case 181:
20015 if (!req->ignore && (p->invitestate != INV_CANCELLED) && sip_cancel_destroy(p))
20016 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
20017
20018
20019
20020 parse_ok_contact(p, req);
20021 if (!reinvite) {
20022 build_route(p, req, 1, resp);
20023 }
20024 if (!req->ignore && p->owner) {
20025 struct ast_party_redirecting redirecting;
20026 struct ast_set_party_redirecting update_redirecting;
20027
20028 ast_party_redirecting_init(&redirecting);
20029 memset(&update_redirecting, 0, sizeof(update_redirecting));
20030 change_redirecting_information(p, req, &redirecting, &update_redirecting,
20031 FALSE);
20032 ast_channel_queue_redirecting_update(p->owner, &redirecting,
20033 &update_redirecting);
20034 ast_party_redirecting_free(&redirecting);
20035 sip_handle_cc(p, req, AST_CC_CCNR);
20036 }
20037 check_pendings(p);
20038 break;
20039
20040 case 183:
20041 if (!req->ignore && (p->invitestate != INV_CANCELLED) && sip_cancel_destroy(p))
20042 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
20043
20044
20045
20046 parse_ok_contact(p, req);
20047 if (!reinvite) {
20048 build_route(p, req, 1, resp);
20049 }
20050 if (!req->ignore && p->owner) {
20051 if (get_rpid(p, req)) {
20052
20053 ast_party_connected_line_init(&connected);
20054 memset(&update_connected, 0, sizeof(update_connected));
20055
20056 update_connected.id.number = 1;
20057 connected.id.number.valid = 1;
20058 connected.id.number.str = (char *) p->cid_num;
20059 connected.id.number.presentation = p->callingpres;
20060
20061 update_connected.id.name = 1;
20062 connected.id.name.valid = 1;
20063 connected.id.name.str = (char *) p->cid_name;
20064 connected.id.name.presentation = p->callingpres;
20065
20066 connected.id.tag = (char *) p->cid_tag;
20067 connected.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
20068 ast_channel_queue_connected_line_update(p->owner, &connected,
20069 &update_connected);
20070 }
20071 sip_handle_cc(p, req, AST_CC_CCNR);
20072 }
20073 if (find_sdp(req)) {
20074 if (p->invitestate != INV_CANCELLED)
20075 p->invitestate = INV_EARLY_MEDIA;
20076 res = process_sdp(p, req, SDP_T38_NONE);
20077 if (!req->ignore && p->owner) {
20078
20079 ast_queue_control(p->owner, AST_CONTROL_PROGRESS);
20080 }
20081 ast_rtp_instance_activate(p->rtp);
20082 } else {
20083
20084
20085
20086
20087 if (!req->ignore && p->owner) {
20088 ast_queue_control(p->owner, AST_CONTROL_RINGING);
20089 }
20090 }
20091 check_pendings(p);
20092 break;
20093
20094 case 200:
20095 if (!req->ignore && (p->invitestate != INV_CANCELLED) && sip_cancel_destroy(p))
20096 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
20097 p->authtries = 0;
20098 if (find_sdp(req)) {
20099 if ((res = process_sdp(p, req, SDP_T38_ACCEPT)) && !req->ignore)
20100 if (!reinvite)
20101
20102
20103 ast_set_flag(&p->flags[0], SIP_PENDINGBYE);
20104 ast_rtp_instance_activate(p->rtp);
20105 }
20106
20107 if (!req->ignore && p->owner) {
20108 int rpid_changed;
20109
20110 rpid_changed = get_rpid(p, req);
20111 if (rpid_changed || !reinvite) {
20112
20113 ast_party_connected_line_init(&connected);
20114 memset(&update_connected, 0, sizeof(update_connected));
20115 if (rpid_changed
20116 || !ast_strlen_zero(p->cid_num)
20117 || (p->callingpres & AST_PRES_RESTRICTION) != AST_PRES_ALLOWED) {
20118 update_connected.id.number = 1;
20119 connected.id.number.valid = 1;
20120 connected.id.number.str = (char *) p->cid_num;
20121 connected.id.number.presentation = p->callingpres;
20122 }
20123 if (rpid_changed
20124 || !ast_strlen_zero(p->cid_name)
20125 || (p->callingpres & AST_PRES_RESTRICTION) != AST_PRES_ALLOWED) {
20126 update_connected.id.name = 1;
20127 connected.id.name.valid = 1;
20128 connected.id.name.str = (char *) p->cid_name;
20129 connected.id.name.presentation = p->callingpres;
20130 }
20131 if (update_connected.id.number || update_connected.id.name) {
20132 connected.id.tag = (char *) p->cid_tag;
20133 connected.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
20134 ast_channel_queue_connected_line_update(p->owner, &connected,
20135 &update_connected);
20136 }
20137 }
20138 }
20139
20140
20141
20142
20143 if (outgoing) {
20144 update_call_counter(p, DEC_CALL_RINGING);
20145 parse_ok_contact(p, req);
20146
20147 if (!reinvite)
20148 build_route(p, req, 1, resp);
20149
20150 if(set_address_from_contact(p)) {
20151
20152
20153 if (!p->route && !req->ignore)
20154 ast_set_flag(&p->flags[0], SIP_PENDINGBYE);
20155 }
20156
20157 }
20158
20159 if (!req->ignore && p->owner) {
20160 if (!reinvite) {
20161 ast_queue_control(p->owner, AST_CONTROL_ANSWER);
20162 if (sip_cfg.callevents)
20163 manager_event(EVENT_FLAG_SYSTEM, "ChannelUpdate",
20164 "Channel: %s\r\nChanneltype: %s\r\nUniqueid: %s\r\nSIPcallid: %s\r\nSIPfullcontact: %s\r\nPeername: %s\r\n",
20165 p->owner->name, "SIP", p->owner->uniqueid, p->callid, p->fullcontact, p->peername);
20166 } else {
20167 if (p->t38.state == T38_DISABLED) {
20168 ast_queue_control(p->owner, AST_CONTROL_UPDATE_RTP_PEER);
20169 } else {
20170 ast_queue_frame(p->owner, &ast_null_frame);
20171 }
20172 }
20173 } else {
20174
20175
20176
20177 if (!req->ignore)
20178 ast_set_flag(&p->flags[0], SIP_PENDINGBYE);
20179 }
20180
20181
20182 if (st_get_mode(p, 0) != SESSION_TIMER_MODE_REFUSE && p->outgoing_call == TRUE && !reinvite) {
20183 p_hdrval = (char*)get_header(req, "Session-Expires");
20184 if (!ast_strlen_zero(p_hdrval)) {
20185
20186 enum st_refresher tmp_st_ref = SESSION_TIMER_REFRESHER_AUTO;
20187 int tmp_st_interval = 0;
20188 rtn = parse_session_expires(p_hdrval, &tmp_st_interval, &tmp_st_ref);
20189 if (rtn != 0) {
20190 ast_set_flag(&p->flags[0], SIP_PENDINGBYE);
20191 }
20192 if (tmp_st_ref == SESSION_TIMER_REFRESHER_UAC ||
20193 tmp_st_ref == SESSION_TIMER_REFRESHER_UAS) {
20194 p->stimer->st_ref = tmp_st_ref;
20195 }
20196 if (tmp_st_interval) {
20197 p->stimer->st_interval = tmp_st_interval;
20198 }
20199 p->stimer->st_active = TRUE;
20200 p->stimer->st_active_peer_ua = TRUE;
20201 start_session_timer(p);
20202 } else {
20203
20204 if (st_get_mode(p, 0) == SESSION_TIMER_MODE_ORIGINATE) {
20205 p->stimer->st_ref = SESSION_TIMER_REFRESHER_UAC;
20206 p->stimer->st_active_peer_ua = FALSE;
20207 start_session_timer(p);
20208 }
20209 }
20210 }
20211
20212
20213
20214 p->invitestate = INV_TERMINATED;
20215 ast_set_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
20216 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, TRUE);
20217 check_pendings(p);
20218 break;
20219
20220 case 407:
20221 case 401:
20222
20223 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
20224 if (p->options)
20225 p->options->auth_type = resp;
20226
20227
20228 ast_string_field_set(p, theirtag, NULL);
20229 if (!req->ignore) {
20230 if (p->authtries < MAX_AUTHTRIES)
20231 p->invitestate = INV_CALLING;
20232 if (p->authtries == MAX_AUTHTRIES || do_proxy_auth(p, req, resp, SIP_INVITE, 1)) {
20233 ast_log(LOG_NOTICE, "Failed to authenticate on INVITE to '%s'\n", get_header(&p->initreq, "From"));
20234 pvt_set_needdestroy(p, "failed to authenticate on INVITE");
20235 sip_alreadygone(p);
20236 if (p->owner)
20237 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
20238 }
20239 }
20240 break;
20241
20242 case 403:
20243
20244 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
20245 ast_log(LOG_WARNING, "Received response: \"Forbidden\" from '%s'\n", get_header(&p->initreq, "From"));
20246 if (!req->ignore && p->owner) {
20247 ast_set_hangupsource(p->owner, p->owner->name, 0);
20248 ast_queue_hangup_with_cause(p->owner, AST_CAUSE_CONGESTION);
20249 }
20250 break;
20251
20252 case 404:
20253 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
20254 if (p->owner && !req->ignore) {
20255 ast_set_hangupsource(p->owner, p->owner->name, 0);
20256 ast_queue_hangup_with_cause(p->owner, AST_CAUSE_CONGESTION);
20257 }
20258 break;
20259
20260 case 408:
20261 case 481:
20262
20263 ast_log(LOG_WARNING, "Re-invite to non-existing call leg on other UA. SIP dialog '%s'. Giving up.\n", p->callid);
20264 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
20265 if (p->owner) {
20266 ast_queue_hangup_with_cause(p->owner, AST_CAUSE_CONGESTION);
20267 }
20268 break;
20269
20270 case 422:
20271 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
20272 ast_string_field_set(p, theirtag, NULL);
20273 proc_422_rsp(p, req);
20274 break;
20275
20276 case 428:
20277 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
20278 append_history(p, "Identity", "SIP identity is required. Not supported by Asterisk.");
20279 ast_log(LOG_WARNING, "SIP identity required by proxy. SIP dialog '%s'. Giving up.\n", p->callid);
20280 if (p->owner && !req->ignore) {
20281 ast_queue_hangup_with_cause(p->owner, AST_CAUSE_CONGESTION);
20282 }
20283 break;
20284
20285 case 487:
20286
20287
20288
20289 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
20290 if (p->owner && !req->ignore) {
20291 ast_queue_hangup_with_cause(p->owner, AST_CAUSE_NORMAL_CLEARING);
20292 append_history(p, "Hangup", "Got 487 on CANCEL request from us. Queued AST hangup request");
20293 } else if (!req->ignore) {
20294 update_call_counter(p, DEC_CALL_LIMIT);
20295 append_history(p, "Hangup", "Got 487 on CANCEL request from us on call without owner. Killing this dialog.");
20296 }
20297 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
20298 break;
20299 case 415:
20300 case 488:
20301 case 606:
20302 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
20303 if (p->udptl && p->t38.state == T38_LOCAL_REINVITE) {
20304 change_t38_state(p, T38_DISABLED);
20305
20306
20307
20308
20309 transmit_reinvite_with_sdp(p, FALSE, FALSE);
20310 } else {
20311
20312 if (p->owner && !req->ignore) {
20313 ast_queue_hangup_with_cause(p->owner, AST_CAUSE_CONGESTION);
20314 }
20315 }
20316 break;
20317 case 491:
20318 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
20319 if (p->owner && !req->ignore) {
20320 if (p->owner->_state != AST_STATE_UP) {
20321 ast_queue_hangup_with_cause(p->owner, AST_CAUSE_CONGESTION);
20322 } else {
20323
20324
20325
20326 int wait;
20327
20328
20329 if (p->outgoing_call) {
20330 wait = 2100 + ast_random() % 2000;
20331 } else {
20332 wait = ast_random() % 2000;
20333 }
20334 p->waitid = ast_sched_add(sched, wait, sip_reinvite_retry, dialog_ref(p, "passing dialog ptr into sched structure based on waitid for sip_reinvite_retry."));
20335 ast_log(LOG_WARNING, "just did sched_add waitid(%d) for sip_reinvite_retry for dialog %s in handle_response_invite\n", p->waitid, p->callid);
20336 ast_debug(2, "Reinvite race. Waiting %d secs before retry\n", wait);
20337 }
20338 }
20339 break;
20340
20341 case 405:
20342 case 501:
20343 xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
20344 if (p->owner) {
20345 ast_queue_hangup_with_cause(p->owner, AST_CAUSE_CONGESTION);
20346 }
20347 break;
20348 }
20349 if (xmitres == XMIT_ERROR)
20350 ast_log(LOG_WARNING, "Could not transmit message in dialog %s\n", p->callid);
20351 }
20352
20353
20354
20355
20356 static void handle_response_notify(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno)
20357 {
20358 switch (resp) {
20359 case 200:
20360
20361 if (p->owner) {
20362 if (p->refer) {
20363 ast_log(LOG_NOTICE, "Got OK on REFER Notify message\n");
20364 } else {
20365 ast_log(LOG_WARNING, "Notify answer on an owned channel? - %s\n", p->owner->name);
20366 }
20367 } else {
20368 if (p->subscribed == NONE && !p->refer) {
20369 ast_debug(4, "Got 200 accepted on NOTIFY %s\n", p->callid);
20370 pvt_set_needdestroy(p, "received 200 response");
20371 }
20372 if (ast_test_flag(&p->flags[1], SIP_PAGE2_STATECHANGEQUEUE)) {
20373
20374 ast_clear_flag(&p->flags[1], SIP_PAGE2_STATECHANGEQUEUE);
20375 cb_extensionstate((char *)p->context, (char *)p->exten, p->laststate, (void *) p);
20376 }
20377 }
20378 break;
20379 case 401:
20380 case 407:
20381 if (!p->notify) {
20382 break;
20383 }
20384 ast_string_field_set(p, theirtag, NULL);
20385 if (ast_strlen_zero(p->authname)) {
20386 ast_log(LOG_WARNING, "Asked to authenticate NOTIFY to %s but we have no matching peer or realm auth!\n", ast_sockaddr_stringify(&p->recv));
20387 pvt_set_needdestroy(p, "unable to authenticate NOTIFY");
20388 }
20389 if (p->authtries > 1 || do_proxy_auth(p, req, resp, SIP_NOTIFY, 0)) {
20390 ast_log(LOG_NOTICE, "Failed to authenticate on NOTIFY to '%s'\n", get_header(&p->initreq, "From"));
20391 pvt_set_needdestroy(p, "failed to authenticate NOTIFY");
20392 }
20393 break;
20394 case 481:
20395 pvt_set_needdestroy(p, "Received 481 response for NOTIFY");
20396 break;
20397 }
20398 }
20399
20400
20401 static void handle_response_subscribe(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno)
20402 {
20403 if (p->subscribed == CALL_COMPLETION) {
20404 struct sip_monitor_instance *monitor_instance;
20405
20406 if (resp < 300) {
20407 return;
20408 }
20409
20410
20411 monitor_instance = ao2_callback(sip_monitor_instances, 0,
20412 find_sip_monitor_instance_by_subscription_pvt, p);
20413 if (monitor_instance) {
20414 ast_cc_monitor_failed(monitor_instance->core_id,
20415 monitor_instance->device_name,
20416 "Received error response to our SUBSCRIBE");
20417 }
20418 return;
20419 }
20420
20421 if (p->subscribed != MWI_NOTIFICATION) {
20422 return;
20423 }
20424 if (!p->mwi) {
20425 return;
20426 }
20427
20428 switch (resp) {
20429 case 200:
20430 ast_debug(3, "Got 200 OK on subscription for MWI\n");
20431 set_pvt_allowed_methods(p, req);
20432 if (p->options) {
20433 ast_free(p->options);
20434 p->options = NULL;
20435 }
20436 p->mwi->subscribed = 1;
20437 if ((p->mwi->resub = ast_sched_add(sched, mwi_expiry * 1000, sip_subscribe_mwi_do, ASTOBJ_REF(p->mwi))) < 0) {
20438 ASTOBJ_UNREF(p->mwi, sip_subscribe_mwi_destroy);
20439 }
20440 break;
20441 case 401:
20442 case 407:
20443 ast_string_field_set(p, theirtag, NULL);
20444 if (p->authtries > 1 || do_proxy_auth(p, req, resp, SIP_SUBSCRIBE, 0)) {
20445 ast_log(LOG_NOTICE, "Failed to authenticate on SUBSCRIBE to '%s'\n", get_header(&p->initreq, "From"));
20446 p->mwi->call = NULL;
20447 ASTOBJ_UNREF(p->mwi, sip_subscribe_mwi_destroy);
20448 pvt_set_needdestroy(p, "failed to authenticate SUBSCRIBE");
20449 }
20450 break;
20451 case 403:
20452 transmit_response_with_date(p, "200 OK", req);
20453 ast_log(LOG_WARNING, "Authentication failed while trying to subscribe for MWI.\n");
20454 p->mwi->call = NULL;
20455 ASTOBJ_UNREF(p->mwi, sip_subscribe_mwi_destroy);
20456 pvt_set_needdestroy(p, "received 403 response");
20457 sip_alreadygone(p);
20458 break;
20459 case 404:
20460 ast_log(LOG_WARNING, "Subscription failed for MWI. The remote side said that a mailbox may not have been configured.\n");
20461 p->mwi->call = NULL;
20462 ASTOBJ_UNREF(p->mwi, sip_subscribe_mwi_destroy);
20463 pvt_set_needdestroy(p, "received 404 response");
20464 break;
20465 case 481:
20466 ast_log(LOG_WARNING, "Subscription failed for MWI. The remote side said that our dialog did not exist.\n");
20467 p->mwi->call = NULL;
20468 ASTOBJ_UNREF(p->mwi, sip_subscribe_mwi_destroy);
20469 pvt_set_needdestroy(p, "received 481 response");
20470 break;
20471 case 500:
20472 case 501:
20473 ast_log(LOG_WARNING, "Subscription failed for MWI. The remote side may have suffered a heart attack.\n");
20474 p->mwi->call = NULL;
20475 ASTOBJ_UNREF(p->mwi, sip_subscribe_mwi_destroy);
20476 pvt_set_needdestroy(p, "received 500/501 response");
20477 break;
20478 }
20479 }
20480
20481
20482
20483
20484 static void handle_response_refer(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno)
20485 {
20486 enum ast_control_transfer message = AST_TRANSFER_FAILED;
20487
20488
20489 if (!p->refer)
20490 return;
20491
20492 switch (resp) {
20493 case 202:
20494
20495
20496 p->refer->status = REFER_ACCEPTED;
20497
20498 ast_debug(3, "Got 202 accepted on transfer\n");
20499
20500 break;
20501
20502 case 401:
20503 case 407:
20504 if (ast_strlen_zero(p->authname)) {
20505 ast_log(LOG_WARNING, "Asked to authenticate REFER to %s but we have no matching peer or realm auth!\n",
20506 ast_sockaddr_stringify(&p->recv));
20507 if (p->owner) {
20508 ast_queue_control_data(p->owner, AST_CONTROL_TRANSFER, &message, sizeof(message));
20509 }
20510 pvt_set_needdestroy(p, "unable to authenticate REFER");
20511 }
20512 if (p->authtries > 1 || do_proxy_auth(p, req, resp, SIP_REFER, 0)) {
20513 ast_log(LOG_NOTICE, "Failed to authenticate on REFER to '%s'\n", get_header(&p->initreq, "From"));
20514 p->refer->status = REFER_NOAUTH;
20515 if (p->owner) {
20516 ast_queue_control_data(p->owner, AST_CONTROL_TRANSFER, &message, sizeof(message));
20517 }
20518 pvt_set_needdestroy(p, "failed to authenticate REFER");
20519 }
20520 break;
20521
20522 case 405:
20523
20524
20525 ast_log(LOG_NOTICE, "SIP transfer to %s failed, REFER not allowed. \n", p->refer->refer_to);
20526 pvt_set_needdestroy(p, "received 405 response");
20527 p->refer->status = REFER_FAILED;
20528 if (p->owner) {
20529 ast_queue_control_data(p->owner, AST_CONTROL_TRANSFER, &message, sizeof(message));
20530 }
20531 break;
20532
20533 case 481:
20534
20535
20536
20537
20538 ast_log(LOG_WARNING, "Remote host can't match REFER request to call '%s'. Giving up.\n", p->callid);
20539 if (p->owner)
20540 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
20541 pvt_set_needdestroy(p, "received 481 response");
20542 break;
20543
20544 case 500:
20545 case 501:
20546
20547
20548 ast_log(LOG_NOTICE, "SIP transfer to %s failed, call miserably fails. \n", p->refer->refer_to);
20549 pvt_set_needdestroy(p, "received 500/501 response");
20550 p->refer->status = REFER_FAILED;
20551 if (p->owner) {
20552 ast_queue_control_data(p->owner, AST_CONTROL_TRANSFER, &message, sizeof(message));
20553 }
20554 break;
20555 case 603:
20556 ast_log(LOG_NOTICE, "SIP transfer to %s declined, call miserably fails. \n", p->refer->refer_to);
20557 p->refer->status = REFER_FAILED;
20558 pvt_set_needdestroy(p, "received 603 response");
20559 if (p->owner) {
20560 ast_queue_control_data(p->owner, AST_CONTROL_TRANSFER, &message, sizeof(message));
20561 }
20562 break;
20563 default:
20564
20565
20566
20567
20568 if (resp < 299) {
20569 ast_log(LOG_WARNING, "SIP transfer to %s had unxpected 2xx response (%d), confusion is possible. \n", p->refer->refer_to, resp);
20570 } else {
20571 ast_log(LOG_WARNING, "SIP transfer to %s with response (%d). \n", p->refer->refer_to, resp);
20572 }
20573
20574 p->refer->status = REFER_FAILED;
20575 pvt_set_needdestroy(p, "received failure response");
20576 if (p->owner) {
20577 ast_queue_control_data(p->owner, AST_CONTROL_TRANSFER, &message, sizeof(message));
20578 }
20579 break;
20580 }
20581 }
20582
20583
20584 static int handle_response_register(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno)
20585 {
20586 int expires, expires_ms;
20587 struct sip_registry *r;
20588 r=p->registry;
20589
20590 switch (resp) {
20591 case 401:
20592 if (p->authtries == MAX_AUTHTRIES || do_register_auth(p, req, resp)) {
20593 ast_log(LOG_NOTICE, "Failed to authenticate on REGISTER to '%s@%s' (Tries %d)\n", p->registry->username, p->registry->hostname, p->authtries);
20594 pvt_set_needdestroy(p, "failed to authenticate REGISTER");
20595 }
20596 break;
20597 case 403:
20598 ast_log(LOG_WARNING, "Forbidden - wrong password on authentication for REGISTER for '%s' to '%s'\n", p->registry->username, p->registry->hostname);
20599 AST_SCHED_DEL_UNREF(sched, r->timeout, registry_unref(r, "reg ptr unref from handle_response_register 403"));
20600 r->regstate = REG_STATE_NOAUTH;
20601 pvt_set_needdestroy(p, "received 403 response");
20602 break;
20603 case 404:
20604 ast_log(LOG_WARNING, "Got 404 Not found on SIP register to service %s@%s, giving up\n", p->registry->username, p->registry->hostname);
20605 pvt_set_needdestroy(p, "received 404 response");
20606 if (r->call)
20607 r->call = dialog_unref(r->call, "unsetting registry->call pointer-- case 404");
20608 r->regstate = REG_STATE_REJECTED;
20609 AST_SCHED_DEL_UNREF(sched, r->timeout, registry_unref(r, "reg ptr unref from handle_response_register 404"));
20610 break;
20611 case 407:
20612 if (p->authtries == MAX_AUTHTRIES || do_register_auth(p, req, resp)) {
20613 ast_log(LOG_NOTICE, "Failed to authenticate on REGISTER to '%s' (tries '%d')\n", get_header(&p->initreq, "From"), p->authtries);
20614 pvt_set_needdestroy(p, "failed to authenticate REGISTER");
20615 }
20616 break;
20617 case 408:
20618
20619 if (r) {
20620 r->regattempts = 0;
20621 } else {
20622 ast_log(LOG_WARNING, "Got a 408 response to our REGISTER on call %s after we had destroyed the registry object\n", p->callid);
20623 }
20624 break;
20625 case 423:
20626 r->expiry = atoi(get_header(req, "Min-Expires"));
20627 ast_log(LOG_WARNING, "Got 423 Interval too brief for service %s@%s, minimum is %d seconds\n", p->registry->username, p->registry->hostname, r->expiry);
20628 AST_SCHED_DEL_UNREF(sched, r->timeout, registry_unref(r, "reg ptr unref from handle_response_register 423"));
20629 if (r->call) {
20630 r->call = dialog_unref(r->call, "unsetting registry->call pointer-- case 423");
20631 pvt_set_needdestroy(p, "received 423 response");
20632 }
20633 if (r->expiry > max_expiry) {
20634 ast_log(LOG_WARNING, "Required expiration time from %s@%s is too high, giving up\n", p->registry->username, p->registry->hostname);
20635 r->expiry = r->configured_expiry;
20636 r->regstate = REG_STATE_REJECTED;
20637 } else {
20638 r->regstate = REG_STATE_UNREGISTERED;
20639 transmit_register(r, SIP_REGISTER, NULL, NULL);
20640 }
20641 manager_event(EVENT_FLAG_SYSTEM, "Registry", "ChannelType: SIP\r\nUsername: %s\r\nDomain: %s\r\nStatus: %s\r\n", r->username, r->hostname, regstate2str(r->regstate));
20642 break;
20643 case 479:
20644 ast_log(LOG_WARNING, "Got error 479 on register to %s@%s, giving up (check config)\n", p->registry->username, p->registry->hostname);
20645 pvt_set_needdestroy(p, "received 479 response");
20646 if (r->call)
20647 r->call = dialog_unref(r->call, "unsetting registry->call pointer-- case 479");
20648 r->regstate = REG_STATE_REJECTED;
20649 AST_SCHED_DEL_UNREF(sched, r->timeout, registry_unref(r, "reg ptr unref from handle_response_register 479"));
20650 break;
20651 case 200:
20652 if (!r) {
20653 ast_log(LOG_WARNING, "Got 200 OK on REGISTER, but there isn't a registry entry for '%s' (we probably already got the OK)\n", S_OR(p->peername, p->username));
20654 pvt_set_needdestroy(p, "received erroneous 200 response");
20655 return 0;
20656 }
20657
20658 r->regstate = REG_STATE_REGISTERED;
20659 r->regtime = ast_tvnow();
20660 manager_event(EVENT_FLAG_SYSTEM, "Registry", "ChannelType: SIP\r\nDomain: %s\r\nStatus: %s\r\n", r->hostname, regstate2str(r->regstate));
20661 r->regattempts = 0;
20662 ast_debug(1, "Registration successful\n");
20663 if (r->timeout > -1) {
20664 ast_debug(1, "Cancelling timeout %d\n", r->timeout);
20665 }
20666 AST_SCHED_DEL_UNREF(sched, r->timeout, registry_unref(r, "reg ptr unref from handle_response_register 200"));
20667 if (r->call)
20668 r->call = dialog_unref(r->call, "unsetting registry->call pointer-- case 200");
20669 p->registry = registry_unref(p->registry, "unref registry entry p->registry");
20670
20671 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
20672
20673
20674
20675
20676
20677
20678 expires = 0;
20679
20680
20681 if (!ast_strlen_zero(get_header(req, "Contact"))) {
20682 const char *contact = NULL;
20683 const char *tmptmp = NULL;
20684 int start = 0;
20685 for(;;) {
20686 contact = __get_header(req, "Contact", &start);
20687
20688 if(!ast_strlen_zero(contact)) {
20689 if( (tmptmp=strstr(contact, p->our_contact))) {
20690 contact=tmptmp;
20691 break;
20692 }
20693 } else
20694 break;
20695 }
20696 tmptmp = strcasestr(contact, "expires=");
20697 if (tmptmp) {
20698 if (sscanf(tmptmp + 8, "%30d;", &expires) != 1)
20699 expires = 0;
20700 }
20701
20702 }
20703 if (!expires)
20704 expires=atoi(get_header(req, "expires"));
20705 if (!expires)
20706 expires=default_expiry;
20707
20708 expires_ms = expires * 1000;
20709 if (expires <= EXPIRY_GUARD_LIMIT)
20710 expires_ms -= MAX((expires_ms * EXPIRY_GUARD_PCT), EXPIRY_GUARD_MIN);
20711 else
20712 expires_ms -= EXPIRY_GUARD_SECS * 1000;
20713 if (sipdebug)
20714 ast_log(LOG_NOTICE, "Outbound Registration: Expiry for %s is %d sec (Scheduling reregistration in %d s)\n", r->hostname, expires, expires_ms/1000);
20715
20716 r->refresh= (int) expires_ms / 1000;
20717
20718
20719 AST_SCHED_REPLACE_UNREF(r->expire, sched, expires_ms, sip_reregister, r,
20720 registry_unref(_data,"unref in REPLACE del fail"),
20721 registry_unref(r,"unref in REPLACE add fail"),
20722 registry_addref(r,"The Addition side of REPLACE"));
20723 }
20724 return 1;
20725 }
20726
20727
20728 static void handle_response_peerpoke(struct sip_pvt *p, int resp, struct sip_request *req)
20729 {
20730 struct sip_peer *peer = p->relatedpeer ;
20731 int statechanged, is_reachable, was_reachable;
20732 int pingtime = ast_tvdiff_ms(ast_tvnow(), peer->ps);
20733
20734
20735
20736
20737
20738
20739 if (pingtime < 1) {
20740 pingtime = 1;
20741 }
20742
20743 if (!peer->maxms) {
20744 pvt_set_needdestroy(p, "got OPTIONS response but qualify is not enabled");
20745 return;
20746 }
20747
20748
20749
20750
20751
20752 was_reachable = peer->lastms > 0 && peer->lastms <= peer->maxms;
20753 is_reachable = pingtime <= peer->maxms;
20754 statechanged = peer->lastms == 0
20755 || was_reachable != is_reachable;
20756
20757 peer->lastms = pingtime;
20758 peer->call = dialog_unref(peer->call, "unref dialog peer->call");
20759 if (statechanged) {
20760 const char *s = is_reachable ? "Reachable" : "Lagged";
20761 char str_lastms[20];
20762 snprintf(str_lastms, sizeof(str_lastms), "%d", pingtime);
20763
20764 ast_log(LOG_NOTICE, "Peer '%s' is now %s. (%dms / %dms)\n",
20765 peer->name, s, pingtime, peer->maxms);
20766 ast_devstate_changed(AST_DEVICE_UNKNOWN, "SIP/%s", peer->name);
20767 if (sip_cfg.peer_rtupdate) {
20768 ast_update_realtime(ast_check_realtime("sipregs") ? "sipregs" : "sippeers", "name", peer->name, "lastms", str_lastms, SENTINEL);
20769 }
20770 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus",
20771 "ChannelType: SIP\r\nPeer: SIP/%s\r\nPeerStatus: %s\r\nTime: %d\r\n",
20772 peer->name, s, pingtime);
20773 if (is_reachable && sip_cfg.regextenonqualify)
20774 register_peer_exten(peer, TRUE);
20775 }
20776
20777 pvt_set_needdestroy(p, "got OPTIONS response");
20778
20779
20780 AST_SCHED_REPLACE_UNREF(peer->pokeexpire, sched,
20781 is_reachable ? peer->qualifyfreq : DEFAULT_FREQ_NOTOK,
20782 sip_poke_peer_s, peer,
20783 unref_peer(_data, "removing poke peer ref"),
20784 unref_peer(peer, "removing poke peer ref"),
20785 ref_peer(peer, "adding poke peer ref"));
20786 }
20787
20788
20789
20790
20791
20792
20793
20794
20795 static void handle_response_info(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno)
20796 {
20797 int sipmethod = SIP_INFO;
20798
20799 switch (resp) {
20800 case 401:
20801 case 407:
20802 ast_log(LOG_WARNING, "Host '%s' requests authentication (%d) for '%s'\n",
20803 ast_sockaddr_stringify(&p->sa), resp, sip_methods[sipmethod].text);
20804 break;
20805 case 405:
20806 case 501:
20807 mark_method_unallowed(&p->allowed_methods, sipmethod);
20808 if (p->relatedpeer) {
20809 mark_method_allowed(&p->relatedpeer->disallowed_methods, sipmethod);
20810 }
20811 ast_log(LOG_WARNING, "Host '%s' does not implement '%s'\n",
20812 ast_sockaddr_stringify(&p->sa), sip_methods[sipmethod].text);
20813 break;
20814 default:
20815 if (300 <= resp && resp < 700) {
20816 ast_verb(3, "Got SIP %s response %d \"%s\" back from host '%s'\n",
20817 sip_methods[sipmethod].text, resp, rest, ast_sockaddr_stringify(&p->sa));
20818 }
20819 break;
20820 }
20821 }
20822
20823
20824
20825
20826
20827
20828
20829
20830
20831 static void handle_response_message(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno)
20832 {
20833 int sipmethod = SIP_MESSAGE;
20834
20835
20836
20837 switch (resp) {
20838 case 401:
20839 case 407:
20840 ast_log(LOG_WARNING, "Host '%s' requests authentication (%d) for '%s'\n",
20841 ast_sockaddr_stringify(&p->sa), resp, sip_methods[sipmethod].text);
20842 break;
20843 case 405:
20844 case 501:
20845 mark_method_unallowed(&p->allowed_methods, sipmethod);
20846 if (p->relatedpeer) {
20847 mark_method_allowed(&p->relatedpeer->disallowed_methods, sipmethod);
20848 }
20849 ast_log(LOG_WARNING, "Host '%s' does not implement '%s'\n",
20850 ast_sockaddr_stringify(&p->sa), sip_methods[sipmethod].text);
20851 break;
20852 default:
20853 if (100 <= resp && resp < 200) {
20854
20855 } else if (200 <= resp && resp < 300) {
20856 p->authtries = 0;
20857 } else if (300 <= resp && resp < 700) {
20858 ast_verb(3, "Got SIP %s response %d \"%s\" back from host '%s'\n",
20859 sip_methods[sipmethod].text, resp, rest, ast_sockaddr_stringify(&p->sa));
20860 }
20861 break;
20862 }
20863 }
20864
20865
20866 static void stop_media_flows(struct sip_pvt *p)
20867 {
20868
20869 if (p->rtp)
20870 ast_rtp_instance_stop(p->rtp);
20871 if (p->vrtp)
20872 ast_rtp_instance_stop(p->vrtp);
20873 if (p->trtp)
20874 ast_rtp_instance_stop(p->trtp);
20875 if (p->udptl)
20876 ast_udptl_stop(p->udptl);
20877 }
20878
20879
20880
20881 static void handle_response(struct sip_pvt *p, int resp, const char *rest, struct sip_request *req, int seqno)
20882 {
20883 struct ast_channel *owner;
20884 int sipmethod;
20885 const char *c = get_header(req, "Cseq");
20886
20887 char *c_copy = ast_strdupa(c);
20888
20889 const char *msg = ast_skip_blanks(ast_skip_nonblanks(c_copy));
20890
20891 if (!msg)
20892 msg = "";
20893
20894 sipmethod = find_sip_method(msg);
20895
20896 owner = p->owner;
20897 if (owner) {
20898 const char *rp = NULL, *rh = NULL;
20899
20900 owner->hangupcause = 0;
20901 if (ast_test_flag(&p->flags[1], SIP_PAGE2_Q850_REASON) && (rh = get_header(req, "Reason"))) {
20902 rh = ast_skip_blanks(rh);
20903 if (!strncasecmp(rh, "Q.850", 5)) {
20904 rp = strstr(rh, "cause=");
20905 if (rp && sscanf(rp + 6, "%30d", &owner->hangupcause) == 1) {
20906 owner->hangupcause &= 0x7f;
20907 if (req->debug)
20908 ast_verbose("Using Reason header for cause code: %d\n", owner->hangupcause);
20909 }
20910 }
20911 }
20912
20913 if (!owner->hangupcause)
20914 owner->hangupcause = hangup_sip2cause(resp);
20915 }
20916
20917 if (p->socket.type == SIP_TRANSPORT_UDP) {
20918 int ack_res = FALSE;
20919
20920
20921 if ((resp >= 100) && (resp <= 199)) {
20922
20923 if (sipmethod == SIP_INVITE) {
20924 ack_res = __sip_semi_ack(p, seqno, 0, sipmethod);
20925 }
20926 } else {
20927 ack_res = __sip_ack(p, seqno, 0, sipmethod);
20928 }
20929
20930 if (ack_res == FALSE) {
20931
20932 if (sipmethod == SIP_INVITE && resp >= 200) {
20933 transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, resp < 300 ? TRUE: FALSE);
20934 }
20935
20936 append_history(p, "Ignore", "Ignoring this retransmit\n");
20937 return;
20938 }
20939 }
20940
20941
20942 if (!p->owner && sipmethod == SIP_NOTIFY && p->pendinginvite)
20943 p->pendinginvite = 0;
20944
20945
20946 if (ast_strlen_zero(p->theirtag) || (resp >= 200)) {
20947 char tag[128];
20948
20949 gettag(req, "To", tag, sizeof(tag));
20950 ast_string_field_set(p, theirtag, tag);
20951 }
20952
20953
20954
20955
20956
20957
20958
20959
20960
20961
20962
20963
20964
20965
20966
20967 if ((resp == 404 || resp == 408 || resp == 481) && sipmethod == SIP_BYE) {
20968 pvt_set_needdestroy(p, "received 4XX response to a BYE");
20969 return;
20970 }
20971
20972 if (p->relatedpeer && sipmethod == SIP_OPTIONS) {
20973
20974
20975
20976 if (resp != 100)
20977 handle_response_peerpoke(p, resp, req);
20978 } else if (sipmethod == SIP_REFER && resp >= 200) {
20979 handle_response_refer(p, resp, rest, req, seqno);
20980 } else if (sipmethod == SIP_PUBLISH) {
20981
20982
20983
20984 handle_response_publish(p, resp, rest, req, seqno);
20985 } else if (sipmethod == SIP_INFO) {
20986
20987 handle_response_info(p, resp, rest, req, seqno);
20988 } else if (sipmethod == SIP_MESSAGE) {
20989
20990 handle_response_message(p, resp, rest, req, seqno);
20991 } else if (sipmethod == SIP_NOTIFY) {
20992
20993 handle_response_notify(p, resp, rest, req, seqno);
20994 } else if (ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
20995 switch(resp) {
20996 case 100:
20997 case 101:
20998 case 183:
20999 case 180:
21000 case 182:
21001 case 181:
21002 if (sipmethod == SIP_INVITE)
21003 handle_response_invite(p, resp, rest, req, seqno);
21004 break;
21005 case 200:
21006 p->authtries = 0;
21007 if (sipmethod == SIP_INVITE) {
21008 handle_response_invite(p, resp, rest, req, seqno);
21009 } else if (sipmethod == SIP_REGISTER) {
21010 handle_response_register(p, resp, rest, req, seqno);
21011 } else if (sipmethod == SIP_SUBSCRIBE) {
21012 ast_set_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
21013 handle_response_subscribe(p, resp, rest, req, seqno);
21014 } else if (sipmethod == SIP_BYE) {
21015 pvt_set_needdestroy(p, "received 200 response");
21016 ast_clear_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
21017 }
21018 break;
21019 case 401:
21020 case 407:
21021 if (sipmethod == SIP_INVITE)
21022 handle_response_invite(p, resp, rest, req, seqno);
21023 else if (sipmethod == SIP_SUBSCRIBE)
21024 handle_response_subscribe(p, resp, rest, req, seqno);
21025 else if (p->registry && sipmethod == SIP_REGISTER)
21026 handle_response_register(p, resp, rest, req, seqno);
21027 else if (sipmethod == SIP_UPDATE) {
21028 handle_response_update(p, resp, rest, req, seqno);
21029 } else if (sipmethod == SIP_BYE) {
21030 if (p->options)
21031 p->options->auth_type = resp;
21032 if (ast_strlen_zero(p->authname)) {
21033 ast_log(LOG_WARNING, "Asked to authenticate %s, to %s but we have no matching peer!\n",
21034 msg, ast_sockaddr_stringify(&p->recv));
21035 pvt_set_needdestroy(p, "unable to authenticate BYE");
21036 } else if ((p->authtries == MAX_AUTHTRIES) || do_proxy_auth(p, req, resp, sipmethod, 0)) {
21037 ast_log(LOG_NOTICE, "Failed to authenticate on %s to '%s'\n", msg, get_header(&p->initreq, "From"));
21038 pvt_set_needdestroy(p, "failed to authenticate BYE");
21039 }
21040 } else {
21041 ast_log(LOG_WARNING, "Got authentication request (%d) on %s to '%s'\n", resp, sip_methods[sipmethod].text, get_header(req, "To"));
21042 pvt_set_needdestroy(p, "received 407 response");
21043 }
21044 break;
21045 case 403:
21046 if (sipmethod == SIP_INVITE)
21047 handle_response_invite(p, resp, rest, req, seqno);
21048 else if (sipmethod == SIP_SUBSCRIBE)
21049 handle_response_subscribe(p, resp, rest, req, seqno);
21050 else if (p->registry && sipmethod == SIP_REGISTER)
21051 handle_response_register(p, resp, rest, req, seqno);
21052 else {
21053 ast_log(LOG_WARNING, "Forbidden - maybe wrong password on authentication for %s\n", msg);
21054 pvt_set_needdestroy(p, "received 403 response");
21055 }
21056 break;
21057 case 404:
21058 if (p->registry && sipmethod == SIP_REGISTER)
21059 handle_response_register(p, resp, rest, req, seqno);
21060 else if (sipmethod == SIP_INVITE)
21061 handle_response_invite(p, resp, rest, req, seqno);
21062 else if (sipmethod == SIP_SUBSCRIBE)
21063 handle_response_subscribe(p, resp, rest, req, seqno);
21064 else if (owner)
21065 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
21066 break;
21067 case 423:
21068 if (sipmethod == SIP_REGISTER)
21069 handle_response_register(p, resp, rest, req, seqno);
21070 break;
21071 case 408:
21072 if (sipmethod == SIP_INVITE)
21073 handle_response_invite(p, resp, rest, req, seqno);
21074 else if (sipmethod == SIP_REGISTER)
21075 handle_response_register(p, resp, rest, req, seqno);
21076 else if (sipmethod == SIP_BYE) {
21077 pvt_set_needdestroy(p, "received 408 response");
21078 ast_debug(4, "Got timeout on bye. Thanks for the answer. Now, kill this call\n");
21079 } else {
21080 if (owner)
21081 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
21082 pvt_set_needdestroy(p, "received 408 response");
21083 }
21084 break;
21085
21086 case 428:
21087 case 422:
21088 if (sipmethod == SIP_INVITE) {
21089 handle_response_invite(p, resp, rest, req, seqno);
21090 }
21091 break;
21092
21093 case 481:
21094 if (sipmethod == SIP_INVITE) {
21095 handle_response_invite(p, resp, rest, req, seqno);
21096 } else if (sipmethod == SIP_SUBSCRIBE) {
21097 handle_response_subscribe(p, resp, rest, req, seqno);
21098 } else if (sipmethod == SIP_BYE) {
21099
21100
21101 ast_log(LOG_WARNING, "Remote host can't match request %s to call '%s'. Giving up.\n", sip_methods[sipmethod].text, p->callid);
21102 } else if (sipmethod == SIP_CANCEL) {
21103
21104
21105 ast_log(LOG_WARNING, "Remote host can't match request %s to call '%s'. Giving up.\n", sip_methods[sipmethod].text, p->callid);
21106 } else {
21107 ast_log(LOG_WARNING, "Remote host can't match request %s to call '%s'. Giving up.\n", sip_methods[sipmethod].text, p->callid);
21108
21109 }
21110 break;
21111 case 487:
21112 if (sipmethod == SIP_INVITE)
21113 handle_response_invite(p, resp, rest, req, seqno);
21114 break;
21115 case 415:
21116 case 488:
21117 case 606:
21118 if (sipmethod == SIP_INVITE)
21119 handle_response_invite(p, resp, rest, req, seqno);
21120 break;
21121 case 491:
21122 if (sipmethod == SIP_INVITE)
21123 handle_response_invite(p, resp, rest, req, seqno);
21124 else {
21125 ast_debug(1, "Got 491 on %s, unsupported. Call ID %s\n", sip_methods[sipmethod].text, p->callid);
21126 pvt_set_needdestroy(p, "received 491 response");
21127 }
21128 break;
21129 case 405:
21130 case 501:
21131 mark_method_unallowed(&p->allowed_methods, sipmethod);
21132 if (p->relatedpeer) {
21133 mark_method_allowed(&p->relatedpeer->disallowed_methods, sipmethod);
21134 }
21135 if (sipmethod == SIP_INVITE)
21136 handle_response_invite(p, resp, rest, req, seqno);
21137 else
21138 ast_log(LOG_WARNING, "Host '%s' does not implement '%s'\n", ast_sockaddr_stringify(&p->sa), msg);
21139 break;
21140 default:
21141 if ((resp >= 300) && (resp < 700)) {
21142
21143 if ((resp != 487))
21144 ast_verb(3, "Got SIP response %d \"%s\" back from %s\n", resp, rest, ast_sockaddr_stringify(&p->sa));
21145
21146 if (sipmethod == SIP_INVITE)
21147 stop_media_flows(p);
21148
21149
21150 switch(resp) {
21151 case 300:
21152 case 301:
21153 case 302:
21154 case 305:
21155 if (p->owner) {
21156 struct ast_party_redirecting redirecting;
21157 struct ast_set_party_redirecting update_redirecting;
21158
21159 ast_party_redirecting_init(&redirecting);
21160 change_redirecting_information(p, req, &redirecting,
21161 &update_redirecting, TRUE);
21162 ast_channel_set_redirecting(p->owner, &redirecting,
21163 &update_redirecting);
21164 ast_party_redirecting_free(&redirecting);
21165 }
21166
21167 case 486:
21168 case 600:
21169 case 603:
21170 if (p->owner) {
21171 sip_handle_cc(p, req, AST_CC_CCBS);
21172 ast_queue_control(p->owner, AST_CONTROL_BUSY);
21173 }
21174 break;
21175 case 482:
21176 case 480:
21177 case 404:
21178 case 410:
21179 case 400:
21180 case 500:
21181 if (sipmethod == SIP_SUBSCRIBE) {
21182 handle_response_subscribe(p, resp, rest, req, seqno);
21183 break;
21184 }
21185
21186 case 502:
21187 case 503:
21188 case 504:
21189 if (owner)
21190 ast_queue_control(p->owner, AST_CONTROL_CONGESTION);
21191 break;
21192 case 484:
21193 if (owner && sipmethod != SIP_BYE) {
21194 switch (ast_test_flag(&p->flags[1], SIP_PAGE2_ALLOWOVERLAP)) {
21195 case SIP_PAGE2_ALLOWOVERLAP_YES:
21196 ast_queue_hangup_with_cause(p->owner, hangup_sip2cause(resp));
21197 break;
21198 default:
21199 ast_queue_hangup_with_cause(p->owner, hangup_sip2cause(404));
21200 break;
21201 }
21202 }
21203 break;
21204 default:
21205
21206 if (owner && sipmethod != SIP_BYE)
21207 ast_queue_hangup_with_cause(p->owner, AST_CAUSE_PROTOCOL_ERROR);
21208 break;
21209 }
21210
21211 if (sipmethod == SIP_INVITE)
21212 transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
21213 sip_alreadygone(p);
21214 if (!p->owner) {
21215 pvt_set_needdestroy(p, "transaction completed");
21216 }
21217 } else if ((resp >= 100) && (resp < 200)) {
21218 if (sipmethod == SIP_INVITE) {
21219 if (!req->ignore && sip_cancel_destroy(p))
21220 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
21221 if (find_sdp(req))
21222 process_sdp(p, req, SDP_T38_NONE);
21223 if (p->owner) {
21224
21225 ast_queue_control(p->owner, AST_CONTROL_PROGRESS);
21226 }
21227 }
21228 } else
21229 ast_log(LOG_NOTICE, "Don't know how to handle a %d %s response from %s\n", resp, rest, p->owner ? p->owner->name : ast_sockaddr_stringify(&p->sa));
21230 }
21231 } else {
21232
21233
21234 if (req->debug)
21235 ast_verbose("SIP Response message for INCOMING dialog %s arrived\n", msg);
21236
21237 if (sipmethod == SIP_INVITE && resp == 200) {
21238
21239
21240 char tag[128];
21241
21242 gettag(req, "To", tag, sizeof(tag));
21243 ast_string_field_set(p, theirtag, tag);
21244 }
21245
21246 switch(resp) {
21247 case 200:
21248 if (sipmethod == SIP_INVITE) {
21249 handle_response_invite(p, resp, rest, req, seqno);
21250 } else if (sipmethod == SIP_CANCEL) {
21251 ast_debug(1, "Got 200 OK on CANCEL\n");
21252
21253
21254 } else if (sipmethod == SIP_BYE) {
21255 pvt_set_needdestroy(p, "transaction completed");
21256 }
21257 break;
21258 case 401:
21259 case 407:
21260 if (sipmethod == SIP_INVITE)
21261 handle_response_invite(p, resp, rest, req, seqno);
21262 else if (sipmethod == SIP_BYE) {
21263 if (p->authtries == MAX_AUTHTRIES || do_proxy_auth(p, req, resp, sipmethod, 0)) {
21264 ast_log(LOG_NOTICE, "Failed to authenticate on %s to '%s'\n", msg, get_header(&p->initreq, "From"));
21265 pvt_set_needdestroy(p, "failed to authenticate BYE");
21266 }
21267 }
21268 break;
21269 case 481:
21270 if (sipmethod == SIP_INVITE) {
21271
21272 handle_response_invite(p, resp, rest, req, seqno);
21273 } else if (sipmethod == SIP_BYE) {
21274 pvt_set_needdestroy(p, "received 481 response");
21275 } else if (sipdebug) {
21276 ast_debug(1, "Remote host can't match request %s to call '%s'. Giving up\n", sip_methods[sipmethod].text, p->callid);
21277 }
21278 break;
21279 case 501:
21280 if (sipmethod == SIP_INVITE)
21281 handle_response_invite(p, resp, rest, req, seqno);
21282 break;
21283 default:
21284 if ((resp >= 100) && (resp < 200)) {
21285 if (sipmethod == SIP_INVITE) {
21286 if (!req->ignore && sip_cancel_destroy(p))
21287 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
21288 }
21289 }
21290 if ((resp >= 300) && (resp < 700)) {
21291 if ((resp != 487))
21292 ast_verb(3, "Incoming call: Got SIP response %d \"%s\" back from %s\n", resp, rest, ast_sockaddr_stringify(&p->sa));
21293 switch(resp) {
21294 case 415:
21295 case 488:
21296 case 603:
21297 case 500:
21298 case 502:
21299 case 503:
21300 case 504:
21301
21302
21303 if (sipmethod == SIP_INVITE && sip_cancel_destroy(p))
21304 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
21305 break;
21306 }
21307 }
21308 break;
21309 }
21310 }
21311 }
21312
21313
21314
21315
21316
21317
21318
21319 static void *sip_park_thread(void *stuff)
21320 {
21321 struct ast_channel *transferee, *transferer;
21322 struct sip_dual *d;
21323 int ext;
21324 int res;
21325
21326 d = stuff;
21327 transferee = d->chan1;
21328 transferer = d->chan2;
21329
21330 ast_debug(4, "SIP Park: Transferer channel %s, Transferee %s\n", transferer->name, transferee->name);
21331
21332 res = ast_park_call_exten(transferee, transferer, d->park_exten, d->park_context, 0, &ext);
21333
21334 #ifdef WHEN_WE_KNOW_THAT_THE_CLIENT_SUPPORTS_MESSAGE
21335 if (res) {
21336 transmit_message_with_text(transferer->tech_pvt, "Unable to park call.\n");
21337 } else {
21338
21339 sprintf(buf, "Call parked on extension '%d'", ext);
21340 transmit_message_with_text(transferer->tech_pvt, buf);
21341 }
21342 #endif
21343
21344
21345
21346 if (!res) {
21347
21348 append_history(transferer->tech_pvt, "SIPpark", "Parked call on %d", ext);
21349 transmit_notify_with_sipfrag(transferer->tech_pvt, d->seqno, "200 OK", TRUE);
21350 transferer->hangupcause = AST_CAUSE_NORMAL_CLEARING;
21351 ast_hangup(transferer);
21352 ast_debug(1, "SIP Call parked on extension '%d'\n", ext);
21353 } else {
21354 transmit_notify_with_sipfrag(transferer->tech_pvt, d->seqno, "503 Service Unavailable", TRUE);
21355 append_history(transferer->tech_pvt, "SIPpark", "Parking failed\n");
21356 ast_debug(1, "SIP Call parked failed \n");
21357
21358 }
21359 deinit_req(&d->req);
21360 ast_free(d->park_exten);
21361 ast_free(d->park_context);
21362 ast_free(d);
21363 return NULL;
21364 }
21365
21366
21367 static int sip_park(struct ast_channel *chan1, struct ast_channel *chan2, struct sip_request *req, int seqno, const char *park_exten, const char *park_context)
21368 {
21369 struct sip_dual *d;
21370 struct ast_channel *transferee, *transferer;
21371 pthread_t th;
21372
21373 transferee = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, chan1->accountcode, chan1->exten, chan1->context, chan1->linkedid, chan1->amaflags, "Parking/%s", chan1->name);
21374 transferer = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, chan2->accountcode, chan2->exten, chan2->context, chan2->linkedid, chan2->amaflags, "SIPPeer/%s", chan2->name);
21375 d = ast_calloc(1, sizeof(*d));
21376 if (!transferee || !transferer || !d) {
21377 if (transferee) {
21378 ast_hangup(transferee);
21379 }
21380 if (transferer) {
21381 ast_hangup(transferer);
21382 }
21383 ast_free(d);
21384 return -1;
21385 }
21386 d->park_exten = ast_strdup(park_exten);
21387 d->park_context = ast_strdup(park_context);
21388 if (!d->park_exten || !d->park_context) {
21389 ast_hangup(transferee);
21390 ast_hangup(transferer);
21391 ast_free(d->park_exten);
21392 ast_free(d->park_context);
21393 ast_free(d);
21394 return -1;
21395 }
21396
21397
21398 transferee->readformat = chan1->readformat;
21399 transferee->writeformat = chan1->writeformat;
21400
21401
21402 if (ast_channel_masquerade(transferee, chan1)) {
21403 ast_hangup(transferee);
21404 ast_hangup(transferer);
21405 ast_free(d->park_exten);
21406 ast_free(d->park_context);
21407 ast_free(d);
21408 return -1;
21409 }
21410
21411
21412 ast_copy_string(transferee->context, chan1->context, sizeof(transferee->context));
21413 ast_copy_string(transferee->exten, chan1->exten, sizeof(transferee->exten));
21414 transferee->priority = chan1->priority;
21415
21416 ast_do_masquerade(transferee);
21417
21418
21419
21420
21421
21422 transferer->readformat = chan2->readformat;
21423 transferer->writeformat = chan2->writeformat;
21424 ast_string_field_set(transferer, parkinglot, chan2->parkinglot);
21425
21426
21427 if (ast_channel_masquerade(transferer, chan2)) {
21428 ast_hangup(transferer);
21429 ast_free(d->park_exten);
21430 ast_free(d->park_context);
21431 ast_free(d);
21432 return -1;
21433 }
21434
21435
21436 ast_copy_string(transferer->context, chan2->context, sizeof(transferer->context));
21437 ast_copy_string(transferer->exten, chan2->exten, sizeof(transferer->exten));
21438 transferer->priority = chan2->priority;
21439
21440 ast_do_masquerade(transferer);
21441
21442
21443 copy_request(&d->req, req);
21444 d->chan1 = transferee;
21445 d->chan2 = transferer;
21446 d->seqno = seqno;
21447 if (ast_pthread_create_detached_background(&th, NULL, sip_park_thread, d) < 0) {
21448
21449 deinit_req(&d->req);
21450 ast_free(d->park_exten);
21451 ast_free(d->park_context);
21452 ast_free(d);
21453
21454 return -1;
21455 }
21456 return 0;
21457 }
21458
21459
21460
21461
21462
21463 static void *sip_pickup_thread(void *stuff)
21464 {
21465 struct ast_channel *chan;
21466 chan = stuff;
21467
21468 if (ast_pickup_call(chan)) {
21469 chan->hangupcause = AST_CAUSE_CALL_REJECTED;
21470 } else {
21471 chan->hangupcause = AST_CAUSE_NORMAL_CLEARING;
21472 }
21473 ast_hangup(chan);
21474 ast_channel_unref(chan);
21475 chan = NULL;
21476 return NULL;
21477 }
21478
21479
21480
21481
21482 static int sip_pickup(struct ast_channel *chan)
21483 {
21484 pthread_t threadid;
21485
21486 ast_channel_ref(chan);
21487
21488 if (ast_pthread_create_detached_background(&threadid, NULL, sip_pickup_thread, chan)) {
21489 ast_debug(1, "Unable to start Group pickup thread on channel %s\n", chan->name);
21490 ast_channel_unref(chan);
21491 return -1;
21492 }
21493 ast_debug(1, "Started Group pickup thread on channel %s\n", chan->name);
21494 return 0;
21495 }
21496
21497
21498
21499
21500
21501 static void ast_quiet_chan(struct ast_channel *chan)
21502 {
21503 if (chan && chan->_state == AST_STATE_UP) {
21504 if (ast_test_flag(chan, AST_FLAG_MOH))
21505 ast_moh_stop(chan);
21506 else if (chan->generatordata)
21507 ast_deactivate_generator(chan);
21508 }
21509 }
21510
21511
21512
21513 static int attempt_transfer(struct sip_dual *transferer, struct sip_dual *target)
21514 {
21515 int res = 0;
21516 struct ast_channel *peera = NULL,
21517 *peerb = NULL,
21518 *peerc = NULL,
21519 *peerd = NULL;
21520
21521
21522
21523
21524 ast_debug(4, "Sip transfer:--------------------\n");
21525 if (transferer->chan1)
21526 ast_debug(4, "-- Transferer to PBX channel: %s State %s\n", transferer->chan1->name, ast_state2str(transferer->chan1->_state));
21527 else
21528 ast_debug(4, "-- No transferer first channel - odd??? \n");
21529 if (target->chan1)
21530 ast_debug(4, "-- Transferer to PBX second channel (target): %s State %s\n", target->chan1->name, ast_state2str(target->chan1->_state));
21531 else
21532 ast_debug(4, "-- No target first channel ---\n");
21533 if (transferer->chan2)
21534 ast_debug(4, "-- Bridged call to transferee: %s State %s\n", transferer->chan2->name, ast_state2str(transferer->chan2->_state));
21535 else
21536 ast_debug(4, "-- No bridged call to transferee\n");
21537 if (target->chan2)
21538 ast_debug(4, "-- Bridged call to transfer target: %s State %s\n", target->chan2 ? target->chan2->name : "<none>", target->chan2 ? ast_state2str(target->chan2->_state) : "(none)");
21539 else
21540 ast_debug(4, "-- No target second channel ---\n");
21541 ast_debug(4, "-- END Sip transfer:--------------------\n");
21542 if (transferer->chan2) {
21543 peera = transferer->chan1;
21544 peerb = target->chan1;
21545 peerc = transferer->chan2;
21546 peerd = target->chan2;
21547 ast_debug(3, "SIP transfer: Four channels to handle\n");
21548 } else if (target->chan2) {
21549 peera = target->chan1;
21550 peerb = transferer->chan1;
21551 peerc = target->chan2;
21552 peerd = transferer->chan2;
21553 ast_debug(3, "SIP transfer: Three channels to handle\n");
21554 }
21555
21556 if (peera && peerb && peerc && (peerb != peerc)) {
21557 ast_quiet_chan(peera);
21558 ast_quiet_chan(peerb);
21559 ast_quiet_chan(peerc);
21560 if (peerd)
21561 ast_quiet_chan(peerd);
21562
21563 ast_debug(4, "SIP transfer: trying to masquerade %s into %s\n", peerc->name, peerb->name);
21564 if (ast_channel_masquerade(peerb, peerc)) {
21565 ast_log(LOG_WARNING, "Failed to masquerade %s into %s\n", peerb->name, peerc->name);
21566 res = -1;
21567 } else
21568 ast_debug(4, "SIP transfer: Succeeded to masquerade channels.\n");
21569 return res;
21570 } else {
21571 ast_log(LOG_NOTICE, "SIP Transfer attempted with no appropriate bridged calls to transfer\n");
21572 if (transferer->chan1)
21573 ast_softhangup_nolock(transferer->chan1, AST_SOFTHANGUP_DEV);
21574 if (target->chan1)
21575 ast_softhangup_nolock(target->chan1, AST_SOFTHANGUP_DEV);
21576 return -1;
21577 }
21578 return 0;
21579 }
21580
21581
21582
21583
21584
21585
21586 static const char *gettag(const struct sip_request *req, const char *header, char *tagbuf, int tagbufsize)
21587 {
21588 const char *thetag;
21589
21590 if (!tagbuf)
21591 return NULL;
21592 tagbuf[0] = '\0';
21593 thetag = get_header(req, header);
21594 thetag = strcasestr(thetag, ";tag=");
21595 if (thetag) {
21596 thetag += 5;
21597 ast_copy_string(tagbuf, thetag, tagbufsize);
21598 return strsep(&tagbuf, ";");
21599 }
21600 return NULL;
21601 }
21602
21603 static int handle_cc_notify(struct sip_pvt *pvt, struct sip_request *req)
21604 {
21605 struct sip_monitor_instance *monitor_instance = ao2_callback(sip_monitor_instances, 0,
21606 find_sip_monitor_instance_by_subscription_pvt, pvt);
21607 const char *status = get_body(req, "cc-state", ':');
21608 struct cc_epa_entry *cc_entry;
21609 char *uri;
21610
21611 if (!monitor_instance) {
21612 transmit_response(pvt, "400 Bad Request", req);
21613 return -1;
21614 }
21615
21616 if (ast_strlen_zero(status)) {
21617 ao2_ref(monitor_instance, -1);
21618 transmit_response(pvt, "400 Bad Request", req);
21619 return -1;
21620 }
21621
21622 if (!strcmp(status, "queued")) {
21623
21624
21625
21626
21627 ast_cc_monitor_request_acked(monitor_instance->core_id, "SIP endpoint %s accepted request", monitor_instance->device_name);
21628 transmit_response(pvt, "200 OK", req);
21629 ao2_ref(monitor_instance, -1);
21630 return 0;
21631 }
21632
21633
21634 uri = get_body(req, "cc-URI", ':');
21635 if (ast_strlen_zero(uri)) {
21636 uri = get_in_brackets((char *)get_header(req, "From"));
21637 }
21638
21639 ast_string_field_set(monitor_instance, notify_uri, uri);
21640 if (monitor_instance->suspension_entry) {
21641 cc_entry = monitor_instance->suspension_entry->instance_data;
21642 if (cc_entry->current_state == CC_CLOSED) {
21643
21644
21645
21646
21647
21648 construct_pidf_body(CC_CLOSED, monitor_instance->suspension_entry->body,
21649 sizeof(monitor_instance->suspension_entry->body), monitor_instance->peername);
21650 transmit_publish(monitor_instance->suspension_entry, SIP_PUBLISH_INITIAL, monitor_instance->notify_uri);
21651 } else {
21652 ast_cc_monitor_callee_available(monitor_instance->core_id, "SIP monitored callee has become available");
21653 }
21654 } else {
21655 ast_cc_monitor_callee_available(monitor_instance->core_id, "SIP monitored callee has become available");
21656 }
21657 ao2_ref(monitor_instance, -1);
21658 transmit_response(pvt, "200 OK", req);
21659
21660 return 0;
21661 }
21662
21663
21664 static int handle_request_notify(struct sip_pvt *p, struct sip_request *req, struct ast_sockaddr *addr, int seqno, const char *e)
21665 {
21666
21667
21668 int res = 0;
21669 const char *event = get_header(req, "Event");
21670 char *sep;
21671
21672 if( (sep = strchr(event, ';')) ) {
21673 *sep++ = '\0';
21674 }
21675
21676 if (sipdebug)
21677 ast_debug(2, "Got NOTIFY Event: %s\n", event);
21678
21679 if (!strcmp(event, "refer")) {
21680
21681
21682
21683
21684
21685 char buf[1024];
21686 char *cmd, *code;
21687 int respcode;
21688 int success = TRUE;
21689
21690
21691
21692
21693
21694
21695
21696
21697 if (strncasecmp(get_header(req, "Content-Type"), "message/sipfrag", strlen("message/sipfrag"))) {
21698
21699 transmit_response(p, "400 Bad request", req);
21700 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
21701 return -1;
21702 }
21703
21704
21705 if (get_msg_text(buf, sizeof(buf), req)) {
21706 ast_log(LOG_WARNING, "Unable to retrieve attachment from NOTIFY %s\n", p->callid);
21707 transmit_response(p, "400 Bad request", req);
21708 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
21709 return -1;
21710 }
21711
21712
21713
21714
21715
21716
21717
21718
21719
21720
21721
21722
21723
21724
21725
21726
21727
21728
21729
21730
21731
21732 ast_debug(3, "* SIP Transfer NOTIFY Attachment: \n---%s\n---\n", buf);
21733 cmd = ast_skip_blanks(buf);
21734 code = cmd;
21735
21736 while(*code && (*code > 32)) {
21737 code++;
21738 }
21739 *code++ = '\0';
21740 code = ast_skip_blanks(code);
21741 sep = code;
21742 sep++;
21743 while(*sep && (*sep > 32)) {
21744 sep++;
21745 }
21746 *sep++ = '\0';
21747 respcode = atoi(code);
21748 switch (respcode) {
21749 case 200:
21750
21751 break;
21752 case 301:
21753 case 302:
21754
21755 success = FALSE;
21756 break;
21757 case 503:
21758 case 603:
21759
21760 success = FALSE;
21761 break;
21762 case 0:
21763
21764 ast_log(LOG_NOTICE, "Error parsing sipfrag in NOTIFY in response to REFER.\n");
21765 success = FALSE;
21766 break;
21767 default:
21768 if (respcode < 200) {
21769
21770 success = -1;
21771 } else {
21772 ast_log(LOG_NOTICE, "Got unknown code '%d' in NOTIFY in response to REFER.\n", respcode);
21773 success = FALSE;
21774 }
21775 break;
21776 }
21777 if (success == FALSE) {
21778 ast_log(LOG_NOTICE, "Transfer failed. Sorry. Nothing further to do with this call\n");
21779 }
21780
21781 if (p->owner && success != -1) {
21782 enum ast_control_transfer message = success ? AST_TRANSFER_SUCCESS : AST_TRANSFER_FAILED;
21783 ast_queue_control_data(p->owner, AST_CONTROL_TRANSFER, &message, sizeof(message));
21784 }
21785
21786 transmit_response(p, "200 OK", req);
21787 } else if (!strcmp(event, "message-summary")) {
21788 const char *mailbox = NULL;
21789 char *c = ast_strdupa(get_body(req, "Voice-Message", ':'));
21790
21791 if (!p->mwi) {
21792 struct sip_peer *peer = find_peer(NULL, &p->recv, TRUE, FINDPEERS, FALSE, p->socket.type);
21793
21794 if (peer) {
21795 mailbox = ast_strdupa(peer->unsolicited_mailbox);
21796 unref_peer(peer, "removing unsolicited mwi ref");
21797 }
21798 } else {
21799 mailbox = p->mwi->mailbox;
21800 }
21801
21802 if (!ast_strlen_zero(mailbox) && !ast_strlen_zero(c)) {
21803 char *old = strsep(&c, " ");
21804 char *new = strsep(&old, "/");
21805 struct ast_event *event;
21806
21807 if ((event = ast_event_new(AST_EVENT_MWI,
21808 AST_EVENT_IE_MAILBOX, AST_EVENT_IE_PLTYPE_STR, mailbox,
21809 AST_EVENT_IE_CONTEXT, AST_EVENT_IE_PLTYPE_STR, "SIP_Remote",
21810 AST_EVENT_IE_NEWMSGS, AST_EVENT_IE_PLTYPE_UINT, atoi(new),
21811 AST_EVENT_IE_OLDMSGS, AST_EVENT_IE_PLTYPE_UINT, atoi(old),
21812 AST_EVENT_IE_END))) {
21813 ast_event_queue_and_cache(event);
21814 }
21815 transmit_response(p, "200 OK", req);
21816 } else {
21817 transmit_response(p, "489 Bad event", req);
21818 res = -1;
21819 }
21820 } else if (!strcmp(event, "keep-alive")) {
21821
21822
21823 transmit_response(p, "200 OK", req);
21824 } else if (!strcmp(event, "call-completion")) {
21825 res = handle_cc_notify(p, req);
21826 } else {
21827
21828 transmit_response(p, "489 Bad event", req);
21829 res = -1;
21830 }
21831
21832 if (!p->lastinvite)
21833 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
21834
21835 return res;
21836 }
21837
21838
21839
21840
21841 static int handle_request_options(struct sip_pvt *p, struct sip_request *req, struct ast_sockaddr *addr, const char *e)
21842 {
21843 const char *msg;
21844 enum sip_get_dest_result gotdest;
21845 int res;
21846
21847 if (p->lastinvite) {
21848
21849 transmit_response_with_allow(p, "200 OK", req, 0);
21850 return 0;
21851 }
21852
21853 if (sip_cfg.auth_options_requests) {
21854
21855 copy_request(&p->initreq, req);
21856 set_pvt_allowed_methods(p, req);
21857 res = check_user(p, req, SIP_OPTIONS, e, XMIT_UNRELIABLE, addr);
21858 if (res == AUTH_CHALLENGE_SENT) {
21859 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
21860 return 0;
21861 }
21862 if (res < 0) {
21863 if (res == AUTH_FAKE_AUTH) {
21864 ast_log(LOG_NOTICE, "Sending fake auth rejection for device %s\n", get_header(req, "From"));
21865 transmit_fake_auth_response(p, SIP_OPTIONS, req, XMIT_UNRELIABLE);
21866 } else {
21867 ast_log(LOG_NOTICE, "Failed to authenticate device %s\n", get_header(req, "From"));
21868 transmit_response(p, "403 Forbidden", req);
21869 }
21870 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
21871 return 0;
21872 }
21873 }
21874
21875
21876 gotdest = get_destination(p, req, NULL);
21877 build_contact(p);
21878
21879 if (ast_strlen_zero(p->context))
21880 ast_string_field_set(p, context, sip_cfg.default_context);
21881
21882 if (ast_shutting_down()) {
21883 msg = "503 Unavailable";
21884 } else {
21885 msg = "404 Not Found";
21886 switch (gotdest) {
21887 case SIP_GET_DEST_INVALID_URI:
21888 msg = "416 Unsupported URI scheme";
21889 break;
21890 case SIP_GET_DEST_EXTEN_MATCHMORE:
21891 case SIP_GET_DEST_REFUSED:
21892 case SIP_GET_DEST_EXTEN_NOT_FOUND:
21893
21894 break;
21895 case SIP_GET_DEST_EXTEN_FOUND:
21896 msg = "200 OK";
21897 break;
21898 }
21899 }
21900 transmit_response_with_allow(p, msg, req, 0);
21901
21902
21903
21904 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
21905
21906 return 0;
21907 }
21908
21909
21910
21911
21912
21913
21914
21915
21916
21917
21918
21919
21920
21921 static int handle_invite_replaces(struct sip_pvt *p, struct sip_request *req, int debug, int seqno, struct ast_sockaddr *addr, int *nounlock)
21922 {
21923 int earlyreplace = 0;
21924 int oneleggedreplace = 0;
21925 struct ast_channel *c = p->owner;
21926 struct ast_channel *replacecall = p->refer->refer_call->owner;
21927 struct ast_channel *targetcall;
21928
21929
21930 if (replacecall->_state == AST_STATE_RING)
21931 earlyreplace = 1;
21932
21933
21934 if (!(targetcall = ast_bridged_channel(replacecall))) {
21935
21936 if (!earlyreplace) {
21937 ast_debug(2, " Attended transfer attempted to replace call with no bridge (maybe ringing). Channel %s!\n", replacecall->name);
21938 oneleggedreplace = 1;
21939 }
21940 }
21941 if (targetcall && targetcall->_state == AST_STATE_RINGING)
21942 ast_debug(4, "SIP transfer: Target channel is in ringing state\n");
21943
21944 if (targetcall)
21945 ast_debug(4, "SIP transfer: Invite Replace incoming channel should bridge to channel %s while hanging up channel %s\n", targetcall->name, replacecall->name);
21946 else
21947 ast_debug(4, "SIP transfer: Invite Replace incoming channel should replace and hang up channel %s (one call leg)\n", replacecall->name);
21948
21949 if (req->ignore) {
21950 ast_log(LOG_NOTICE, "Ignoring this INVITE with replaces in a stupid way.\n");
21951
21952
21953
21954 transmit_response_with_sdp(p, "200 OK", req, XMIT_RELIABLE, FALSE, FALSE);
21955
21956 if (c) {
21957 *nounlock = 1;
21958 ast_channel_unlock(c);
21959 }
21960 ast_channel_unlock(replacecall);
21961 sip_pvt_unlock(p->refer->refer_call);
21962 return 1;
21963 }
21964 if (!c) {
21965
21966 ast_log(LOG_ERROR, "Unable to create new channel. Invite/replace failed.\n");
21967 transmit_response_reliable(p, "503 Service Unavailable", req);
21968 append_history(p, "Xfer", "INVITE/Replace Failed. No new channel.");
21969 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
21970 ast_channel_unlock(replacecall);
21971 sip_pvt_unlock(p->refer->refer_call);
21972 return 1;
21973 }
21974 append_history(p, "Xfer", "INVITE/Replace received");
21975
21976
21977
21978
21979
21980
21981
21982
21983
21984
21985
21986 transmit_response(p, "100 Trying", req);
21987 ast_setstate(c, AST_STATE_RING);
21988
21989
21990
21991
21992
21993 transmit_response_with_sdp(p, "200 OK", req, XMIT_RELIABLE, FALSE, FALSE);
21994
21995 ast_setstate(c, AST_STATE_UP);
21996
21997
21998 ast_quiet_chan(replacecall);
21999 ast_quiet_chan(targetcall);
22000 ast_debug(4, "Invite/Replaces: preparing to masquerade %s into %s\n", c->name, replacecall->name);
22001
22002
22003 if (! earlyreplace && ! oneleggedreplace )
22004 ast_set_flag(&p->refer->refer_call->flags[0], SIP_DEFER_BYE_ON_TRANSFER);
22005
22006
22007 if(ast_channel_masquerade(replacecall, c))
22008 ast_log(LOG_ERROR, "Failed to masquerade C into Replacecall\n");
22009 else
22010 ast_debug(4, "Invite/Replaces: Going to masquerade %s into %s\n", c->name, replacecall->name);
22011
22012
22013
22014
22015
22016 ast_channel_ref(c);
22017 ast_channel_unlock(replacecall);
22018 ast_channel_unlock(c);
22019 sip_pvt_unlock(p->refer->refer_call);
22020 sip_pvt_unlock(p);
22021 if (ast_do_masquerade(replacecall)) {
22022 ast_log(LOG_WARNING, "Failed to perform masquerade with INVITE replaces\n");
22023 }
22024 ast_channel_lock(c);
22025 if (earlyreplace || oneleggedreplace ) {
22026 c->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
22027 }
22028 ast_setstate(c, AST_STATE_DOWN);
22029 ast_channel_unlock(c);
22030
22031
22032 c->tech_pvt = dialog_unref(c->tech_pvt, "unref dialog c->tech_pvt");
22033
22034
22035 ast_hangup(c);
22036
22037 *nounlock = 1;
22038
22039 sip_pvt_lock(p);
22040 ast_channel_unref(c);
22041 return 0;
22042 }
22043
22044
22045 static int do_magic_pickup(struct ast_channel *channel, const char *extension, const char *context)
22046 {
22047 struct ast_str *str = ast_str_alloca(AST_MAX_EXTENSION + AST_MAX_CONTEXT + 2);
22048 struct ast_app *pickup = pbx_findapp("Pickup");
22049
22050 if (!pickup) {
22051 ast_log(LOG_ERROR, "Unable to perform pickup: Application 'Pickup' not loaded (app_directed_pickup.so).\n");
22052 return -1;
22053 }
22054
22055 ast_str_set(&str, 0, "%s@%s", extension, sip_cfg.notifycid == IGNORE_CONTEXT ? "PICKUPMARK" : context);
22056
22057 ast_debug(2, "About to call Pickup(%s)\n", str->str);
22058
22059
22060
22061
22062 pbx_exec(channel, pickup, str->str);
22063
22064 return 0;
22065 }
22066
22067
22068 static int sip_t38_abort(const void *data)
22069 {
22070 struct sip_pvt *p = (struct sip_pvt *) data;
22071
22072 sip_pvt_lock(p);
22073
22074
22075
22076
22077
22078 if (p->t38id != -1) {
22079 change_t38_state(p, T38_DISABLED);
22080 transmit_response_reliable(p, "488 Not acceptable here", &p->initreq);
22081 p->t38id = -1;
22082 dialog_unref(p, "unref the dialog ptr from sip_t38_abort, because it held a dialog ptr");
22083 }
22084 sip_pvt_unlock(p);
22085 return 0;
22086 }
22087
22088
22089
22090
22091
22092
22093
22094
22095
22096
22097
22098
22099 static int handle_request_update(struct sip_pvt *p, struct sip_request *req)
22100 {
22101 if (ast_strlen_zero(get_header(req, "X-Asterisk-rpid-update"))) {
22102 transmit_response(p, "501 Method Not Implemented", req);
22103 return 0;
22104 }
22105 if (get_rpid(p, req)) {
22106 struct ast_party_connected_line connected;
22107 struct ast_set_party_connected_line update_connected;
22108
22109 ast_party_connected_line_init(&connected);
22110 memset(&update_connected, 0, sizeof(update_connected));
22111
22112 update_connected.id.number = 1;
22113 connected.id.number.valid = 1;
22114 connected.id.number.str = (char *) p->cid_num;
22115 connected.id.number.presentation = p->callingpres;
22116
22117 update_connected.id.name = 1;
22118 connected.id.name.valid = 1;
22119 connected.id.name.str = (char *) p->cid_name;
22120 connected.id.name.presentation = p->callingpres;
22121
22122 connected.id.tag = (char *) p->cid_tag;
22123 connected.source = AST_CONNECTED_LINE_UPDATE_SOURCE_TRANSFER;
22124 ast_channel_queue_connected_line_update(p->owner, &connected, &update_connected);
22125 }
22126 transmit_response(p, "200 OK", req);
22127 return 0;
22128 }
22129
22130
22131
22132
22133
22134
22135
22136
22137 static int handle_request_invite(struct sip_pvt *p, struct sip_request *req, int debug, int seqno, struct ast_sockaddr *addr, int *recount, const char *e, int *nounlock)
22138 {
22139 int res = 1;
22140 int gotdest;
22141 const char *p_replaces;
22142 char *replace_id = NULL;
22143 int refer_locked = 0;
22144 const char *required;
22145 unsigned int required_profile = 0;
22146 struct ast_channel *c = NULL;
22147 struct sip_peer *authpeer = NULL;
22148 int reinvite = 0;
22149 int rtn;
22150 struct ast_party_redirecting redirecting;
22151 struct ast_set_party_redirecting update_redirecting;
22152
22153 const char *p_uac_se_hdr;
22154 const char *p_uac_min_se;
22155 int uac_max_se = -1;
22156 int uac_min_se = -1;
22157 int st_active = FALSE;
22158 int st_interval = 0;
22159 enum st_refresher st_ref;
22160 int dlg_min_se = -1;
22161 struct {
22162 char exten[AST_MAX_EXTENSION];
22163 char context[AST_MAX_CONTEXT];
22164 } pickup = {
22165 .exten = "",
22166 };
22167 st_ref = SESSION_TIMER_REFRESHER_AUTO;
22168
22169
22170 if (!p->sipoptions) {
22171 const char *supported = get_header(req, "Supported");
22172 if (!ast_strlen_zero(supported)) {
22173 p->sipoptions = parse_sip_options(supported, NULL, 0);
22174 }
22175 }
22176
22177
22178 required = get_header(req, "Require");
22179 if (!ast_strlen_zero(required)) {
22180 char unsupported[256] = { 0, };
22181 required_profile = parse_sip_options(required, unsupported, ARRAY_LEN(unsupported));
22182
22183
22184
22185 if (!ast_strlen_zero(unsupported)) {
22186 transmit_response_with_unsupported(p, "420 Bad extension (unsupported)", req, unsupported);
22187 ast_log(LOG_WARNING, "Received SIP INVITE with unsupported required extension: required:%s unsupported:%s\n", required, unsupported);
22188 p->invitestate = INV_COMPLETED;
22189 if (!p->lastinvite)
22190 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
22191 res = -1;
22192 goto request_invite_cleanup;
22193 }
22194 }
22195
22196
22197
22198 p->sipoptions |= required_profile;
22199 p->reqsipoptions = required_profile;
22200
22201
22202 if (ast_test_flag(&p->flags[0], SIP_OUTGOING) && p->owner && (p->invitestate != INV_TERMINATED && p->invitestate != INV_CONFIRMED) && p->owner->_state != AST_STATE_UP) {
22203
22204
22205
22206
22207
22208 int different;
22209 const char *initial_rlPart2 = REQ_OFFSET_TO_STR(&p->initreq, rlPart2);
22210 const char *this_rlPart2 = REQ_OFFSET_TO_STR(req, rlPart2);
22211 if (sip_cfg.pedanticsipchecking)
22212 different = sip_uri_cmp(initial_rlPart2, this_rlPart2);
22213 else
22214 different = strcmp(initial_rlPart2, this_rlPart2);
22215 if (!different) {
22216 transmit_response(p, "482 Loop Detected", req);
22217 p->invitestate = INV_COMPLETED;
22218 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
22219 res = 0;
22220 goto request_invite_cleanup;
22221 } else {
22222
22223
22224
22225
22226
22227
22228
22229 char *uri = ast_strdupa(this_rlPart2);
22230 char *at = strchr(uri, '@');
22231 char *peerorhost;
22232 ast_debug(2, "Potential spiral detected. Original RURI was %s, new RURI is %s\n", initial_rlPart2, this_rlPart2);
22233 transmit_response(p, "100 Trying", req);
22234 if (at) {
22235 *at = '\0';
22236 }
22237
22238 if ((peerorhost = strchr(uri, ':'))) {
22239 *peerorhost++ = '\0';
22240 }
22241 ast_string_field_set(p, theirtag, NULL);
22242
22243
22244 ast_string_field_set(p->owner, call_forward, peerorhost);
22245 ast_queue_control(p->owner, AST_CONTROL_BUSY);
22246 res = 0;
22247 goto request_invite_cleanup;
22248 }
22249 }
22250
22251 if (!req->ignore && p->pendinginvite) {
22252 if (!ast_test_flag(&p->flags[0], SIP_OUTGOING) && (p->invitestate == INV_COMPLETED || p->invitestate == INV_TERMINATED)) {
22253
22254
22255
22256
22257
22258
22259
22260
22261
22262
22263 __sip_ack(p, p->pendinginvite, 1, 0);
22264 } else {
22265
22266 p->glareinvite = seqno;
22267 if (p->rtp && find_sdp(req)) {
22268 struct ast_sockaddr addr;
22269 if (get_ip_and_port_from_sdp(req, SDP_AUDIO, &addr)) {
22270 ast_log(LOG_WARNING, "Failed to set an alternate media source on glared reinvite. Audio may not work properly on this call.\n");
22271 } else {
22272 ast_rtp_instance_set_alt_remote_address(p->rtp, &addr);
22273 }
22274 if (p->vrtp) {
22275 if (get_ip_and_port_from_sdp(req, SDP_VIDEO, &addr)) {
22276 ast_log(LOG_WARNING, "Failed to set an alternate media source on glared reinvite. Video may not work properly on this call.\n");
22277 } else {
22278 ast_rtp_instance_set_alt_remote_address(p->vrtp, &addr);
22279 }
22280 }
22281 }
22282 transmit_response_reliable(p, "491 Request Pending", req);
22283 ast_debug(1, "Got INVITE on call where we already have pending INVITE, deferring that - %s\n", p->callid);
22284
22285 res = 0;
22286 goto request_invite_cleanup;
22287 }
22288 }
22289
22290 p_replaces = get_header(req, "Replaces");
22291 if (!ast_strlen_zero(p_replaces)) {
22292
22293 char *ptr;
22294 char *fromtag = NULL;
22295 char *totag = NULL;
22296 char *start, *to;
22297 int error = 0;
22298
22299 if (p->owner) {
22300 ast_debug(3, "INVITE w Replaces on existing call? Refusing action. [%s]\n", p->callid);
22301 transmit_response_reliable(p, "400 Bad request", req);
22302
22303 res = -1;
22304 goto request_invite_cleanup;
22305 }
22306
22307 if (sipdebug)
22308 ast_debug(3, "INVITE part of call transfer. Replaces [%s]\n", p_replaces);
22309
22310 replace_id = ast_strdupa(p_replaces);
22311 ast_uri_decode(replace_id);
22312
22313 if (!p->refer && !sip_refer_allocate(p)) {
22314 transmit_response_reliable(p, "500 Server Internal Error", req);
22315 append_history(p, "Xfer", "INVITE/Replace Failed. Out of memory.");
22316 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
22317 p->invitestate = INV_COMPLETED;
22318 res = -1;
22319 goto request_invite_cleanup;
22320 }
22321
22322
22323
22324
22325
22326
22327
22328
22329
22330
22331 replace_id = ast_skip_blanks(replace_id);
22332
22333 start = replace_id;
22334 while ( (ptr = strsep(&start, ";")) ) {
22335 ptr = ast_skip_blanks(ptr);
22336 if ( (to = strcasestr(ptr, "to-tag=") ) )
22337 totag = to + 7;
22338 else if ( (to = strcasestr(ptr, "from-tag=") ) ) {
22339 fromtag = to + 9;
22340 fromtag = strsep(&fromtag, "&");
22341 }
22342 }
22343
22344 if (sipdebug)
22345 ast_debug(4, "Invite/replaces: Will use Replace-Call-ID : %s Fromtag: %s Totag: %s\n",
22346 replace_id,
22347 fromtag ? fromtag : "<no from tag>",
22348 totag ? totag : "<no to tag>");
22349
22350
22351
22352
22353
22354 if (strncmp(replace_id, "pickup-", 7) == 0) {
22355 struct sip_pvt *subscription = NULL;
22356 replace_id += 7;
22357
22358 if ((subscription = get_sip_pvt_byid_locked(replace_id, totag, fromtag)) == NULL) {
22359 ast_log(LOG_NOTICE, "Unable to find subscription with call-id: %s\n", replace_id);
22360 transmit_response_reliable(p, "481 Call Leg Does Not Exist (Replaces)", req);
22361 error = 1;
22362 } else {
22363 ast_log(LOG_NOTICE, "Trying to pick up %s@%s\n", subscription->exten, subscription->context);
22364 ast_copy_string(pickup.exten, subscription->exten, sizeof(pickup.exten));
22365 ast_copy_string(pickup.context, subscription->context, sizeof(pickup.context));
22366 sip_pvt_unlock(subscription);
22367 if (subscription->owner) {
22368 ast_channel_unlock(subscription->owner);
22369 }
22370 }
22371 }
22372
22373
22374 if (!error && ast_strlen_zero(pickup.exten) && (p->refer->refer_call = get_sip_pvt_byid_locked(replace_id, totag, fromtag)) == NULL) {
22375 ast_log(LOG_NOTICE, "Supervised transfer attempted to replace non-existent call id (%s)!\n", replace_id);
22376 transmit_response_reliable(p, "481 Call Leg Does Not Exist (Replaces)", req);
22377 error = 1;
22378 } else {
22379 refer_locked = 1;
22380 }
22381
22382
22383
22384
22385
22386 if (p->refer->refer_call == p) {
22387 ast_log(LOG_NOTICE, "INVITE with replaces into it's own call id (%s == %s)!\n", replace_id, p->callid);
22388 p->refer->refer_call = dialog_unref(p->refer->refer_call, "unref dialog p->refer->refer_call");
22389 transmit_response_reliable(p, "400 Bad request", req);
22390 error = 1;
22391 }
22392
22393 if (!error && ast_strlen_zero(pickup.exten) && !p->refer->refer_call->owner) {
22394
22395 ast_log(LOG_NOTICE, "Supervised transfer attempted to replace non-existing call id (%s)!\n", replace_id);
22396
22397 transmit_response_reliable(p, "481 Call Leg Does Not Exist (Replace)", req);
22398 error = 1;
22399 }
22400
22401 if (!error && ast_strlen_zero(pickup.exten) && 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) {
22402 ast_log(LOG_NOTICE, "Supervised transfer attempted to replace non-ringing or active call id (%s)!\n", replace_id);
22403 transmit_response_reliable(p, "603 Declined (Replaces)", req);
22404 error = 1;
22405 }
22406
22407 if (error) {
22408 append_history(p, "Xfer", "INVITE/Replace Failed.");
22409 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
22410 sip_pvt_unlock(p);
22411 if (p->refer->refer_call) {
22412 sip_pvt_unlock(p->refer->refer_call);
22413 if (p->refer->refer_call->owner) {
22414 ast_channel_unlock(p->refer->refer_call->owner);
22415 }
22416 }
22417 refer_locked = 0;
22418 p->invitestate = INV_COMPLETED;
22419 res = -1;
22420 goto request_invite_cleanup;
22421 }
22422 }
22423
22424
22425
22426
22427 if (!req->ignore) {
22428 int newcall = (p->initreq.headers ? TRUE : FALSE);
22429
22430 if (sip_cancel_destroy(p))
22431 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
22432
22433 p->pendinginvite = seqno;
22434 check_via(p, req);
22435
22436 copy_request(&p->initreq, req);
22437 if (sipdebug)
22438 ast_debug(1, "Initializing initreq for method %s - callid %s\n", sip_methods[req->method].text, p->callid);
22439 if (!p->owner) {
22440 if (debug)
22441 ast_verbose("Using INVITE request as basis request - %s\n", p->callid);
22442 if (newcall)
22443 append_history(p, "Invite", "New call: %s", p->callid);
22444 parse_ok_contact(p, req);
22445 } else {
22446 ast_clear_flag(&p->flags[0], SIP_OUTGOING);
22447 if (get_rpid(p, req)) {
22448 struct ast_party_connected_line connected;
22449 struct ast_set_party_connected_line update_connected;
22450
22451 ast_party_connected_line_init(&connected);
22452 memset(&update_connected, 0, sizeof(update_connected));
22453
22454 update_connected.id.number = 1;
22455 connected.id.number.valid = 1;
22456 connected.id.number.str = (char *) p->cid_num;
22457 connected.id.number.presentation = p->callingpres;
22458
22459 update_connected.id.name = 1;
22460 connected.id.name.valid = 1;
22461 connected.id.name.str = (char *) p->cid_name;
22462 connected.id.name.presentation = p->callingpres;
22463
22464 connected.id.tag = (char *) p->cid_tag;
22465 connected.source = AST_CONNECTED_LINE_UPDATE_SOURCE_TRANSFER;
22466 ast_channel_queue_connected_line_update(p->owner, &connected,
22467 &update_connected);
22468 }
22469
22470 if (find_sdp(req)) {
22471 if (process_sdp(p, req, SDP_T38_INITIATE)) {
22472 if (!ast_strlen_zero(get_header(req, "Content-Encoding"))) {
22473
22474
22475
22476 transmit_response_reliable(p, "415 Unsupported Media type", req);
22477 } else {
22478 transmit_response_reliable(p, "488 Not acceptable here", req);
22479 }
22480 if (!p->lastinvite)
22481 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
22482 res = -1;
22483 goto request_invite_cleanup;
22484 }
22485 ast_queue_control(p->owner, AST_CONTROL_SRCUPDATE);
22486 } else {
22487 p->jointcapability = p->capability;
22488 ast_debug(1, "Hm.... No sdp for the moment\n");
22489
22490
22491
22492 if (ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD)) {
22493 ast_queue_control(p->owner, AST_CONTROL_UNHOLD);
22494
22495 ast_queue_frame(p->owner, &ast_null_frame);
22496 change_hold_state(p, req, FALSE, 0);
22497 }
22498 }
22499 if (p->do_history)
22500 append_history(p, "ReInv", "Re-invite received");
22501 }
22502 } else if (debug)
22503 ast_verbose("Ignoring this INVITE request\n");
22504
22505 if (!p->lastinvite && !req->ignore && !p->owner) {
22506
22507
22508 int cc_recall_core_id = -1;
22509 set_pvt_allowed_methods(p, req);
22510 res = check_user_full(p, req, SIP_INVITE, e, XMIT_RELIABLE, addr, &authpeer);
22511 if (res == AUTH_CHALLENGE_SENT) {
22512 p->invitestate = INV_COMPLETED;
22513 res = 0;
22514 goto request_invite_cleanup;
22515 }
22516 if (res < 0) {
22517 if (res == AUTH_FAKE_AUTH) {
22518 ast_log(LOG_NOTICE, "Sending fake auth rejection for device %s\n", get_header(req, "From"));
22519 transmit_fake_auth_response(p, SIP_INVITE, req, XMIT_RELIABLE);
22520 } else {
22521 ast_log(LOG_NOTICE, "Failed to authenticate device %s\n", get_header(req, "From"));
22522 transmit_response_reliable(p, "403 Forbidden", req);
22523 }
22524 p->invitestate = INV_COMPLETED;
22525 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
22526 res = 0;
22527 goto request_invite_cleanup;
22528 }
22529
22530
22531 if (p->relatedpeer) {
22532 p->relatedpeer = unref_peer(p->relatedpeer,"unsetting the relatedpeer field in the dialog, before it is set to something else.");
22533 }
22534 if (authpeer) {
22535 p->relatedpeer = ref_peer(authpeer, "setting dialog's relatedpeer pointer");
22536 }
22537
22538 req->authenticated = 1;
22539
22540
22541 if (find_sdp(req)) {
22542 if (process_sdp(p, req, SDP_T38_INITIATE)) {
22543
22544
22545
22546 if (!ast_strlen_zero(get_header(req, "Content-Encoding"))) {
22547 transmit_response_reliable(p, "415 Unsupported Media type", req);
22548 } else {
22549
22550 transmit_response_reliable(p, "488 Not acceptable here", req);
22551 }
22552 p->invitestate = INV_COMPLETED;
22553 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
22554 ast_debug(1, "No compatible codecs for this SIP call.\n");
22555 res = -1;
22556 goto request_invite_cleanup;
22557 }
22558 } else {
22559 p->jointcapability = p->capability;
22560 ast_debug(2, "No SDP in Invite, third party call control\n");
22561 }
22562
22563
22564
22565 if (p->owner)
22566 ast_queue_frame(p->owner, &ast_null_frame);
22567
22568
22569
22570 if (ast_strlen_zero(p->context))
22571 ast_string_field_set(p, context, sip_cfg.default_context);
22572
22573
22574
22575 ast_debug(1, "Checking SIP call limits for device %s\n", p->username);
22576 if ((res = update_call_counter(p, INC_CALL_LIMIT))) {
22577 if (res < 0) {
22578 ast_log(LOG_NOTICE, "Failed to place call for device %s, too many calls\n", p->username);
22579 transmit_response_reliable(p, "480 Temporarily Unavailable (Call limit) ", req);
22580 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
22581 p->invitestate = INV_COMPLETED;
22582 }
22583 res = 0;
22584 goto request_invite_cleanup;
22585 }
22586 gotdest = get_destination(p, NULL, &cc_recall_core_id);
22587 extract_uri(p, req);
22588 build_contact(p);
22589
22590 if (p->rtp) {
22591 ast_rtp_instance_set_prop(p->rtp, AST_RTP_PROPERTY_DTMF, ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833);
22592 ast_rtp_instance_set_prop(p->rtp, AST_RTP_PROPERTY_DTMF_COMPENSATE, ast_test_flag(&p->flags[1], SIP_PAGE2_RFC2833_COMPENSATE));
22593 }
22594
22595 if (!replace_id && (gotdest != SIP_GET_DEST_EXTEN_FOUND)) {
22596 switch(gotdest) {
22597 case SIP_GET_DEST_INVALID_URI:
22598 transmit_response_reliable(p, "416 Unsupported URI scheme", req);
22599 break;
22600 case SIP_GET_DEST_EXTEN_MATCHMORE:
22601 if (ast_test_flag(&p->flags[1], SIP_PAGE2_ALLOWOVERLAP)
22602 == SIP_PAGE2_ALLOWOVERLAP_YES) {
22603 transmit_response_reliable(p, "484 Address Incomplete", req);
22604 break;
22605 }
22606
22607
22608
22609
22610
22611
22612
22613
22614
22615 case SIP_GET_DEST_EXTEN_NOT_FOUND:
22616 case SIP_GET_DEST_REFUSED:
22617 default:
22618 {
22619 char *decoded_exten = ast_strdupa(p->exten);
22620 transmit_response_reliable(p, "404 Not Found", req);
22621 ast_uri_decode(decoded_exten);
22622 ast_log(LOG_NOTICE, "Call from '%s' (%s) to extension"
22623 " '%s' rejected because extension not found in context '%s'.\n",
22624 S_OR(p->username, p->peername), ast_sockaddr_stringify(&p->recv), decoded_exten, p->context);
22625 }
22626 }
22627
22628 p->invitestate = INV_COMPLETED;
22629 update_call_counter(p, DEC_CALL_LIMIT);
22630 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
22631 res = 0;
22632 goto request_invite_cleanup;
22633 } else {
22634
22635
22636
22637 if (ast_strlen_zero(p->exten))
22638 ast_string_field_set(p, exten, "s");
22639
22640
22641 make_our_tag(p->tag, sizeof(p->tag));
22642
22643
22644 c = sip_new(p, AST_STATE_DOWN, S_OR(p->peername, NULL), NULL);
22645 if (cc_recall_core_id != -1) {
22646 ast_setup_cc_recall_datastore(c, cc_recall_core_id);
22647 ast_cc_agent_set_interfaces_chanvar(c);
22648 }
22649 *recount = 1;
22650
22651
22652 build_route(p, req, 0, 0);
22653
22654 if (c) {
22655 ast_party_redirecting_init(&redirecting);
22656 memset(&update_redirecting, 0, sizeof(update_redirecting));
22657 change_redirecting_information(p, req, &redirecting, &update_redirecting,
22658 FALSE);
22659 ast_channel_set_redirecting(c, &redirecting, &update_redirecting);
22660 ast_party_redirecting_free(&redirecting);
22661 }
22662 }
22663 } else {
22664 ast_party_redirecting_init(&redirecting);
22665 memset(&update_redirecting, 0, sizeof(update_redirecting));
22666 if (sipdebug) {
22667 if (!req->ignore)
22668 ast_debug(2, "Got a SIP re-invite for call %s\n", p->callid);
22669 else
22670 ast_debug(2, "Got a SIP re-transmit of INVITE for call %s\n", p->callid);
22671 }
22672 if (!req->ignore)
22673 reinvite = 1;
22674 c = p->owner;
22675 change_redirecting_information(p, req, &redirecting, &update_redirecting, FALSE);
22676 if (c) {
22677 ast_channel_set_redirecting(c, &redirecting, &update_redirecting);
22678 }
22679 ast_party_redirecting_free(&redirecting);
22680 }
22681
22682
22683 if ((p->sipoptions & SIP_OPT_TIMER) && !ast_strlen_zero(get_header(req, "Session-Expires"))) {
22684
22685
22686 ast_debug(2, "Incoming INVITE with 'timer' option supported and \"Session-Expires\" header.\n");
22687
22688
22689 if (!p->stimer)
22690 sip_st_alloc(p);
22691
22692
22693 p_uac_se_hdr = get_header(req, "Session-Expires");
22694 rtn = parse_session_expires(p_uac_se_hdr, &uac_max_se, &st_ref);
22695 if (rtn != 0) {
22696 transmit_response_reliable(p, "400 Session-Expires Invalid Syntax", req);
22697 p->invitestate = INV_COMPLETED;
22698 if (!p->lastinvite) {
22699 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
22700 }
22701 res = -1;
22702 goto request_invite_cleanup;
22703 }
22704
22705
22706 p_uac_min_se = get_header(req, "Min-SE");
22707 if (!ast_strlen_zero(p_uac_min_se)) {
22708 rtn = parse_minse(p_uac_min_se, &uac_min_se);
22709 if (rtn != 0) {
22710 transmit_response_reliable(p, "400 Min-SE Invalid Syntax", req);
22711 p->invitestate = INV_COMPLETED;
22712 if (!p->lastinvite) {
22713 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
22714 }
22715 res = -1;
22716 goto request_invite_cleanup;
22717 }
22718 }
22719
22720 dlg_min_se = st_get_se(p, FALSE);
22721 switch (st_get_mode(p, 1)) {
22722 case SESSION_TIMER_MODE_ACCEPT:
22723 case SESSION_TIMER_MODE_ORIGINATE:
22724 if (uac_max_se > 0 && uac_max_se < dlg_min_se) {
22725 transmit_response_with_minse(p, "422 Session Interval Too Small", req, dlg_min_se);
22726 p->invitestate = INV_COMPLETED;
22727 if (!p->lastinvite) {
22728 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
22729 }
22730 res = -1;
22731 goto request_invite_cleanup;
22732 }
22733
22734 p->stimer->st_active_peer_ua = TRUE;
22735 st_active = TRUE;
22736 if (st_ref == SESSION_TIMER_REFRESHER_AUTO) {
22737 st_ref = st_get_refresher(p);
22738 }
22739
22740 if (uac_max_se > 0) {
22741 int dlg_max_se = st_get_se(p, TRUE);
22742 if (dlg_max_se >= uac_min_se) {
22743 st_interval = (uac_max_se < dlg_max_se) ? uac_max_se : dlg_max_se;
22744 } else {
22745 st_interval = uac_max_se;
22746 }
22747 } else {
22748
22749 st_interval = global_max_se;
22750 }
22751 break;
22752
22753 case SESSION_TIMER_MODE_REFUSE:
22754 if (p->reqsipoptions & SIP_OPT_TIMER) {
22755 transmit_response_with_unsupported(p, "420 Option Disabled", req, required);
22756 ast_log(LOG_WARNING, "Received SIP INVITE with supported but disabled option: %s\n", required);
22757 p->invitestate = INV_COMPLETED;
22758 if (!p->lastinvite) {
22759 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
22760 }
22761 res = -1;
22762 goto request_invite_cleanup;
22763 }
22764 break;
22765
22766 default:
22767 ast_log(LOG_ERROR, "Internal Error %d at %s:%d\n", st_get_mode(p, 1), __FILE__, __LINE__);
22768 break;
22769 }
22770 } else {
22771
22772
22773
22774 switch (st_get_mode(p, 1)) {
22775 case SESSION_TIMER_MODE_ORIGINATE:
22776 st_active = TRUE;
22777 st_interval = st_get_se(p, TRUE);
22778 st_ref = SESSION_TIMER_REFRESHER_UAS;
22779 p->stimer->st_active_peer_ua = FALSE;
22780 break;
22781
22782 default:
22783 break;
22784 }
22785 }
22786
22787 if (reinvite == 0) {
22788
22789 if (st_active == TRUE) {
22790 p->stimer->st_active = TRUE;
22791 p->stimer->st_interval = st_interval;
22792 p->stimer->st_ref = st_ref;
22793 start_session_timer(p);
22794 }
22795 } else {
22796 if (p->stimer->st_active == TRUE) {
22797
22798
22799
22800 ast_debug (2, "Restarting session-timers on a refresh - %s\n", p->callid);
22801
22802
22803 if (st_interval > 0) {
22804 p->stimer->st_interval = st_interval;
22805 p->stimer->st_ref = st_ref;
22806 }
22807
22808 restart_session_timer(p);
22809 if (p->stimer->st_expirys > 0) {
22810 p->stimer->st_expirys--;
22811 }
22812 }
22813 }
22814
22815 if (!req->ignore && p)
22816 p->lastinvite = seqno;
22817
22818 if (c && replace_id) {
22819 if (!ast_strlen_zero(pickup.exten)) {
22820 append_history(p, "Xfer", "INVITE/Replace received");
22821
22822
22823 transmit_response(p, "100 Trying", req);
22824 p->invitestate = INV_PROCEEDING;
22825 ast_setstate(c, AST_STATE_RING);
22826
22827
22828 ast_channel_unlock(c);
22829 *nounlock = 1;
22830
22831
22832
22833
22834
22835
22836 sip_pvt_unlock(p);
22837 do_magic_pickup(c, pickup.exten, pickup.context);
22838
22839 ast_hangup(c);
22840 sip_pvt_lock(p);
22841
22842 res = 0;
22843 goto request_invite_cleanup;
22844 } else {
22845
22846 if (sipdebug)
22847 ast_debug(4, "Sending this call to the invite/replcaes handler %s\n", p->callid);
22848 res = handle_invite_replaces(p, req, debug, seqno, addr, nounlock);
22849 refer_locked = 0;
22850 goto request_invite_cleanup;
22851 }
22852 }
22853
22854
22855 if (c) {
22856 enum ast_channel_state c_state = c->_state;
22857
22858 if (c_state != AST_STATE_UP && reinvite &&
22859 (p->invitestate == INV_TERMINATED || p->invitestate == INV_CONFIRMED)) {
22860
22861
22862
22863
22864
22865
22866
22867
22868
22869 c_state = AST_STATE_UP;
22870 }
22871
22872 switch(c_state) {
22873 case AST_STATE_DOWN:
22874 ast_debug(2, "%s: New call is still down.... Trying... \n", c->name);
22875 transmit_provisional_response(p, "100 Trying", req, 0);
22876 p->invitestate = INV_PROCEEDING;
22877 ast_setstate(c, AST_STATE_RING);
22878 if (strcmp(p->exten, ast_pickup_ext())) {
22879 enum ast_pbx_result result;
22880
22881 result = ast_pbx_start(c);
22882
22883 switch(result) {
22884 case AST_PBX_FAILED:
22885 ast_log(LOG_WARNING, "Failed to start PBX :(\n");
22886 p->invitestate = INV_COMPLETED;
22887 transmit_response_reliable(p, "503 Unavailable", req);
22888 break;
22889 case AST_PBX_CALL_LIMIT:
22890 ast_log(LOG_WARNING, "Failed to start PBX (call limit reached) \n");
22891 p->invitestate = INV_COMPLETED;
22892 transmit_response_reliable(p, "480 Temporarily Unavailable", req);
22893 break;
22894 case AST_PBX_SUCCESS:
22895
22896 break;
22897 }
22898
22899 if (result) {
22900
22901
22902 ast_channel_unlock(c);
22903 *nounlock = 1;
22904 sip_pvt_unlock(p);
22905 ast_hangup(c);
22906 sip_pvt_lock(p);
22907 c = NULL;
22908 }
22909 } else {
22910 if (sip_pickup(c)) {
22911 ast_log(LOG_WARNING, "Failed to start Group pickup by %s\n", c->name);
22912 transmit_response_reliable(p, "480 Temporarily Unavailable", req);
22913 sip_alreadygone(p);
22914 c->hangupcause = AST_CAUSE_FAILURE;
22915
22916
22917 ast_channel_unlock(c);
22918 *nounlock = 1;
22919
22920 p->invitestate = INV_COMPLETED;
22921 sip_pvt_unlock(p);
22922 ast_hangup(c);
22923 sip_pvt_lock(p);
22924 c = NULL;
22925 }
22926 }
22927 break;
22928 case AST_STATE_RING:
22929 transmit_provisional_response(p, "100 Trying", req, 0);
22930 p->invitestate = INV_PROCEEDING;
22931 break;
22932 case AST_STATE_RINGING:
22933 transmit_provisional_response(p, "180 Ringing", req, 0);
22934 p->invitestate = INV_PROCEEDING;
22935 break;
22936 case AST_STATE_UP:
22937 ast_debug(2, "%s: This call is UP.... \n", c->name);
22938
22939 transmit_response(p, "100 Trying", req);
22940
22941 if (p->t38.state == T38_PEER_REINVITE) {
22942 if (p->t38id > -1) {
22943
22944 AST_SCHED_DEL_UNREF(sched, p->t38id, dialog_unref(p, "remove ref for t38id"));
22945 }
22946 p->t38id = ast_sched_add(sched, 5000, sip_t38_abort, dialog_ref(p, "passing dialog ptr into sched structure based on t38id for sip_t38_abort."));
22947 } else if (p->t38.state == T38_ENABLED) {
22948 ast_set_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
22949 transmit_response_with_t38_sdp(p, "200 OK", req, (reinvite ? XMIT_RELIABLE : (req->ignore ? XMIT_UNRELIABLE : XMIT_CRITICAL)));
22950 } else if (p->t38.state == T38_DISABLED) {
22951
22952 if (p->srtp && !ast_test_flag(p->srtp, SRTP_CRYPTO_OFFER_OK)) {
22953 ast_log(LOG_WARNING, "Target does not support required crypto\n");
22954 transmit_response_reliable(p, "488 Not Acceptable Here (crypto)", req);
22955 } else {
22956 ast_set_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
22957 transmit_response_with_sdp(p, "200 OK", req, (reinvite ? XMIT_RELIABLE : (req->ignore ? XMIT_UNRELIABLE : XMIT_CRITICAL)), p->session_modify == TRUE ? FALSE : TRUE, FALSE);
22958 ast_queue_control(p->owner, AST_CONTROL_UPDATE_RTP_PEER);
22959 }
22960 }
22961
22962 p->invitestate = INV_TERMINATED;
22963 break;
22964 default:
22965 ast_log(LOG_WARNING, "Don't know how to handle INVITE in state %d\n", c->_state);
22966 transmit_response(p, "100 Trying", req);
22967 break;
22968 }
22969 } else {
22970 if (p && (p->autokillid == -1)) {
22971 const char *msg;
22972
22973 if (!p->jointcapability)
22974 msg = "488 Not Acceptable Here (codec error)";
22975 else {
22976 ast_log(LOG_NOTICE, "Unable to create/find SIP channel for this INVITE\n");
22977 msg = "503 Unavailable";
22978 }
22979 transmit_response_reliable(p, msg, req);
22980 p->invitestate = INV_COMPLETED;
22981 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
22982 }
22983 }
22984
22985 request_invite_cleanup:
22986
22987 if (refer_locked && p->refer && p->refer->refer_call) {
22988 sip_pvt_unlock(p->refer->refer_call);
22989 if (p->refer->refer_call->owner) {
22990 ast_channel_unlock(p->refer->refer_call->owner);
22991 }
22992 }
22993 if (authpeer) {
22994 authpeer = unref_peer(authpeer, "unref_peer, from handle_request_invite authpeer");
22995 }
22996
22997 return res;
22998 }
22999
23000
23001
23002
23003
23004
23005
23006
23007
23008
23009
23010
23011
23012
23013 static int local_attended_transfer(struct sip_pvt *transferer, struct sip_dual *current, struct sip_request *req, int seqno, int *nounlock)
23014 {
23015 struct sip_dual target;
23016
23017 int res = 0;
23018 struct sip_pvt *targetcall_pvt;
23019 struct ast_party_connected_line connected_to_transferee;
23020 struct ast_party_connected_line connected_to_target;
23021 char transferer_linkedid[32];
23022 struct ast_channel *chans[2];
23023
23024
23025 if (!(targetcall_pvt = get_sip_pvt_byid_locked(transferer->refer->replaces_callid, transferer->refer->replaces_callid_totag,
23026 transferer->refer->replaces_callid_fromtag))) {
23027 if (transferer->refer->localtransfer) {
23028
23029
23030
23031 transmit_notify_with_sipfrag(transferer, seqno, "481 Call leg/transaction does not exist", TRUE);
23032 append_history(transferer, "Xfer", "Refer failed");
23033 ast_clear_flag(&transferer->flags[0], SIP_GOTREFER);
23034 transferer->refer->status = REFER_FAILED;
23035 return -1;
23036 }
23037
23038 ast_debug(3, "SIP attended transfer: Not our call - generating INVITE with replaces\n");
23039 return 0;
23040 }
23041
23042
23043 append_history(transferer, "Xfer", "Refer accepted");
23044 if (!targetcall_pvt->owner) {
23045 ast_debug(4, "SIP attended transfer: Error: No owner of target call\n");
23046
23047 transmit_notify_with_sipfrag(transferer, seqno, "503 Service Unavailable", TRUE);
23048 append_history(transferer, "Xfer", "Refer failed");
23049 ast_clear_flag(&transferer->flags[0], SIP_GOTREFER);
23050 transferer->refer->status = REFER_FAILED;
23051 sip_pvt_unlock(targetcall_pvt);
23052 if (targetcall_pvt)
23053 ao2_t_ref(targetcall_pvt, -1, "Drop targetcall_pvt pointer");
23054 return -1;
23055 }
23056
23057
23058 target.chan1 = targetcall_pvt->owner;
23059 target.chan2 = ast_bridged_channel(targetcall_pvt->owner);
23060
23061 if (!target.chan2 || !(target.chan2->_state == AST_STATE_UP || target.chan2->_state == AST_STATE_RINGING) ) {
23062
23063 if (target.chan2)
23064 ast_debug(4, "SIP attended transfer: Error: Wrong state of target call: %s\n", ast_state2str(target.chan2->_state));
23065 else if (target.chan1->_state != AST_STATE_RING)
23066 ast_debug(4, "SIP attended transfer: Error: No target channel\n");
23067 else
23068 ast_debug(4, "SIP attended transfer: Attempting transfer in ringing state\n");
23069 }
23070
23071
23072 if (sipdebug) {
23073 if (current->chan2)
23074 ast_debug(4, "SIP attended transfer: trying to bridge %s and %s\n", target.chan1->name, current->chan2->name);
23075 else
23076 ast_debug(4, "SIP attended transfer: trying to make %s take over (masq) %s\n", target.chan1->name, current->chan1->name);
23077 }
23078
23079 ast_set_flag(&transferer->flags[0], SIP_DEFER_BYE_ON_TRANSFER);
23080
23081 ast_copy_string(transferer_linkedid, transferer->owner->linkedid, sizeof(transferer_linkedid));
23082
23083
23084 chans[0] = transferer->owner;
23085 chans[1] = target.chan1;
23086 ast_manager_event_multichan(EVENT_FLAG_CALL, "Transfer", 2, chans,
23087 "TransferMethod: SIP\r\n"
23088 "TransferType: Attended\r\n"
23089 "Channel: %s\r\n"
23090 "Uniqueid: %s\r\n"
23091 "SIP-Callid: %s\r\n"
23092 "TargetChannel: %s\r\n"
23093 "TargetUniqueid: %s\r\n",
23094 transferer->owner->name,
23095 transferer->owner->uniqueid,
23096 transferer->callid,
23097 target.chan1->name,
23098 target.chan1->uniqueid);
23099 ast_party_connected_line_init(&connected_to_transferee);
23100 ast_party_connected_line_init(&connected_to_target);
23101
23102 ast_party_connected_line_copy(&connected_to_transferee, ¤t->chan1->connected);
23103
23104 ast_party_connected_line_copy(&connected_to_target, &target.chan1->connected);
23105 connected_to_target.source = connected_to_transferee.source = AST_CONNECTED_LINE_UPDATE_SOURCE_TRANSFER;
23106 res = attempt_transfer(current, &target);
23107 if (res) {
23108
23109 transmit_notify_with_sipfrag(transferer, seqno, "486 Busy Here", TRUE);
23110 append_history(transferer, "Xfer", "Refer failed");
23111 ast_clear_flag(&transferer->flags[0], SIP_DEFER_BYE_ON_TRANSFER);
23112
23113 sip_pvt_unlock(targetcall_pvt);
23114 ast_channel_unlock(target.chan1);
23115 } else {
23116
23117 const char *xfersound = pbx_builtin_getvar_helper(target.chan1, "ATTENDED_TRANSFER_COMPLETE_SOUND");
23118
23119
23120 ast_cel_report_event(target.chan1, AST_CEL_ATTENDEDTRANSFER, NULL, transferer_linkedid, target.chan2);
23121
23122
23123 transmit_notify_with_sipfrag(transferer, seqno, "200 OK", TRUE);
23124 append_history(transferer, "Xfer", "Refer succeeded");
23125 transferer->refer->status = REFER_200OK;
23126 if (target.chan2 && !ast_strlen_zero(xfersound) && ast_streamfile(target.chan2, xfersound, target.chan2->language) >= 0) {
23127 ast_waitstream(target.chan2, "");
23128 }
23129
23130
23131
23132
23133
23134
23135
23136
23137
23138
23139
23140 ast_channel_ref(current->chan1);
23141 ast_channel_unlock(current->chan1);
23142 ast_channel_unlock(target.chan1);
23143 *nounlock = 1;
23144 sip_pvt_unlock(targetcall_pvt);
23145 sip_pvt_unlock(transferer);
23146
23147 ast_do_masquerade(target.chan1);
23148
23149 ast_indicate(target.chan1, AST_CONTROL_UNHOLD);
23150 if (target.chan2) {
23151 ast_indicate(target.chan2, AST_CONTROL_UNHOLD);
23152 }
23153
23154 if (current->chan2 && current->chan2->_state == AST_STATE_RING) {
23155 ast_indicate(target.chan1, AST_CONTROL_RINGING);
23156 }
23157
23158 if (target.chan2) {
23159 ast_channel_queue_connected_line_update(target.chan1, &connected_to_transferee, NULL);
23160 ast_channel_queue_connected_line_update(target.chan2, &connected_to_target, NULL);
23161 } else {
23162
23163
23164
23165
23166
23167
23168
23169 struct ast_control_read_action_payload *frame_payload;
23170 int payload_size;
23171 int frame_size;
23172 unsigned char connected_line_data[1024];
23173 payload_size = ast_connected_line_build_data(connected_line_data,
23174 sizeof(connected_line_data), &connected_to_target, NULL);
23175 frame_size = payload_size + sizeof(*frame_payload);
23176 if (payload_size != -1 && (frame_payload = alloca(frame_size))) {
23177 frame_payload->payload_size = payload_size;
23178 memcpy(frame_payload->payload, connected_line_data, payload_size);
23179 frame_payload->action = AST_FRAME_READ_ACTION_CONNECTED_LINE_MACRO;
23180 ast_queue_control_data(target.chan1, AST_CONTROL_READ_ACTION, frame_payload, frame_size);
23181 }
23182
23183
23184
23185
23186 ast_channel_queue_connected_line_update(target.chan1, &connected_to_transferee, NULL);
23187
23188 }
23189 sip_pvt_lock(transferer);
23190
23191 ast_channel_unref(current->chan1);
23192 }
23193
23194
23195 ast_party_connected_line_free(&connected_to_target);
23196 ast_party_connected_line_free(&connected_to_transferee);
23197 if (targetcall_pvt)
23198 ao2_t_ref(targetcall_pvt, -1, "drop targetcall_pvt");
23199 return 1;
23200 }
23201
23202
23203
23204
23205
23206
23207
23208
23209
23210
23211
23212
23213
23214
23215
23216
23217
23218
23219
23220
23221
23222
23223
23224
23225
23226
23227
23228
23229
23230
23231
23232
23233
23234
23235
23236
23237
23238
23239
23240
23241
23242
23243
23244
23245
23246
23247
23248
23249
23250
23251
23252
23253
23254
23255
23256
23257
23258
23259
23260
23261
23262
23263
23264
23265
23266 static int handle_request_refer(struct sip_pvt *p, struct sip_request *req, int debug, int seqno, int *nounlock)
23267 {
23268
23269
23270
23271
23272 struct sip_dual current = { 0, };
23273 struct ast_channel *chans[2] = { 0, };
23274 char *refer_to = NULL;
23275 char *refer_to_domain = NULL;
23276 char *refer_to_context = NULL;
23277 char *referred_by = NULL;
23278 char *callid = NULL;
23279 int localtransfer = 0;
23280 int attendedtransfer = 0;
23281 int res = 0;
23282
23283 if (req->debug) {
23284 ast_verbose("Call %s got a SIP call transfer from %s: (REFER)!\n",
23285 p->callid,
23286 ast_test_flag(&p->flags[0], SIP_OUTGOING) ? "callee" : "caller");
23287 }
23288
23289 if (!p->owner) {
23290
23291
23292 ast_debug(3, "Call %s: Declined REFER, outside of dialog...\n", p->callid);
23293 transmit_response(p, "603 Declined (No dialog)", req);
23294 if (!req->ignore) {
23295 append_history(p, "Xfer", "Refer failed. Outside of dialog.");
23296 sip_alreadygone(p);
23297 pvt_set_needdestroy(p, "outside of dialog");
23298 }
23299 res = 0;
23300 goto handle_refer_cleanup;
23301 }
23302
23303
23304 if (p->allowtransfer == TRANSFER_CLOSED ) {
23305
23306 transmit_response(p, "603 Declined (policy)", req);
23307 append_history(p, "Xfer", "Refer failed. Allowtransfer == closed.");
23308
23309 res = 0;
23310 goto handle_refer_cleanup;
23311 }
23312
23313 if (!req->ignore && ast_test_flag(&p->flags[0], SIP_GOTREFER)) {
23314
23315 transmit_response(p, "491 Request pending", req);
23316 append_history(p, "Xfer", "Refer failed. Request pending.");
23317 res = 0;
23318 goto handle_refer_cleanup;
23319 }
23320
23321
23322 if (!p->refer && !sip_refer_allocate(p)) {
23323 transmit_response(p, "500 Internal Server Error", req);
23324 append_history(p, "Xfer", "Refer failed. Memory allocation error.");
23325 res = -3;
23326 goto handle_refer_cleanup;
23327 }
23328
23329 res = get_refer_info(p, req);
23330
23331 p->refer->status = REFER_SENT;
23332
23333 if (res != 0) {
23334 switch (res) {
23335 case -2:
23336 transmit_response(p, "400 Bad Request (Refer-to missing)", req);
23337 append_history(p, "Xfer", "Refer failed. Refer-to missing.");
23338 if (req->debug) {
23339 ast_debug(1, "SIP transfer to black hole can't be handled (no refer-to: )\n");
23340 }
23341 break;
23342 case -3:
23343 transmit_response(p, "603 Declined (Non sip: uri)", req);
23344 append_history(p, "Xfer", "Refer failed. Non SIP uri");
23345 if (req->debug) {
23346 ast_debug(1, "SIP transfer to non-SIP uri denied\n");
23347 }
23348 break;
23349 default:
23350
23351 transmit_response(p, "202 Accepted", req);
23352 append_history(p, "Xfer", "Refer failed. Bad extension.");
23353 transmit_notify_with_sipfrag(p, seqno, "404 Not found", TRUE);
23354 ast_clear_flag(&p->flags[0], SIP_GOTREFER);
23355 if (req->debug) {
23356 ast_debug(1, "SIP transfer to bad extension: %s\n", p->refer->refer_to);
23357 }
23358 break;
23359 }
23360 res = 0;
23361 goto handle_refer_cleanup;
23362 }
23363 if (ast_strlen_zero(p->context)) {
23364 ast_string_field_set(p, context, sip_cfg.default_context);
23365 }
23366
23367
23368 if (sip_cfg.allow_external_domains && check_sip_domain(p->refer->refer_to_domain, NULL, 0)) {
23369 p->refer->localtransfer = 1;
23370 if (sipdebug) {
23371 ast_debug(3, "This SIP transfer is local : %s\n", p->refer->refer_to_domain);
23372 }
23373 } else if (AST_LIST_EMPTY(&domain_list) || check_sip_domain(p->refer->refer_to_domain, NULL, 0)) {
23374
23375 p->refer->localtransfer = 1;
23376 } else if (sipdebug) {
23377 ast_debug(3, "This SIP transfer is to a remote SIP extension (remote domain %s)\n", p->refer->refer_to_domain);
23378 }
23379
23380
23381
23382 if (req->ignore) {
23383 goto handle_refer_cleanup;
23384 }
23385
23386
23387
23388
23389
23390
23391
23392
23393
23394
23395
23396
23397
23398
23399
23400
23401
23402
23403
23404
23405
23406
23407
23408
23409
23410
23411 chans[0] = current.chan1 = p->owner;
23412
23413
23414 chans[1] = current.chan2 = ast_bridged_channel(current.chan1);
23415
23416 ast_channel_ref(current.chan1);
23417 if (current.chan2) {
23418 ast_channel_ref(current.chan2);
23419 }
23420
23421 if (sipdebug) {
23422 ast_debug(3, "SIP %s transfer: Transferer channel %s, transferee channel %s\n",
23423 p->refer->attendedtransfer ? "attended" : "blind",
23424 current.chan1->name,
23425 current.chan2 ? current.chan2->name : "<none>");
23426 }
23427
23428 if (!current.chan2 && !p->refer->attendedtransfer) {
23429
23430
23431
23432 if (sipdebug) {
23433 ast_debug(3, "Refused SIP transfer on non-bridged channel.\n");
23434 }
23435 p->refer->status = REFER_FAILED;
23436 append_history(p, "Xfer", "Refer failed. Non-bridged channel.");
23437 transmit_response(p, "603 Declined", req);
23438 res = -1;
23439 goto handle_refer_cleanup;
23440 }
23441
23442 if (current.chan2) {
23443 if (sipdebug) {
23444 ast_debug(4, "Got SIP transfer, applying to bridged peer '%s'\n", current.chan2->name);
23445 }
23446 ast_queue_control(current.chan1, AST_CONTROL_UNHOLD);
23447 }
23448
23449 ast_set_flag(&p->flags[0], SIP_GOTREFER);
23450
23451
23452 transmit_response(p, "202 Accepted", req);
23453
23454
23455 if (p->refer->attendedtransfer) {
23456
23457 if ((res = local_attended_transfer(p, ¤t, req, seqno, nounlock))) {
23458 goto handle_refer_cleanup;
23459 }
23460
23461 if (sipdebug) {
23462 ast_debug(4, "SIP attended transfer: Still not our call - generating INVITE with replaces\n");
23463 }
23464
23465 }
23466
23467
23468 refer_to = ast_strdupa(p->refer->refer_to);
23469 refer_to_domain = ast_strdupa(p->refer->refer_to_domain);
23470 refer_to_context = ast_strdupa(p->refer->refer_to_context);
23471 referred_by = ast_strdupa(p->refer->referred_by);
23472 callid = ast_strdupa(p->callid);
23473 localtransfer = p->refer->localtransfer;
23474 attendedtransfer = p->refer->attendedtransfer;
23475
23476 if (!*nounlock) {
23477 ast_channel_unlock(p->owner);
23478 *nounlock = 1;
23479 }
23480 sip_pvt_unlock(p);
23481
23482
23483 if (localtransfer && ast_parking_ext_valid(refer_to, current.chan1, current.chan1->context)) {
23484 sip_pvt_lock(p);
23485 ast_clear_flag(&p->flags[0], SIP_GOTREFER);
23486 p->refer->status = REFER_200OK;
23487 append_history(p, "Xfer", "REFER to call parking.");
23488 sip_pvt_unlock(p);
23489
23490 ast_manager_event_multichan(EVENT_FLAG_CALL, "Transfer", 2, chans,
23491 "TransferMethod: SIP\r\n"
23492 "TransferType: Blind\r\n"
23493 "Channel: %s\r\n"
23494 "Uniqueid: %s\r\n"
23495 "SIP-Callid: %s\r\n"
23496 "TargetChannel: %s\r\n"
23497 "TargetUniqueid: %s\r\n"
23498 "TransferExten: %s\r\n"
23499 "Transfer2Parking: Yes\r\n",
23500 current.chan1->name,
23501 current.chan1->uniqueid,
23502 callid,
23503 current.chan2->name,
23504 current.chan2->uniqueid,
23505 refer_to);
23506
23507 if (sipdebug) {
23508 ast_debug(4, "SIP transfer to parking: trying to park %s. Parked by %s\n", current.chan2->name, current.chan1->name);
23509 }
23510
23511
23512 if (sip_park(current.chan2, current.chan1, req, seqno, refer_to, current.chan1->context)) {
23513 sip_pvt_lock(p);
23514 transmit_notify_with_sipfrag(p, seqno, "500 Internal Server Error", TRUE);
23515 } else {
23516 sip_pvt_lock(p);
23517 }
23518 goto handle_refer_cleanup;
23519 }
23520
23521
23522
23523
23524 if (current.chan1 && current.chan2) {
23525 ast_debug(3, "chan1->name: %s\n", current.chan1->name);
23526 pbx_builtin_setvar_helper(current.chan1, "BLINDTRANSFER", current.chan2->name);
23527 }
23528
23529 if (current.chan2) {
23530 pbx_builtin_setvar_helper(current.chan2, "BLINDTRANSFER", current.chan1->name);
23531 pbx_builtin_setvar_helper(current.chan2, "SIPDOMAIN", refer_to_domain);
23532 pbx_builtin_setvar_helper(current.chan2, "SIPTRANSFER", "yes");
23533
23534 pbx_builtin_setvar_helper(current.chan2, "_SIPTRANSFER", "yes");
23535
23536 if (!ast_strlen_zero(referred_by)) {
23537 pbx_builtin_setvar_helper(current.chan2, "_SIPTRANSFER_REFERER", referred_by);
23538 }
23539 }
23540
23541 sip_pvt_lock(p);
23542
23543 if (!ast_strlen_zero(p->refer->replaces_callid)) {
23544 char tempheader[SIPBUFSIZE];
23545 snprintf(tempheader, sizeof(tempheader), "%s%s%s%s%s", p->refer->replaces_callid,
23546 p->refer->replaces_callid_totag ? ";to-tag=" : "",
23547 p->refer->replaces_callid_totag,
23548 p->refer->replaces_callid_fromtag ? ";from-tag=" : "",
23549 p->refer->replaces_callid_fromtag);
23550
23551 if (current.chan2) {
23552 sip_pvt_unlock(p);
23553 pbx_builtin_setvar_helper(current.chan2, "_SIPTRANSFER_REPLACES", tempheader);
23554 sip_pvt_lock(p);
23555 }
23556 }
23557
23558
23559
23560
23561 if (!p->refer->attendedtransfer) {
23562 transmit_notify_with_sipfrag(p, seqno, "180 Ringing", FALSE);
23563 }
23564
23565
23566
23567
23568
23569 if (!current.chan2) {
23570
23571
23572
23573
23574
23575
23576
23577 p->refer->status = REFER_FAILED;
23578 transmit_notify_with_sipfrag(p, seqno, "503 Service Unavailable (can't handle one-legged xfers)", TRUE);
23579 ast_clear_flag(&p->flags[0], SIP_GOTREFER);
23580 append_history(p, "Xfer", "Refer failed (only bridged calls).");
23581 res = -1;
23582 goto handle_refer_cleanup;
23583 }
23584 ast_set_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER);
23585
23586
23587
23588
23589
23590
23591
23592 sip_pvt_unlock(p);
23593 ast_indicate(current.chan2, AST_CONTROL_UNHOLD);
23594 res = ast_async_goto(current.chan2, refer_to_context, refer_to, 1);
23595
23596 if (!res) {
23597 ast_manager_event_multichan(EVENT_FLAG_CALL, "Transfer", 2, chans,
23598 "TransferMethod: SIP\r\n"
23599 "TransferType: Blind\r\n"
23600 "Channel: %s\r\n"
23601 "Uniqueid: %s\r\n"
23602 "SIP-Callid: %s\r\n"
23603 "TargetChannel: %s\r\n"
23604 "TargetUniqueid: %s\r\n"
23605 "TransferExten: %s\r\n"
23606 "TransferContext: %s\r\n",
23607 current.chan1->name,
23608 current.chan1->uniqueid,
23609 callid,
23610 current.chan2->name,
23611 current.chan2->uniqueid,
23612 refer_to,
23613 refer_to_context);
23614
23615 ast_debug(3, "%s transfer succeeded. Telling transferer.\n", attendedtransfer? "Attended" : "Blind");
23616
23617
23618 ast_channel_lock(current.chan1);
23619 ast_cel_report_event(current.chan1, p->refer->attendedtransfer? AST_CEL_ATTENDEDTRANSFER : AST_CEL_BLINDTRANSFER, NULL, p->refer->attendedtransfer ? NULL : p->refer->refer_to, current.chan2);
23620 ast_channel_unlock(current.chan1);
23621
23622 sip_pvt_lock(p);
23623 transmit_notify_with_sipfrag(p, seqno, "200 Ok", TRUE);
23624 if (p->refer->localtransfer) {
23625 p->refer->status = REFER_200OK;
23626 }
23627 if (p->owner) {
23628 p->owner->hangupcause = AST_CAUSE_NORMAL_CLEARING;
23629 }
23630 append_history(p, "Xfer", "Refer succeeded.");
23631 ast_clear_flag(&p->flags[0], SIP_GOTREFER);
23632
23633
23634 res = 0;
23635 } else {
23636 sip_pvt_lock(p);
23637 ast_clear_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER);
23638 ast_debug(3, "%s transfer failed. Resuming original call.\n", p->refer->attendedtransfer? "Attended" : "Blind");
23639 append_history(p, "Xfer", "Refer failed.");
23640
23641 p->refer->status = REFER_FAILED;
23642 transmit_notify_with_sipfrag(p, seqno, "503 Service Unavailable", TRUE);
23643 ast_clear_flag(&p->flags[0], SIP_GOTREFER);
23644 res = -1;
23645 }
23646
23647 handle_refer_cleanup:
23648 if (current.chan1) {
23649 ast_channel_unref(current.chan1);
23650 }
23651 if (current.chan2) {
23652 ast_channel_unref(current.chan2);
23653 }
23654
23655
23656 return res;
23657 }
23658
23659
23660 static int handle_request_cancel(struct sip_pvt *p, struct sip_request *req)
23661 {
23662
23663 check_via(p, req);
23664 sip_alreadygone(p);
23665
23666 if (p->owner && p->owner->_state == AST_STATE_UP) {
23667
23668 transmit_response(p, "200 OK", req);
23669 ast_debug(1, "Got CANCEL on an answered call. Ignoring... \n");
23670 return 0;
23671 }
23672
23673
23674
23675
23676
23677
23678 if (p->invitestate == INV_TERMINATED || p->invitestate == INV_COMPLETED) {
23679 __sip_pretend_ack(p);
23680 }
23681 if (p->invitestate != INV_TERMINATED)
23682 p->invitestate = INV_CANCELLED;
23683
23684 if (ast_test_flag(&p->flags[0], SIP_INC_COUNT) || ast_test_flag(&p->flags[1], SIP_PAGE2_CALL_ONHOLD))
23685 update_call_counter(p, DEC_CALL_LIMIT);
23686
23687 stop_media_flows(p);
23688 if (p->owner) {
23689 ast_set_hangupsource(p->owner, p->owner->name, 0);
23690 ast_queue_hangup(p->owner);
23691 }
23692 else
23693 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
23694 if (ast_str_strlen(p->initreq.data) > 0) {
23695 struct sip_pkt *pkt, *prev_pkt;
23696
23697
23698
23699
23700
23701
23702
23703
23704
23705
23706
23707 for (pkt = p->packets, prev_pkt = NULL; pkt; prev_pkt = pkt, pkt = pkt->next) {
23708 if (pkt->seqno == p->lastinvite && pkt->response_code == 487) {
23709 AST_SCHED_DEL(sched, pkt->retransid);
23710 UNLINK(pkt, p->packets, prev_pkt);
23711 dialog_unref(pkt->owner, "unref packet->owner from dialog");
23712 if (pkt->data) {
23713 ast_free(pkt->data);
23714 }
23715 ast_free(pkt);
23716 break;
23717 }
23718 }
23719 transmit_response_reliable(p, "487 Request Terminated", &p->initreq);
23720 transmit_response(p, "200 OK", req);
23721 return 1;
23722 } else {
23723 transmit_response(p, "481 Call Leg Does Not Exist", req);
23724 return 0;
23725 }
23726 }
23727
23728
23729 static int handle_request_bye(struct sip_pvt *p, struct sip_request *req)
23730 {
23731 struct ast_channel *c=NULL;
23732 int res;
23733 struct ast_channel *bridged_to;
23734 const char *required;
23735
23736
23737 if (p->pendinginvite && !ast_test_flag(&p->flags[0], SIP_OUTGOING) && !req->ignore) {
23738 transmit_response_reliable(p, "487 Request Terminated", &p->initreq);
23739 }
23740
23741 __sip_pretend_ack(p);
23742
23743 p->invitestate = INV_TERMINATED;
23744
23745 copy_request(&p->initreq, req);
23746 if (sipdebug)
23747 ast_debug(1, "Initializing initreq for method %s - callid %s\n", sip_methods[req->method].text, p->callid);
23748 check_via(p, req);
23749 sip_alreadygone(p);
23750
23751
23752 if (p->do_history || p->owner) {
23753 char quality_buf[AST_MAX_USER_FIELD], *quality;
23754 struct ast_channel *bridge = p->owner ? ast_bridged_channel(p->owner) : NULL;
23755
23756
23757
23758
23759 while (bridge && ast_channel_trylock(bridge)) {
23760 ast_channel_unlock(p->owner);
23761 do {
23762
23763 sip_pvt_unlock(p);
23764 usleep(1);
23765 sip_pvt_lock(p);
23766 } while (p->owner && ast_channel_trylock(p->owner));
23767 bridge = p->owner ? ast_bridged_channel(p->owner) : NULL;
23768 }
23769
23770
23771 if (p->rtp && (quality = ast_rtp_instance_get_quality(p->rtp, AST_RTP_INSTANCE_STAT_FIELD_QUALITY, quality_buf, sizeof(quality_buf)))) {
23772 if (p->do_history) {
23773 append_history(p, "RTCPaudio", "Quality:%s", quality);
23774
23775 if ((quality = ast_rtp_instance_get_quality(p->rtp, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_JITTER, quality_buf, sizeof(quality_buf)))) {
23776 append_history(p, "RTCPaudioJitter", "Quality:%s", quality);
23777 }
23778 if ((quality = ast_rtp_instance_get_quality(p->rtp, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_LOSS, quality_buf, sizeof(quality_buf)))) {
23779 append_history(p, "RTCPaudioLoss", "Quality:%s", quality);
23780 }
23781 if ((quality = ast_rtp_instance_get_quality(p->rtp, AST_RTP_INSTANCE_STAT_FIELD_QUALITY_RTT, quality_buf, sizeof(quality_buf)))) {
23782 append_history(p, "RTCPaudioRTT", "Quality:%s", quality);
23783 }
23784 }
23785
23786 if (p->owner) {
23787 ast_rtp_instance_set_stats_vars(p->owner, p->rtp);
23788 }
23789
23790 }
23791
23792 if (bridge) {
23793 struct sip_pvt *q = bridge->tech_pvt;
23794
23795 if (IS_SIP_TECH(bridge->tech) && q && q->rtp) {
23796 ast_rtp_instance_set_stats_vars(bridge, q->rtp);
23797 }
23798 ast_channel_unlock(bridge);
23799 }
23800
23801 if (p->vrtp && (quality = ast_rtp_instance_get_quality(p->vrtp, AST_RTP_INSTANCE_STAT_FIELD_QUALITY, quality_buf, sizeof(quality_buf)))) {
23802 if (p->do_history) {
23803 append_history(p, "RTCPvideo", "Quality:%s", quality);
23804 }
23805 if (p->owner) {
23806 pbx_builtin_setvar_helper(p->owner, "RTPVIDEOQOS", quality);
23807 }
23808 }
23809 if (p->trtp && (quality = ast_rtp_instance_get_quality(p->trtp, AST_RTP_INSTANCE_STAT_FIELD_QUALITY, quality_buf, sizeof(quality_buf)))) {
23810 if (p->do_history) {
23811 append_history(p, "RTCPtext", "Quality:%s", quality);
23812 }
23813 if (p->owner) {
23814 pbx_builtin_setvar_helper(p->owner, "RTPTEXTQOS", quality);
23815 }
23816 }
23817 }
23818
23819 stop_media_flows(p);
23820 stop_session_timer(p);
23821
23822 if (!ast_strlen_zero(get_header(req, "Also"))) {
23823 ast_log(LOG_NOTICE, "Client '%s' using deprecated BYE/Also transfer method. Ask vendor to support REFER instead\n",
23824 ast_sockaddr_stringify(&p->recv));
23825 if (ast_strlen_zero(p->context))
23826 ast_string_field_set(p, context, sip_cfg.default_context);
23827 res = get_also_info(p, req);
23828 if (!res) {
23829 c = p->owner;
23830 if (c) {
23831 bridged_to = ast_bridged_channel(c);
23832 if (bridged_to) {
23833
23834 ast_queue_control(c, AST_CONTROL_UNHOLD);
23835 ast_channel_unlock(c);
23836 ast_async_goto(bridged_to, p->context, p->refer->refer_to, 1);
23837 ast_channel_lock(c);
23838 } else
23839 ast_queue_hangup(p->owner);
23840 }
23841 } else {
23842 ast_log(LOG_WARNING, "Invalid transfer information from '%s'\n", ast_sockaddr_stringify(&p->recv));
23843 if (p->owner)
23844 ast_queue_hangup_with_cause(p->owner, AST_CAUSE_PROTOCOL_ERROR);
23845 }
23846 } else if (p->owner) {
23847 ast_set_hangupsource(p->owner, p->owner->name, 0);
23848 ast_queue_hangup(p->owner);
23849 sip_scheddestroy_final(p, DEFAULT_TRANS_TIMEOUT);
23850 ast_debug(3, "Received bye, issuing owner hangup\n");
23851 } else {
23852 sip_scheddestroy_final(p, DEFAULT_TRANS_TIMEOUT);
23853 ast_debug(3, "Received bye, no owner, selfdestruct soon.\n");
23854 }
23855 ast_clear_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
23856
23857
23858 required = get_header(req, "Require");
23859 if (!ast_strlen_zero(required)) {
23860 char unsupported[256] = { 0, };
23861 parse_sip_options(required, unsupported, ARRAY_LEN(unsupported));
23862
23863
23864 if (!ast_strlen_zero(unsupported)) {
23865 transmit_response_with_unsupported(p, "420 Bad extension (unsupported)", req, unsupported);
23866 ast_log(LOG_WARNING, "Received SIP BYE with unsupported required extension: required:%s unsupported:%s\n", required, unsupported);
23867 } else {
23868 transmit_response(p, "200 OK", req);
23869 }
23870 } else {
23871 transmit_response(p, "200 OK", req);
23872 }
23873
23874 return 1;
23875 }
23876
23877
23878 static int handle_request_message(struct sip_pvt *p, struct sip_request *req)
23879 {
23880 if (!req->ignore) {
23881 if (req->debug)
23882 ast_verbose("Receiving message!\n");
23883 receive_message(p, req);
23884 } else
23885 transmit_response(p, "202 Accepted", req);
23886 return 1;
23887 }
23888
23889 static enum sip_publish_type determine_sip_publish_type(struct sip_request *req, const char * const event, const char * const etag, const char * const expires, int *expires_int)
23890 {
23891 int etag_present = !ast_strlen_zero(etag);
23892 int body_present = req->lines > 0;
23893
23894 ast_assert(expires_int != NULL);
23895
23896 if (ast_strlen_zero(expires)) {
23897
23898
23899
23900
23901 *expires_int = DEFAULT_PUBLISH_EXPIRES;
23902 } else if (sscanf(expires, "%30d", expires_int) != 1) {
23903 return SIP_PUBLISH_UNKNOWN;
23904 }
23905
23906 if (*expires_int == 0) {
23907 return SIP_PUBLISH_REMOVE;
23908 } else if (!etag_present && body_present) {
23909 return SIP_PUBLISH_INITIAL;
23910 } else if (etag_present && !body_present) {
23911 return SIP_PUBLISH_REFRESH;
23912 } else if (etag_present && body_present) {
23913 return SIP_PUBLISH_MODIFY;
23914 }
23915
23916 return SIP_PUBLISH_UNKNOWN;
23917 }
23918
23919 #ifdef HAVE_LIBXML2
23920 static void get_pidf_body(struct sip_request *req, char *pidf_body, size_t size)
23921 {
23922 int i;
23923 struct ast_str *str = ast_str_alloca(size);
23924 for (i = 0; i < req->lines; ++i) {
23925 ast_str_append(&str, 0, "%s", REQ_OFFSET_TO_STR(req, line[i]));
23926 }
23927 ast_copy_string(pidf_body, ast_str_buffer(str), size);
23928 }
23929
23930 static int pidf_validate_tuple(struct ast_xml_node *tuple_node)
23931 {
23932 const char *id;
23933 int status_found = FALSE;
23934 struct ast_xml_node *tuple_children;
23935 struct ast_xml_node *tuple_children_iterator;
23936
23937 if (!(id = ast_xml_get_attribute(tuple_node, "id"))) {
23938 ast_log(LOG_WARNING, "Tuple XML element has no attribute 'id'\n");
23939 return FALSE;
23940 }
23941
23942 ast_xml_free_attr(id);
23943
23944 if (!(tuple_children = ast_xml_node_get_children(tuple_node))) {
23945
23946 ast_log(LOG_WARNING, "Tuple XML element has no child elements\n");
23947 return FALSE;
23948 }
23949 for (tuple_children_iterator = tuple_children; tuple_children_iterator;
23950 tuple_children_iterator = ast_xml_node_get_next(tuple_children_iterator)) {
23951
23952
23953
23954
23955 if (strcmp(ast_xml_node_get_name(tuple_children_iterator), "status")) {
23956
23957 continue;
23958 }
23959 if (status_found == TRUE) {
23960
23961 ast_log(LOG_WARNING, "Multiple status elements found in tuple. Only one allowed\n");
23962 return FALSE;
23963 }
23964 status_found = TRUE;
23965 }
23966 return status_found;
23967 }
23968
23969
23970 static int pidf_validate_presence(struct ast_xml_doc *doc)
23971 {
23972 struct ast_xml_node *presence_node = ast_xml_get_root(doc);
23973 struct ast_xml_node *child_nodes;
23974 struct ast_xml_node *node_iterator;
23975 struct ast_xml_ns *ns;
23976 const char *entity;
23977 const char *namespace;
23978 const char presence_namespace[] = "urn:ietf:params:xml:ns:pidf";
23979
23980 if (!presence_node) {
23981 ast_log(LOG_WARNING, "Unable to retrieve root node of the XML document\n");
23982 return FALSE;
23983 }
23984
23985
23986
23987 if (strcmp(ast_xml_node_get_name(presence_node), "presence")) {
23988 ast_log(LOG_WARNING, "Root node of PIDF document is not 'presence'. Invalid\n");
23989 return FALSE;
23990 }
23991
23992
23993
23994
23995 if (!(entity = ast_xml_get_attribute(presence_node, "entity"))) {
23996 ast_log(LOG_WARNING, "Presence element of PIDF document has no 'entity' attribute\n");
23997 return FALSE;
23998 }
23999
24000 ast_xml_free_attr(entity);
24001
24002 if (!(ns = ast_xml_find_namespace(doc, presence_node, NULL))) {
24003 ast_log(LOG_WARNING, "Couldn't find default namespace...\n");
24004 return FALSE;
24005 }
24006
24007 namespace = ast_xml_get_ns_href(ns);
24008 if (ast_strlen_zero(namespace) || strcmp(namespace, presence_namespace)) {
24009 ast_log(LOG_WARNING, "PIDF document has invalid namespace value %s\n", namespace);
24010 return FALSE;
24011 }
24012
24013 if (!(child_nodes = ast_xml_node_get_children(presence_node))) {
24014 ast_log(LOG_WARNING, "PIDF document has no elements as children of 'presence'. Invalid\n");
24015 return FALSE;
24016 }
24017
24018
24019
24020
24021
24022
24023
24024
24025
24026 for (node_iterator = child_nodes; node_iterator;
24027 node_iterator = ast_xml_node_get_next(node_iterator)) {
24028 if (strcmp(ast_xml_node_get_name(node_iterator), "tuple")) {
24029
24030 continue;
24031 }
24032 if (pidf_validate_tuple(node_iterator) == FALSE) {
24033 ast_log(LOG_WARNING, "Unable to validate tuple\n");
24034 return FALSE;
24035 }
24036 }
24037
24038 return TRUE;
24039 }
24040
24041
24042
24043
24044
24045
24046
24047
24048
24049
24050
24051
24052
24053
24054
24055
24056 static int sip_pidf_validate(struct sip_request *req, struct ast_xml_doc **pidf_doc)
24057 {
24058 struct ast_xml_doc *doc;
24059 int content_length;
24060 const char *content_length_str = get_header(req, "Content-Length");
24061 const char *content_type = get_header(req, "Content-Type");
24062 char pidf_body[SIPBUFSIZE];
24063 int res;
24064
24065 if (ast_strlen_zero(content_type) || strcmp(content_type, "application/pidf+xml")) {
24066 ast_log(LOG_WARNING, "Content type is not PIDF\n");
24067 return FALSE;
24068 }
24069
24070 if (ast_strlen_zero(content_length_str)) {
24071 ast_log(LOG_WARNING, "No content length. Can't determine bounds of PIDF document\n");
24072 return FALSE;
24073 }
24074
24075 if (sscanf(content_length_str, "%30d", &content_length) != 1) {
24076 ast_log(LOG_WARNING, "Invalid content length provided\n");
24077 return FALSE;
24078 }
24079
24080 if (content_length > sizeof(pidf_body)) {
24081 ast_log(LOG_WARNING, "Content length of PIDF document truncated to %d bytes\n", (int) sizeof(pidf_body));
24082 content_length = sizeof(pidf_body);
24083 }
24084
24085 get_pidf_body(req, pidf_body, content_length);
24086
24087 if (!(doc = ast_xml_read_memory(pidf_body, content_length))) {
24088 ast_log(LOG_WARNING, "Unable to open XML PIDF document. Is it malformed?\n");
24089 return FALSE;
24090 }
24091
24092 res = pidf_validate_presence(doc);
24093 if (res == TRUE) {
24094 *pidf_doc = doc;
24095 } else {
24096 ast_xml_close(doc);
24097 }
24098 return res;
24099 }
24100
24101 static int cc_esc_publish_handler(struct sip_pvt *pvt, struct sip_request *req, struct event_state_compositor *esc, struct sip_esc_entry *esc_entry)
24102 {
24103 const char *uri = REQ_OFFSET_TO_STR(req, rlPart2);
24104 struct ast_cc_agent *agent;
24105 struct sip_cc_agent_pvt *agent_pvt;
24106 struct ast_xml_doc *pidf_doc = NULL;
24107 const char *basic_status = NULL;
24108 struct ast_xml_node *presence_node;
24109 struct ast_xml_node *presence_children;
24110 struct ast_xml_node *tuple_node;
24111 struct ast_xml_node *tuple_children;
24112 struct ast_xml_node *status_node;
24113 struct ast_xml_node *status_children;
24114 struct ast_xml_node *basic_node;
24115 int res = 0;
24116
24117 if (!((agent = find_sip_cc_agent_by_notify_uri(uri)) || (agent = find_sip_cc_agent_by_subscribe_uri(uri)))) {
24118 ast_log(LOG_WARNING, "Could not find agent using uri '%s'\n", uri);
24119 transmit_response(pvt, "412 Conditional Request Failed", req);
24120 return -1;
24121 }
24122
24123 agent_pvt = agent->private_data;
24124
24125 if (sip_pidf_validate(req, &pidf_doc) == FALSE) {
24126 res = -1;
24127 goto cc_publish_cleanup;
24128 }
24129
24130
24131
24132
24133
24134
24135
24136 presence_node = ast_xml_get_root(pidf_doc);
24137 if (!(presence_children = ast_xml_node_get_children(presence_node))) {
24138 ast_log(LOG_WARNING, "No tuples within presence element.\n");
24139 res = -1;
24140 goto cc_publish_cleanup;
24141 }
24142
24143 if (!(tuple_node = ast_xml_find_element(presence_children, "tuple", NULL, NULL))) {
24144 ast_log(LOG_NOTICE, "Couldn't find tuple node?\n");
24145 res = -1;
24146 goto cc_publish_cleanup;
24147 }
24148
24149
24150
24151
24152 tuple_children = ast_xml_node_get_children(tuple_node);
24153 status_node = ast_xml_find_element(tuple_children, "status", NULL, NULL);
24154
24155 if (!(status_children = ast_xml_node_get_children(status_node))) {
24156 ast_log(LOG_WARNING, "No basic elements within status element.\n");
24157 res = -1;
24158 goto cc_publish_cleanup;
24159 }
24160
24161 if (!(basic_node = ast_xml_find_element(status_children, "basic", NULL, NULL))) {
24162 ast_log(LOG_WARNING, "Couldn't find basic node?\n");
24163 res = -1;
24164 goto cc_publish_cleanup;
24165 }
24166
24167 basic_status = ast_xml_get_text(basic_node);
24168
24169 if (ast_strlen_zero(basic_status)) {
24170 ast_log(LOG_NOTICE, "NOthing in basic node?\n");
24171 res = -1;
24172 goto cc_publish_cleanup;
24173 }
24174
24175 if (!strcmp(basic_status, "open")) {
24176 agent_pvt->is_available = TRUE;
24177 ast_cc_agent_caller_available(agent->core_id, "Received PUBLISH stating SIP caller %s is available",
24178 agent->device_name);
24179 } else if (!strcmp(basic_status, "closed")) {
24180 agent_pvt->is_available = FALSE;
24181 ast_cc_agent_caller_busy(agent->core_id, "Received PUBLISH stating SIP caller %s is busy",
24182 agent->device_name);
24183 } else {
24184 ast_log(LOG_NOTICE, "Invalid content in basic element: %s\n", basic_status);
24185 }
24186
24187 cc_publish_cleanup:
24188 if (basic_status) {
24189 ast_xml_free_text(basic_status);
24190 }
24191 if (pidf_doc) {
24192 ast_xml_close(pidf_doc);
24193 }
24194 ao2_ref(agent, -1);
24195 if (res) {
24196 transmit_response(pvt, "400 Bad Request", req);
24197 }
24198 return res;
24199 }
24200
24201 #endif
24202
24203 static int handle_sip_publish_initial(struct sip_pvt *p, struct sip_request *req, struct event_state_compositor *esc, const int expires)
24204 {
24205 struct sip_esc_entry *esc_entry = create_esc_entry(esc, req, expires);
24206 int res = 0;
24207
24208 if (!esc_entry) {
24209 transmit_response(p, "503 Internal Server Failure", req);
24210 return -1;
24211 }
24212
24213 if (esc->callbacks->initial_handler) {
24214 res = esc->callbacks->initial_handler(p, req, esc, esc_entry);
24215 }
24216
24217 if (!res) {
24218 transmit_response_with_sip_etag(p, "200 OK", req, esc_entry, 0);
24219 }
24220
24221 ao2_ref(esc_entry, -1);
24222 return res;
24223 }
24224
24225 static int handle_sip_publish_refresh(struct sip_pvt *p, struct sip_request *req, struct event_state_compositor *esc, const char * const etag, const int expires)
24226 {
24227 struct sip_esc_entry *esc_entry = get_esc_entry(etag, esc);
24228 int expires_ms = expires * 1000;
24229 int res = 0;
24230
24231 if (!esc_entry) {
24232 transmit_response(p, "412 Conditional Request Failed", req);
24233 return -1;
24234 }
24235
24236 AST_SCHED_REPLACE_UNREF(esc_entry->sched_id, sched, expires_ms, publish_expire, esc_entry,
24237 ao2_ref(_data, -1),
24238 ao2_ref(esc_entry, -1),
24239 ao2_ref(esc_entry, +1));
24240
24241 if (esc->callbacks->refresh_handler) {
24242 res = esc->callbacks->refresh_handler(p, req, esc, esc_entry);
24243 }
24244
24245 if (!res) {
24246 transmit_response_with_sip_etag(p, "200 OK", req, esc_entry, 1);
24247 }
24248
24249 ao2_ref(esc_entry, -1);
24250 return res;
24251 }
24252
24253 static int handle_sip_publish_modify(struct sip_pvt *p, struct sip_request *req, struct event_state_compositor *esc, const char * const etag, const int expires)
24254 {
24255 struct sip_esc_entry *esc_entry = get_esc_entry(etag, esc);
24256 int expires_ms = expires * 1000;
24257 int res = 0;
24258
24259 if (!esc_entry) {
24260 transmit_response(p, "412 Conditional Request Failed", req);
24261 return -1;
24262 }
24263
24264 AST_SCHED_REPLACE_UNREF(esc_entry->sched_id, sched, expires_ms, publish_expire, esc_entry,
24265 ao2_ref(_data, -1),
24266 ao2_ref(esc_entry, -1),
24267 ao2_ref(esc_entry, +1));
24268
24269 if (esc->callbacks->modify_handler) {
24270 res = esc->callbacks->modify_handler(p, req, esc, esc_entry);
24271 }
24272
24273 if (!res) {
24274 transmit_response_with_sip_etag(p, "200 OK", req, esc_entry, 1);
24275 }
24276
24277 ao2_ref(esc_entry, -1);
24278 return res;
24279 }
24280
24281 static int handle_sip_publish_remove(struct sip_pvt *p, struct sip_request *req, struct event_state_compositor *esc, const char * const etag)
24282 {
24283 struct sip_esc_entry *esc_entry = get_esc_entry(etag, esc);
24284 int res = 0;
24285
24286 if (!esc_entry) {
24287 transmit_response(p, "412 Conditional Request Failed", req);
24288 return -1;
24289 }
24290
24291 AST_SCHED_DEL(sched, esc_entry->sched_id);
24292
24293 ao2_ref(esc_entry, -1);
24294
24295 if (esc->callbacks->remove_handler) {
24296 res = esc->callbacks->remove_handler(p, req, esc, esc_entry);
24297 }
24298
24299 if (!res) {
24300 transmit_response_with_sip_etag(p, "200 OK", req, esc_entry, 1);
24301 }
24302
24303
24304 ao2_unlink(esc->compositor, esc_entry);
24305 ao2_ref(esc_entry, -1);
24306 return res;
24307 }
24308
24309 static int handle_request_publish(struct sip_pvt *p, struct sip_request *req, struct ast_sockaddr *addr, const int seqno, const char *uri)
24310 {
24311 const char *etag = get_header(req, "SIP-If-Match");
24312 const char *event = get_header(req, "Event");
24313 struct event_state_compositor *esc;
24314 enum sip_publish_type publish_type;
24315 const char *expires_str = get_header(req, "Expires");
24316 int expires_int;
24317 int auth_result;
24318 int handler_result = -1;
24319
24320 if (ast_strlen_zero(event)) {
24321 transmit_response(p, "489 Bad Event", req);
24322 pvt_set_needdestroy(p, "missing Event: header");
24323 return -1;
24324 }
24325
24326 if (!(esc = get_esc(event))) {
24327 transmit_response(p, "489 Bad Event", req);
24328 pvt_set_needdestroy(p, "unknown event package in publish");
24329 return -1;
24330 }
24331
24332 auth_result = check_user(p, req, SIP_PUBLISH, uri, XMIT_RELIABLE, addr);
24333 if (auth_result == AUTH_CHALLENGE_SENT) {
24334 p->lastinvite = seqno;
24335 return 0;
24336 } else if (auth_result < 0) {
24337 if (auth_result == AUTH_FAKE_AUTH) {
24338 ast_log(LOG_NOTICE, "Sending fake auth rejection for device %s\n", get_header(req, "From"));
24339 transmit_fake_auth_response(p, SIP_INVITE, req, XMIT_RELIABLE);
24340 } else {
24341 ast_log(LOG_NOTICE, "Failed to authenticate device %s\n", get_header(req, "From"));
24342 transmit_response_reliable(p, "403 Forbidden", req);
24343 }
24344 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
24345 ast_string_field_set(p, theirtag, NULL);
24346 return 0;
24347 } else if (auth_result == AUTH_SUCCESSFUL && p->lastinvite) {
24348
24349 __sip_ack(p, p->lastinvite, 1, 0);
24350 }
24351
24352 publish_type = determine_sip_publish_type(req, event, etag, expires_str, &expires_int);
24353
24354 if (expires_int > max_expiry) {
24355 expires_int = max_expiry;
24356 } else if (expires_int < min_expiry && expires_int > 0) {
24357 transmit_response_with_minexpires(p, "423 Interval too small", req);
24358 pvt_set_needdestroy(p, "Expires is less that the min expires allowed.");
24359 return 0;
24360 }
24361 p->expiry = expires_int;
24362
24363
24364
24365
24366 switch (publish_type) {
24367 case SIP_PUBLISH_UNKNOWN:
24368 transmit_response(p, "400 Bad Request", req);
24369 break;
24370 case SIP_PUBLISH_INITIAL:
24371 handler_result = handle_sip_publish_initial(p, req, esc, expires_int);
24372 break;
24373 case SIP_PUBLISH_REFRESH:
24374 handler_result = handle_sip_publish_refresh(p, req, esc, etag, expires_int);
24375 break;
24376 case SIP_PUBLISH_MODIFY:
24377 handler_result = handle_sip_publish_modify(p, req, esc, etag, expires_int);
24378 break;
24379 case SIP_PUBLISH_REMOVE:
24380 handler_result = handle_sip_publish_remove(p, req, esc, etag);
24381 break;
24382 default:
24383 transmit_response(p, "400 Impossible Condition", req);
24384 break;
24385 }
24386 if (!handler_result && p->expiry > 0) {
24387 sip_scheddestroy(p, (p->expiry + 10) * 1000);
24388 } else {
24389 pvt_set_needdestroy(p, "forcing expiration");
24390 }
24391
24392 return handler_result;
24393 }
24394
24395
24396
24397
24398
24399
24400
24401 static void add_peer_mwi_subs(struct sip_peer *peer)
24402 {
24403 struct sip_mailbox *mailbox;
24404
24405 AST_LIST_TRAVERSE(&peer->mailboxes, mailbox, entry) {
24406 if (mailbox->event_sub) {
24407 ast_event_unsubscribe(mailbox->event_sub);
24408 }
24409
24410 mailbox->event_sub = ast_event_subscribe(AST_EVENT_MWI, mwi_event_cb, "SIP mbox event", peer,
24411 AST_EVENT_IE_MAILBOX, AST_EVENT_IE_PLTYPE_STR, mailbox->mailbox,
24412 AST_EVENT_IE_CONTEXT, AST_EVENT_IE_PLTYPE_STR, S_OR(mailbox->context, "default"),
24413 AST_EVENT_IE_END);
24414 }
24415 }
24416
24417 static int handle_cc_subscribe(struct sip_pvt *p, struct sip_request *req)
24418 {
24419 const char *uri = REQ_OFFSET_TO_STR(req, rlPart2);
24420 char *param_separator;
24421 struct ast_cc_agent *agent;
24422 struct sip_cc_agent_pvt *agent_pvt;
24423 const char *expires_str = get_header(req, "Expires");
24424 int expires = -1;
24425
24426 if (!ast_strlen_zero(expires_str)) {
24427 sscanf(expires_str, "%d", &expires);
24428 }
24429
24430 if ((param_separator = strchr(uri, ';'))) {
24431 *param_separator = '\0';
24432 }
24433
24434 p->subscribed = CALL_COMPLETION;
24435
24436 if (!(agent = find_sip_cc_agent_by_subscribe_uri(uri))) {
24437 if (!expires) {
24438
24439
24440
24441
24442
24443
24444 transmit_response(p, "200 OK", req);
24445 return 0;
24446 }
24447 ast_log(LOG_WARNING, "Invalid URI '%s' in CC subscribe\n", uri);
24448 transmit_response(p, "404 Not Found", req);
24449 return -1;
24450 }
24451
24452 agent_pvt = agent->private_data;
24453
24454 if (!expires) {
24455
24456
24457
24458 ast_cc_failed(agent->core_id, "CC is being canceled by %s", agent->device_name);
24459 transmit_response(p, "200 OK", req);
24460 ao2_ref(agent, -1);
24461 return 0;
24462 }
24463
24464 agent_pvt->subscribe_pvt = dialog_ref(p, "SIP CC agent gains reference to subscription dialog");
24465 ast_cc_agent_accept_request(agent->core_id, "SIP caller %s has requested CC via SUBSCRIBE",
24466 agent->device_name);
24467
24468
24469
24470
24471 ao2_ref(agent, -1);
24472 return 0;
24473 }
24474
24475
24476 static int handle_request_subscribe(struct sip_pvt *p, struct sip_request *req, struct ast_sockaddr *addr, int seqno, const char *e)
24477 {
24478 int gotdest = 0;
24479 int res = 0;
24480 int firststate;
24481 struct sip_peer *authpeer = NULL;
24482 const char *eventheader = get_header(req, "Event");
24483 int resubscribe = (p->subscribed != NONE) && !req->ignore;
24484 char *temp, *event;
24485
24486 if (p->initreq.headers) {
24487
24488 if (p->initreq.method != SIP_SUBSCRIBE) {
24489
24490
24491 transmit_response(p, "403 Forbidden (within dialog)", req);
24492
24493 ast_debug(1, "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);
24494 return 0;
24495 } else if (req->debug) {
24496 if (resubscribe)
24497 ast_debug(1, "Got a re-subscribe on existing subscription %s\n", p->callid);
24498 else
24499 ast_debug(1, "Got a new subscription %s (possibly with auth) or retransmission\n", p->callid);
24500 }
24501 }
24502
24503
24504
24505
24506 if (!sip_cfg.allowsubscribe) {
24507 transmit_response(p, "403 Forbidden (policy)", req);
24508 pvt_set_needdestroy(p, "forbidden");
24509 return 0;
24510 }
24511
24512 if (!req->ignore && !resubscribe) {
24513 const char *to = get_header(req, "To");
24514 char totag[128];
24515 set_pvt_allowed_methods(p, req);
24516
24517
24518 if (!ast_strlen_zero(to) && gettag(req, "To", totag, sizeof(totag))) {
24519 if (req->debug)
24520 ast_verbose("Received resubscription for a dialog we no longer know about. Telling remote side to subscribe again.\n");
24521 transmit_response(p, "481 Subscription does not exist", req);
24522 pvt_set_needdestroy(p, "subscription does not exist");
24523 return 0;
24524 }
24525
24526
24527 if (req->debug)
24528 ast_verbose("Creating new subscription\n");
24529
24530 copy_request(&p->initreq, req);
24531 if (sipdebug)
24532 ast_debug(4, "Initializing initreq for method %s - callid %s\n", sip_methods[req->method].text, p->callid);
24533 check_via(p, req);
24534 build_route(p, req, 0, 0);
24535 } else if (req->debug && req->ignore)
24536 ast_verbose("Ignoring this SUBSCRIBE request\n");
24537
24538
24539 if (ast_strlen_zero(eventheader)) {
24540 transmit_response(p, "489 Bad Event", req);
24541 ast_debug(2, "Received SIP subscribe for unknown event package: <none>\n");
24542 pvt_set_needdestroy(p, "unknown event package in subscribe");
24543 return 0;
24544 }
24545
24546 if ( (strchr(eventheader, ';'))) {
24547 event = ast_strdupa(eventheader);
24548 temp = strchr(event, ';');
24549 *temp = '\0';
24550
24551 } else
24552 event = (char *) eventheader;
24553
24554
24555
24556
24557 if (p->subscribed == NONE || resubscribe) {
24558 res = check_user_full(p, req, SIP_SUBSCRIBE, e, 0, addr, &authpeer);
24559
24560
24561 if (res == AUTH_CHALLENGE_SENT)
24562 return 0;
24563 if (res != AUTH_SUCCESSFUL) {
24564 if (res == AUTH_FAKE_AUTH) {
24565 ast_log(LOG_NOTICE, "Sending fake auth rejection for device %s\n", get_header(req, "From"));
24566 transmit_fake_auth_response(p, SIP_SUBSCRIBE, req, XMIT_UNRELIABLE);
24567 } else {
24568 ast_log(LOG_NOTICE, "Failed to authenticate device %s for SUBSCRIBE\n", get_header(req, "From"));
24569 transmit_response_reliable(p, "403 Forbidden", req);
24570 }
24571
24572 pvt_set_needdestroy(p, "authentication failed");
24573 return 0;
24574 }
24575 }
24576
24577
24578
24579
24580
24581
24582 if (!ast_test_flag(&p->flags[1], SIP_PAGE2_ALLOWSUBSCRIBE)) {
24583 transmit_response(p, "403 Forbidden (policy)", req);
24584 pvt_set_needdestroy(p, "subscription not allowed");
24585 if (authpeer) {
24586 unref_peer(authpeer, "unref_peer, from handle_request_subscribe (authpeer 1)");
24587 }
24588 return 0;
24589 }
24590
24591 if (strcmp(event, "message-summary") && strcmp(event, "call-completion")) {
24592
24593 gotdest = get_destination(p, NULL, NULL);
24594 }
24595
24596
24597 parse_ok_contact(p, req);
24598
24599 build_contact(p);
24600 if (gotdest != SIP_GET_DEST_EXTEN_FOUND) {
24601 if (gotdest == SIP_GET_DEST_INVALID_URI) {
24602 transmit_response(p, "416 Unsupported URI scheme", req);
24603 } else {
24604 transmit_response(p, "404 Not Found", req);
24605 }
24606 pvt_set_needdestroy(p, "subscription target not found");
24607 if (authpeer) {
24608 unref_peer(authpeer, "unref_peer, from handle_request_subscribe (authpeer 2)");
24609 }
24610 return 0;
24611 }
24612
24613
24614 if (ast_strlen_zero(p->tag))
24615 make_our_tag(p->tag, sizeof(p->tag));
24616
24617 if (!strcmp(event, "presence") || !strcmp(event, "dialog")) {
24618 unsigned int pidf_xml;
24619 const char *accept;
24620 int start = 0;
24621 enum subscriptiontype subscribed = NONE;
24622 const char *unknown_acceptheader = NULL;
24623
24624
24625 accept = __get_header(req, "Accept", &start);
24626 while ((subscribed == NONE) && !ast_strlen_zero(accept)) {
24627 pidf_xml = strstr(accept, "application/pidf+xml") ? 1 : 0;
24628
24629
24630
24631 if (pidf_xml && strstr(p->useragent, "Polycom")) {
24632 subscribed = XPIDF_XML;
24633 } else if (pidf_xml) {
24634 subscribed = PIDF_XML;
24635 } else if (strstr(accept, "application/dialog-info+xml")) {
24636 subscribed = DIALOG_INFO_XML;
24637
24638 } else if (strstr(accept, "application/cpim-pidf+xml")) {
24639 subscribed = CPIM_PIDF_XML;
24640 } else if (strstr(accept, "application/xpidf+xml")) {
24641 subscribed = XPIDF_XML;
24642 } else {
24643 unknown_acceptheader = accept;
24644 }
24645
24646 accept = __get_header(req, "Accept", &start);
24647 }
24648
24649 if (!start) {
24650 if (p->subscribed == NONE) {
24651 transmit_response(p, "489 Bad Event", req);
24652 ast_log(LOG_WARNING,"SUBSCRIBE failure: no Accept header: pvt: "
24653 "stateid: %d, laststate: %d, dialogver: %u, subscribecont: "
24654 "'%s', subscribeuri: '%s'\n",
24655 p->stateid,
24656 p->laststate,
24657 p->dialogver,
24658 p->subscribecontext,
24659 p->subscribeuri);
24660 pvt_set_needdestroy(p, "no Accept header");
24661 if (authpeer) {
24662 unref_peer(authpeer, "unref_peer, from handle_request_subscribe (authpeer 2)");
24663 }
24664 return 0;
24665 }
24666
24667
24668 } else if (subscribed == NONE) {
24669
24670 char mybuf[200];
24671 if (!ast_strlen_zero(unknown_acceptheader)) {
24672 snprintf(mybuf, sizeof(mybuf), "489 Bad Event (format %s)", unknown_acceptheader);
24673 } else {
24674 snprintf(mybuf, sizeof(mybuf), "489 Bad Event");
24675 }
24676 transmit_response(p, mybuf, req);
24677 ast_log(LOG_WARNING,"SUBSCRIBE failure: unrecognized format:"
24678 "'%s' pvt: subscribed: %d, stateid: %d, laststate: %d,"
24679 "dialogver: %u, subscribecont: '%s', subscribeuri: '%s'\n",
24680 unknown_acceptheader,
24681 (int)p->subscribed,
24682 p->stateid,
24683 p->laststate,
24684 p->dialogver,
24685 p->subscribecontext,
24686 p->subscribeuri);
24687 pvt_set_needdestroy(p, "unrecognized format");
24688 if (authpeer) {
24689 unref_peer(authpeer, "unref_peer, from handle_request_subscribe (authpeer 2)");
24690 }
24691 return 0;
24692 } else {
24693 p->subscribed = subscribed;
24694 }
24695 } else if (!strcmp(event, "message-summary")) {
24696 int start = 0;
24697 int found_supported = 0;
24698 const char *acceptheader;
24699
24700 acceptheader = __get_header(req, "Accept", &start);
24701 while (!found_supported && !ast_strlen_zero(acceptheader)) {
24702 found_supported = strcmp(acceptheader, "application/simple-message-summary") ? 0 : 1;
24703 if (!found_supported && (option_debug > 2)) {
24704 ast_log(LOG_DEBUG, "Received SIP mailbox subscription for unknown format: %s\n", acceptheader);
24705 }
24706 acceptheader = __get_header(req, "Accept", &start);
24707 }
24708 if (start && !found_supported) {
24709
24710 transmit_response(p, "406 Not Acceptable", req);
24711 ast_debug(2, "Received SIP mailbox subscription for unknown format: %s\n", acceptheader);
24712 pvt_set_needdestroy(p, "unknown format");
24713 if (authpeer) {
24714 unref_peer(authpeer, "unref_peer, from handle_request_subscribe (authpeer 3)");
24715 }
24716 return 0;
24717 }
24718
24719
24720
24721
24722
24723 if (!authpeer || AST_LIST_EMPTY(&authpeer->mailboxes)) {
24724 if (!authpeer) {
24725 transmit_response(p, "404 Not found", req);
24726 } else {
24727 transmit_response(p, "404 Not found (no mailbox)", req);
24728 ast_log(LOG_NOTICE, "Received SIP subscribe for peer without mailbox: %s\n", S_OR(authpeer->name, ""));
24729 }
24730 pvt_set_needdestroy(p, "received 404 response");
24731 if (authpeer) {
24732 unref_peer(authpeer, "unref_peer, from handle_request_subscribe (authpeer 3)");
24733 }
24734 return 0;
24735 }
24736
24737 p->subscribed = MWI_NOTIFICATION;
24738 if (ast_test_flag(&authpeer->flags[1], SIP_PAGE2_SUBSCRIBEMWIONLY)) {
24739 ao2_unlock(p);
24740 add_peer_mwi_subs(authpeer);
24741 ao2_lock(p);
24742 }
24743 if (authpeer->mwipvt != p) {
24744
24745 if (authpeer->mwipvt) {
24746 dialog_unlink_all(authpeer->mwipvt);
24747 authpeer->mwipvt = dialog_unref(authpeer->mwipvt, "unref dialog authpeer->mwipvt");
24748 }
24749 authpeer->mwipvt = dialog_ref(p, "setting peers' mwipvt to p");
24750 }
24751 if (p->relatedpeer != authpeer) {
24752 if (p->relatedpeer) {
24753 unref_peer(p->relatedpeer, "Unref previously stored relatedpeer ptr");
24754 }
24755 p->relatedpeer = ref_peer(authpeer, "setting dialog's relatedpeer pointer");
24756 }
24757
24758 } else if (!strcmp(event, "call-completion")) {
24759 handle_cc_subscribe(p, req);
24760 } else {
24761 transmit_response(p, "489 Bad Event", req);
24762 ast_debug(2, "Received SIP subscribe for unknown event package: %s\n", event);
24763 pvt_set_needdestroy(p, "unknown event package");
24764 if (authpeer) {
24765 unref_peer(authpeer, "unref_peer, from handle_request_subscribe (authpeer 5)");
24766 }
24767 return 0;
24768 }
24769
24770
24771 if (p->subscribed != MWI_NOTIFICATION && p->subscribed != CALL_COMPLETION && !resubscribe) {
24772 if (p->stateid != -1) {
24773 ast_extension_state_del(p->stateid, cb_extensionstate);
24774 }
24775 dialog_ref(p, "copying dialog ptr into extension state struct");
24776 p->stateid = ast_extension_state_add_destroy(p->context, p->exten,
24777 cb_extensionstate, cb_extensionstate_destroy, p);
24778 if (p->stateid == -1) {
24779 dialog_unref(p, "copying dialog ptr into extension state struct failed");
24780 }
24781 }
24782
24783 if (!req->ignore && p)
24784 p->lastinvite = seqno;
24785 if (p && !p->needdestroy) {
24786 p->expiry = atoi(get_header(req, "Expires"));
24787
24788
24789 if (p->expiry > max_expiry) {
24790 p->expiry = max_expiry;
24791 } else if (p->expiry < min_expiry && p->expiry > 0) {
24792 transmit_response_with_minexpires(p, "423 Interval too small", req);
24793 ast_log(LOG_WARNING, "Received subscription for extension \"%s\" context \"%s\" "
24794 "with Expire header less that 'minexpire' limit. Received \"Expire: %d\" min is %d\n",
24795 p->exten, p->context, p->expiry, min_expiry);
24796 pvt_set_needdestroy(p, "Expires is less that the min expires allowed.");
24797 if (authpeer) {
24798 unref_peer(authpeer, "unref_peer, from handle_request_subscribe (authpeer 6)");
24799 }
24800 return 0;
24801 }
24802
24803 if (sipdebug) {
24804 if (p->subscribed == MWI_NOTIFICATION && p->relatedpeer) {
24805 ast_debug(2, "Adding subscription for mailbox notification - peer %s\n", p->relatedpeer->name);
24806 } else if (p->subscribed == CALL_COMPLETION) {
24807 ast_debug(2, "Adding CC subscription for peer %s\n", p->username);
24808 } else {
24809 ast_debug(2, "Adding subscription for extension %s context %s for peer %s\n", p->exten, p->context, p->username);
24810 }
24811 }
24812 if (p->autokillid > -1 && sip_cancel_destroy(p))
24813 ast_log(LOG_WARNING, "Unable to cancel SIP destruction. Expect bad things.\n");
24814 if (p->expiry > 0)
24815 sip_scheddestroy(p, (p->expiry + 10) * 1000);
24816
24817 if (p->subscribed == MWI_NOTIFICATION) {
24818 ast_set_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
24819 transmit_response(p, "200 OK", req);
24820 if (p->relatedpeer) {
24821 struct sip_peer *peer = p->relatedpeer;
24822 ref_peer(peer, "ensure a peer ref is held during MWI sending");
24823 ao2_unlock(p);
24824 sip_send_mwi_to_peer(peer, 0);
24825 ao2_lock(p);
24826 unref_peer(peer, "release a peer ref now that MWI is sent");
24827 }
24828 } else if (p->subscribed != CALL_COMPLETION) {
24829 if ((firststate = ast_extension_state(NULL, p->context, p->exten)) < 0) {
24830
24831 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_sockaddr_stringify(&p->sa));
24832 transmit_response(p, "404 Not found", req);
24833 pvt_set_needdestroy(p, "no extension for SUBSCRIBE");
24834 if (authpeer) {
24835 unref_peer(authpeer, "unref_peer, from handle_request_subscribe (authpeer 6)");
24836 }
24837 return 0;
24838 }
24839 ast_set_flag(&p->flags[1], SIP_PAGE2_DIALOG_ESTABLISHED);
24840 transmit_response(p, "200 OK", req);
24841 transmit_state_notify(p, firststate, 1, FALSE);
24842 append_history(p, "Subscribestatus", "%s", ast_extension_state2str(firststate));
24843
24844 ast_string_field_build(p, subscribeuri, "%s@%s", p->exten, p->context);
24845
24846
24847 }
24848 if (!p->expiry) {
24849 pvt_set_needdestroy(p, "forcing expiration");
24850 }
24851 }
24852
24853 if (authpeer) {
24854 unref_peer(authpeer, "unref pointer into (*authpeer)");
24855 }
24856 return 1;
24857 }
24858
24859
24860 static int handle_request_register(struct sip_pvt *p, struct sip_request *req, struct ast_sockaddr *addr, const char *e)
24861 {
24862 enum check_auth_result res;
24863
24864
24865
24866 if (p->initreq.headers && p->initreq.method != SIP_REGISTER) {
24867 ast_log(LOG_WARNING, "Ignoring spurious REGISTER with Call-ID: %s\n", p->callid);
24868 return -1;
24869 }
24870
24871
24872 copy_request(&p->initreq, req);
24873 if (sipdebug)
24874 ast_debug(4, "Initializing initreq for method %s - callid %s\n", sip_methods[req->method].text, p->callid);
24875 check_via(p, req);
24876 if ((res = register_verify(p, addr, req, e)) < 0) {
24877 const char *reason;
24878
24879 switch (res) {
24880 case AUTH_SECRET_FAILED:
24881 reason = "Wrong password";
24882 break;
24883 case AUTH_USERNAME_MISMATCH:
24884 reason = "Username/auth name mismatch";
24885 break;
24886 case AUTH_NOT_FOUND:
24887 reason = "No matching peer found";
24888 break;
24889 case AUTH_UNKNOWN_DOMAIN:
24890 reason = "Not a local domain";
24891 break;
24892 case AUTH_PEER_NOT_DYNAMIC:
24893 reason = "Peer is not supposed to register";
24894 break;
24895 case AUTH_ACL_FAILED:
24896 reason = "Device does not match ACL";
24897 break;
24898 case AUTH_BAD_TRANSPORT:
24899 reason = "Device not configured to use this transport type";
24900 break;
24901 default:
24902 reason = "Unknown failure";
24903 break;
24904 }
24905 ast_log(LOG_NOTICE, "Registration from '%s' failed for '%s' - %s\n",
24906 get_header(req, "To"), ast_sockaddr_stringify(addr),
24907 reason);
24908 append_history(p, "RegRequest", "Failed : Account %s : %s", get_header(req, "To"), reason);
24909 } else {
24910 req->authenticated = 1;
24911 append_history(p, "RegRequest", "Succeeded : Account %s", get_header(req, "To"));
24912 }
24913
24914 if (res < 1) {
24915
24916
24917 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
24918 }
24919 return res;
24920 }
24921
24922
24923
24924
24925
24926
24927
24928
24929 static int handle_incoming(struct sip_pvt *p, struct sip_request *req, struct ast_sockaddr *addr, int *recount, int *nounlock)
24930 {
24931
24932
24933 const char *cmd;
24934 const char *cseq;
24935 const char *useragent;
24936 const char *via;
24937 const char *callid;
24938 int via_pos = 0;
24939 int seqno;
24940 int len;
24941 int respid;
24942 int res = 0;
24943 int debug = sip_debug_test_pvt(p);
24944 const char *e;
24945 int error = 0;
24946 int oldmethod = p->method;
24947 int acked = 0;
24948
24949
24950
24951
24952 cseq = get_header(req, "Cseq");
24953 cmd = REQ_OFFSET_TO_STR(req, header[0]);
24954
24955 via = __get_header(req, "Via", &via_pos);
24956
24957 callid = get_header(req, "Call-ID");
24958
24959
24960 if (ast_strlen_zero(cmd) || ast_strlen_zero(cseq) || ast_strlen_zero(via)) {
24961 ast_log(LOG_ERROR, "Dropping this SIP message with Call-ID '%s', it's incomplete.\n", callid);
24962 error = 1;
24963 }
24964 if (!error && sscanf(cseq, "%30d%n", &seqno, &len) != 1) {
24965 ast_log(LOG_ERROR, "No seqno in '%s'. Dropping incomplete message.\n", cmd);
24966 error = 1;
24967 }
24968 if (error) {
24969 if (!p->initreq.headers) {
24970 pvt_set_needdestroy(p, "no headers");
24971 }
24972 return -1;
24973 }
24974
24975
24976 cmd = REQ_OFFSET_TO_STR(req, rlPart1);
24977 e = ast_skip_blanks(REQ_OFFSET_TO_STR(req, rlPart2));
24978
24979
24980 useragent = get_header(req, "User-Agent");
24981 if (!ast_strlen_zero(useragent))
24982 ast_string_field_set(p, useragent, useragent);
24983
24984
24985 if (req->method == SIP_RESPONSE) {
24986
24987
24988
24989
24990
24991
24992 if (ast_strlen_zero(e)) {
24993 return 0;
24994 }
24995 if (sscanf(e, "%30d %n", &respid, &len) != 1) {
24996 ast_log(LOG_WARNING, "Invalid response: '%s'\n", e);
24997 return 0;
24998 }
24999 if (respid <= 0) {
25000 ast_log(LOG_WARNING, "Invalid SIP response code: '%d'\n", respid);
25001 return 0;
25002 }
25003
25004
25005
25006 if (!ast_strlen_zero(__get_header(req, "via", &via_pos))) {
25007 ast_log(LOG_WARNING, "Misrouted SIP response '%s' with Call-ID '%s', too many vias\n", e, callid);
25008 return 0;
25009 }
25010 if (p->ocseq && (p->ocseq < seqno)) {
25011 ast_debug(1, "Ignoring out of order response %d (expecting %d)\n", seqno, p->ocseq);
25012 return -1;
25013 } else {
25014 char causevar[256], causeval[256];
25015
25016 if ((respid == 200) || ((respid >= 300) && (respid <= 399))) {
25017 extract_uri(p, req);
25018 }
25019
25020 handle_response(p, respid, e + len, req, seqno);
25021
25022 if (global_store_sip_cause && p->owner) {
25023 struct ast_channel *owner = p->owner;
25024
25025 snprintf(causevar, sizeof(causevar), "MASTER_CHANNEL(HASH(SIP_CAUSE,%s))", owner->name);
25026 snprintf(causeval, sizeof(causeval), "SIP %s", REQ_OFFSET_TO_STR(req, rlPart2));
25027
25028 ast_channel_ref(owner);
25029 sip_pvt_unlock(p);
25030 ast_channel_unlock(owner);
25031 *nounlock = 1;
25032 pbx_builtin_setvar_helper(owner, causevar, causeval);
25033 ast_channel_unref(owner);
25034 sip_pvt_lock(p);
25035 }
25036 }
25037 return 0;
25038 }
25039
25040
25041
25042
25043
25044 p->method = req->method;
25045 ast_debug(4, "**** Received %s (%d) - Command in SIP %s\n", sip_methods[p->method].text, sip_methods[p->method].id, cmd);
25046
25047 if (p->icseq && (p->icseq > seqno) ) {
25048 if (p->pendinginvite && seqno == p->pendinginvite && (req->method == SIP_ACK || req->method == SIP_CANCEL)) {
25049 ast_debug(2, "Got CANCEL or ACK on INVITE with transactions in between.\n");
25050 } else {
25051 ast_debug(1, "Ignoring too old SIP packet packet %d (expecting >= %d)\n", seqno, p->icseq);
25052 if (req->method == SIP_INVITE) {
25053 unsigned int ran = (ast_random() % 10) + 1;
25054 char seconds[4];
25055 snprintf(seconds, sizeof(seconds), "%u", ran);
25056 transmit_response_with_retry_after(p, "500 Server error", req, seconds);
25057 } else if (req->method != SIP_ACK) {
25058 transmit_response(p, "500 Server error", req);
25059 }
25060 return -1;
25061 }
25062 } else if (p->icseq &&
25063 p->icseq == seqno &&
25064 req->method != SIP_ACK &&
25065 (p->method != SIP_CANCEL || p->alreadygone)) {
25066
25067
25068
25069 req->ignore = 1;
25070 ast_debug(3, "Ignoring SIP message because of retransmit (%s Seqno %d, ours %d)\n", sip_methods[p->method].text, p->icseq, seqno);
25071 }
25072
25073
25074
25075 if (!p->pendinginvite && (req->method == SIP_CANCEL)) {
25076 transmit_response(p, "481 Call/Transaction Does Not Exist", req);
25077 return res;
25078 }
25079
25080 if (seqno >= p->icseq)
25081
25082
25083
25084 p->icseq = seqno;
25085
25086
25087 if (ast_strlen_zero(p->theirtag)) {
25088 char tag[128];
25089
25090 gettag(req, "From", tag, sizeof(tag));
25091 ast_string_field_set(p, theirtag, tag);
25092 }
25093 snprintf(p->lastmsg, sizeof(p->lastmsg), "Rx: %s", cmd);
25094
25095 if (sip_cfg.pedanticsipchecking) {
25096
25097
25098
25099
25100 if (!p->initreq.headers && req->has_to_tag) {
25101
25102 if (!req->ignore && req->method == SIP_INVITE) {
25103 transmit_response_reliable(p, "481 Call/Transaction Does Not Exist", req);
25104
25105 } else if (req->method != SIP_ACK) {
25106 transmit_response(p, "481 Call/Transaction Does Not Exist", req);
25107 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
25108 } else {
25109 ast_debug(1, "Got ACK for unknown dialog... strange.\n");
25110 }
25111 return res;
25112 }
25113 }
25114
25115 if (!e && (p->method == SIP_INVITE || p->method == SIP_SUBSCRIBE || p->method == SIP_REGISTER || p->method == SIP_NOTIFY || p->method == SIP_PUBLISH)) {
25116 transmit_response(p, "400 Bad request", req);
25117 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
25118 return -1;
25119 }
25120
25121
25122 switch (p->method) {
25123 case SIP_OPTIONS:
25124 res = handle_request_options(p, req, addr, e);
25125 break;
25126 case SIP_INVITE:
25127 res = handle_request_invite(p, req, debug, seqno, addr, recount, e, nounlock);
25128 break;
25129 case SIP_REFER:
25130 res = handle_request_refer(p, req, debug, seqno, nounlock);
25131 break;
25132 case SIP_CANCEL:
25133 res = handle_request_cancel(p, req);
25134 break;
25135 case SIP_BYE:
25136 res = handle_request_bye(p, req);
25137 break;
25138 case SIP_MESSAGE:
25139 res = handle_request_message(p, req);
25140 break;
25141 case SIP_PUBLISH:
25142 res = handle_request_publish(p, req, addr, seqno, e);
25143 break;
25144 case SIP_SUBSCRIBE:
25145 res = handle_request_subscribe(p, req, addr, seqno, e);
25146 break;
25147 case SIP_REGISTER:
25148 res = handle_request_register(p, req, addr, e);
25149 break;
25150 case SIP_INFO:
25151 if (req->debug)
25152 ast_verbose("Receiving INFO!\n");
25153 if (!req->ignore)
25154 handle_request_info(p, req);
25155 else
25156 transmit_response(p, "200 OK", req);
25157 break;
25158 case SIP_NOTIFY:
25159 res = handle_request_notify(p, req, addr, seqno, e);
25160 break;
25161 case SIP_UPDATE:
25162 res = handle_request_update(p, req);
25163 break;
25164 case SIP_ACK:
25165
25166 if (seqno == p->pendinginvite) {
25167 p->invitestate = INV_TERMINATED;
25168 p->pendinginvite = 0;
25169 acked = __sip_ack(p, seqno, 1 , 0);
25170 if (find_sdp(req)) {
25171 if (process_sdp(p, req, SDP_T38_NONE))
25172 return -1;
25173 }
25174 check_pendings(p);
25175 } else if (p->glareinvite == seqno) {
25176
25177 p->glareinvite = 0;
25178 acked = __sip_ack(p, seqno, 1, 0);
25179 }
25180 if (!acked) {
25181
25182
25183 p->method = oldmethod;
25184 }
25185 if (!p->lastinvite && ast_strlen_zero(p->randdata)) {
25186 pvt_set_needdestroy(p, "unmatched ACK");
25187 }
25188 break;
25189 default:
25190 transmit_response_with_allow(p, "501 Method Not Implemented", req, 0);
25191 ast_log(LOG_NOTICE, "Unknown SIP command '%s' from '%s'\n",
25192 cmd, ast_sockaddr_stringify(&p->sa));
25193
25194 if (!p->initreq.headers) {
25195 pvt_set_needdestroy(p, "unimplemented method");
25196 }
25197 break;
25198 }
25199 return res;
25200 }
25201
25202
25203
25204
25205
25206
25207 static int sipsock_read(int *id, int fd, short events, void *ignore)
25208 {
25209 struct sip_request req;
25210 struct ast_sockaddr addr;
25211 int res;
25212 static char readbuf[65535];
25213
25214 memset(&req, 0, sizeof(req));
25215 res = ast_recvfrom(fd, readbuf, sizeof(readbuf) - 1, 0, &addr);
25216 if (res < 0) {
25217 #if !defined(__FreeBSD__)
25218 if (errno == EAGAIN)
25219 ast_log(LOG_NOTICE, "SIP: Received packet with bad UDP checksum\n");
25220 else
25221 #endif
25222 if (errno != ECONNREFUSED)
25223 ast_log(LOG_WARNING, "Recv error: %s\n", strerror(errno));
25224 return 1;
25225 }
25226
25227 readbuf[res] = '\0';
25228
25229 if (!(req.data = ast_str_create(SIP_MIN_PACKET))) {
25230 return 1;
25231 }
25232
25233 if (ast_str_set(&req.data, 0, "%s", readbuf) == AST_DYNSTR_BUILD_FAILED) {
25234 return -1;
25235 }
25236
25237 req.socket.fd = sipsock;
25238 set_socket_transport(&req.socket, SIP_TRANSPORT_UDP);
25239 req.socket.tcptls_session = NULL;
25240 req.socket.port = htons(ast_sockaddr_port(&bindaddr));
25241
25242 handle_request_do(&req, &addr);
25243 deinit_req(&req);
25244
25245 return 1;
25246 }
25247
25248
25249
25250
25251
25252 static int handle_request_do(struct sip_request *req, struct ast_sockaddr *addr)
25253 {
25254 struct sip_pvt *p;
25255 struct ast_channel *owner_chan_ref = NULL;
25256 int recount = 0;
25257 int nounlock = 0;
25258
25259 if (sip_debug_test_addr(addr))
25260 req->debug = 1;
25261 if (sip_cfg.pedanticsipchecking)
25262 lws2sws(req->data);
25263 if (req->debug) {
25264 ast_verbose("\n<--- SIP read from %s:%s --->\n%s\n<------------->\n",
25265 get_transport(req->socket.type), ast_sockaddr_stringify(addr), req->data->str);
25266 }
25267
25268 if (parse_request(req) == -1) {
25269 ast_str_reset(req->data);
25270 return 1;
25271 }
25272 req->method = find_sip_method(REQ_OFFSET_TO_STR(req, rlPart1));
25273
25274 if (req->debug)
25275 ast_verbose("--- (%d headers %d lines)%s ---\n", req->headers, req->lines, (req->headers + req->lines == 0) ? " Nat keepalive" : "");
25276
25277 if (req->headers < 2) {
25278 ast_str_reset(req->data);
25279 return 1;
25280 }
25281
25282
25283 ast_mutex_lock(&netlock);
25284
25285
25286 p = find_call(req, addr, req->method);
25287 if (p == NULL) {
25288 ast_debug(1, "Invalid SIP message - rejected , no callid, len %zu\n", ast_str_strlen(req->data));
25289 ast_mutex_unlock(&netlock);
25290 return 1;
25291 }
25292
25293
25294
25295 owner_chan_ref = sip_pvt_lock_full(p);
25296
25297 copy_socket_data(&p->socket, &req->socket);
25298 ast_sockaddr_copy(&p->recv, addr);
25299
25300
25301 if (p->owner) {
25302 req->authenticated = 1;
25303 }
25304
25305 if (p->do_history)
25306 append_history(p, "Rx", "%s / %s / %s", req->data->str, get_header(req, "CSeq"), REQ_OFFSET_TO_STR(req, rlPart2));
25307
25308 if (handle_incoming(p, req, addr, &recount, &nounlock) == -1) {
25309
25310 ast_debug(1, "SIP message could not be handled, bad request: %-70.70s\n", p->callid[0] ? p->callid : "<no callid>");
25311 }
25312
25313 if (recount) {
25314 ast_update_use_count();
25315 }
25316
25317 if (p->owner && !nounlock) {
25318 ast_channel_unlock(p->owner);
25319 }
25320 if (owner_chan_ref) {
25321 ast_channel_unref(owner_chan_ref);
25322 }
25323 sip_pvt_unlock(p);
25324 ao2_t_ref(p, -1, "throw away dialog ptr from find_call at end of routine");
25325 ast_mutex_unlock(&netlock);
25326
25327 return 1;
25328 }
25329
25330
25331
25332
25333
25334
25335
25336 static int sip_standard_port(enum sip_transport type, int port)
25337 {
25338 if (type & SIP_TRANSPORT_TLS)
25339 return port == STANDARD_TLS_PORT;
25340 else
25341 return port == STANDARD_SIP_PORT;
25342 }
25343
25344 static int threadinfo_locate_cb(void *obj, void *arg, int flags)
25345 {
25346 struct sip_threadinfo *th = obj;
25347 struct ast_sockaddr *s = arg;
25348
25349 if (!ast_sockaddr_cmp(s, &th->tcptls_session->remote_address)) {
25350 return CMP_MATCH | CMP_STOP;
25351 }
25352
25353 return 0;
25354 }
25355
25356
25357
25358
25359
25360
25361 static struct ast_tcptls_session_instance *sip_tcp_locate(struct ast_sockaddr *s)
25362 {
25363 struct sip_threadinfo *th;
25364 struct ast_tcptls_session_instance *tcptls_instance = NULL;
25365
25366 if ((th = ao2_callback(threadt, 0, threadinfo_locate_cb, s))) {
25367 tcptls_instance = (ao2_ref(th->tcptls_session, +1), th->tcptls_session);
25368 ao2_t_ref(th, -1, "decrement ref from callback");
25369 }
25370
25371 return tcptls_instance;
25372 }
25373
25374
25375
25376
25377
25378
25379 int get_address_family_filter(const struct ast_sockaddr *addr)
25380 {
25381 if (ast_sockaddr_is_ipv6(addr) && ast_sockaddr_is_any(addr)) {
25382 return 0;
25383 }
25384
25385 return addr->ss.ss_family;
25386 }
25387
25388
25389 static int sip_prepare_socket(struct sip_pvt *p)
25390 {
25391 struct sip_socket *s = &p->socket;
25392 static const char name[] = "SIP socket";
25393 struct sip_threadinfo *th = NULL;
25394 struct ast_tcptls_session_instance *tcptls_session;
25395 struct ast_tcptls_session_args *ca;
25396 struct ast_sockaddr sa_tmp;
25397
25398
25399 if ((s->fd != -1) && (s->type == SIP_TRANSPORT_UDP)) {
25400 return s->fd;
25401 }
25402 if ((s->type & (SIP_TRANSPORT_TCP | SIP_TRANSPORT_TLS)) &&
25403 (s->tcptls_session) &&
25404 (s->tcptls_session->fd != -1)) {
25405 return s->tcptls_session->fd;
25406 }
25407
25408
25409
25410
25411 if (p->outboundproxy && p->outboundproxy->transport) {
25412 s->type = p->outboundproxy->transport;
25413 }
25414
25415 if (s->type == SIP_TRANSPORT_UDP) {
25416 s->fd = sipsock;
25417 return s->fd;
25418 }
25419
25420
25421
25422
25423
25424
25425
25426
25427
25428
25429
25430 ast_sockaddr_copy(&sa_tmp, sip_real_dst(p));
25431 if ((tcptls_session = sip_tcp_locate(&sa_tmp))) {
25432 s->fd = tcptls_session->fd;
25433 if (s->tcptls_session) {
25434 ao2_ref(s->tcptls_session, -1);
25435 s->tcptls_session = NULL;
25436 }
25437 s->tcptls_session = tcptls_session;
25438 return s->fd;
25439
25440 } else if (s->tcptls_session) {
25441 return s->fd;
25442 }
25443
25444
25445
25446 if (!(ca = ao2_alloc(sizeof(*ca), sip_tcptls_client_args_destructor)) ||
25447 !(ca->name = ast_strdup(name))) {
25448 goto create_tcptls_session_fail;
25449 }
25450 ca->accept_fd = -1;
25451 ast_sockaddr_copy(&ca->remote_address,sip_real_dst(p));
25452
25453 if (s->type == SIP_TRANSPORT_TLS) {
25454 if (!(ca->tls_cfg = ast_calloc(1, sizeof(*ca->tls_cfg)))) {
25455 goto create_tcptls_session_fail;
25456 }
25457 memcpy(ca->tls_cfg, &default_tls_cfg, sizeof(*ca->tls_cfg));
25458
25459 if (!(ca->tls_cfg->certfile = ast_strdup(default_tls_cfg.certfile)) ||
25460 !(ca->tls_cfg->pvtfile = ast_strdup(default_tls_cfg.pvtfile)) ||
25461 !(ca->tls_cfg->cipher = ast_strdup(default_tls_cfg.cipher)) ||
25462 !(ca->tls_cfg->cafile = ast_strdup(default_tls_cfg.cafile)) ||
25463 !(ca->tls_cfg->capath = ast_strdup(default_tls_cfg.capath))) {
25464
25465 goto create_tcptls_session_fail;
25466 }
25467
25468
25469 if (!ast_strlen_zero(p->tohost)) {
25470 ast_copy_string(ca->hostname, p->tohost, sizeof(ca->hostname));
25471 }
25472 }
25473
25474
25475 if (!(s->tcptls_session = ast_tcptls_client_create(ca))) {
25476 goto create_tcptls_session_fail;
25477 }
25478
25479 s->fd = s->tcptls_session->fd;
25480
25481
25482
25483
25484
25485 if (!(th = sip_threadinfo_create(s->tcptls_session, s->type))) {
25486 goto create_tcptls_session_fail;
25487 }
25488
25489
25490 ao2_ref(s->tcptls_session, +1);
25491
25492 if (ast_pthread_create_background(&ca->master, NULL, sip_tcp_worker_fn, s->tcptls_session)) {
25493 ast_debug(1, "Unable to launch '%s'.", ca->name);
25494 ao2_ref(s->tcptls_session, -1);
25495 goto create_tcptls_session_fail;
25496 }
25497
25498 return s->fd;
25499
25500 create_tcptls_session_fail:
25501 if (ca) {
25502 ao2_t_ref(ca, -1, "failed to create client, getting rid of client tcptls_session arguments");
25503 }
25504 if (s->tcptls_session) {
25505 ast_tcptls_close_session_file(tcptls_session);
25506 s->fd = -1;
25507 ao2_ref(s->tcptls_session, -1);
25508 s->tcptls_session = NULL;
25509 }
25510 if (th) {
25511 ao2_t_unlink(threadt, th, "Removing tcptls thread info object, thread failed to open");
25512 }
25513
25514 return -1;
25515 }
25516
25517
25518
25519
25520
25521 static int get_cached_mwi(struct sip_peer *peer, int *new, int *old)
25522 {
25523 struct sip_mailbox *mailbox;
25524 int in_cache;
25525
25526 in_cache = 0;
25527 AST_LIST_TRAVERSE(&peer->mailboxes, mailbox, entry) {
25528 struct ast_event *event;
25529 event = ast_event_get_cached(AST_EVENT_MWI,
25530 AST_EVENT_IE_MAILBOX, AST_EVENT_IE_PLTYPE_STR, mailbox->mailbox,
25531 AST_EVENT_IE_CONTEXT, AST_EVENT_IE_PLTYPE_STR, S_OR(mailbox->context, "default"),
25532 AST_EVENT_IE_END);
25533 if (!event)
25534 continue;
25535 *new += ast_event_get_ie_uint(event, AST_EVENT_IE_NEWMSGS);
25536 *old += ast_event_get_ie_uint(event, AST_EVENT_IE_OLDMSGS);
25537 ast_event_destroy(event);
25538 in_cache = 1;
25539 }
25540
25541 return in_cache;
25542 }
25543
25544
25545
25546
25547 static int sip_send_mwi_to_peer(struct sip_peer *peer, int cache_only)
25548 {
25549
25550 struct sip_pvt *p;
25551 int newmsgs = 0, oldmsgs = 0;
25552 const char *vmexten = NULL;
25553
25554 ao2_lock(peer);
25555
25556 if (peer->vmexten) {
25557 vmexten = ast_strdupa(peer->vmexten);
25558 }
25559
25560 if (ast_test_flag((&peer->flags[1]), SIP_PAGE2_SUBSCRIBEMWIONLY) && !peer->mwipvt) {
25561 ao2_unlock(peer);
25562 return 0;
25563 }
25564
25565
25566 if (ast_sockaddr_isnull(&peer->addr) && ast_sockaddr_isnull(&peer->defaddr)) {
25567 ao2_unlock(peer);
25568 return 0;
25569 }
25570
25571
25572 if (!get_cached_mwi(peer, &newmsgs, &oldmsgs) && !cache_only) {
25573
25574 struct ast_str *mailbox_str = ast_str_alloca(512);
25575 peer_mailboxes_to_str(&mailbox_str, peer);
25576 ao2_unlock(peer);
25577 ast_app_inboxcount(mailbox_str->str, &newmsgs, &oldmsgs);
25578 ao2_lock(peer);
25579 }
25580
25581 if (peer->mwipvt) {
25582
25583 p = dialog_ref(peer->mwipvt, "sip_send_mwi_to_peer: Setting dialog ptr p from peer->mwipvt");
25584 ao2_unlock(peer);
25585 } else {
25586 ao2_unlock(peer);
25587
25588 if (!(p = sip_alloc(NULL, NULL, 0, SIP_NOTIFY, NULL))) {
25589 return -1;
25590 }
25591
25592
25593
25594
25595
25596 set_socket_transport(&p->socket, 0);
25597 if (create_addr_from_peer(p, peer)) {
25598
25599 dialog_unlink_all(p);
25600 dialog_unref(p, "unref dialog p just created via sip_alloc");
25601
25602 return 0;
25603 }
25604
25605 ast_sip_ouraddrfor(&p->sa, &p->ourip, p);
25606 build_via(p);
25607
25608 ao2_lock(peer);
25609 if (!ast_strlen_zero(peer->mwi_from)) {
25610 ast_string_field_set(p, mwi_from, peer->mwi_from);
25611 } else if (!ast_strlen_zero(default_mwi_from)) {
25612 ast_string_field_set(p, mwi_from, default_mwi_from);
25613 }
25614 ao2_unlock(peer);
25615
25616
25617 change_callid_pvt(p, NULL);
25618
25619
25620 sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
25621 }
25622
25623
25624
25625 sip_pvt_lock(p);
25626
25627
25628 ast_set_flag(&p->flags[0], SIP_OUTGOING);
25629
25630 transmit_notify_with_mwi(p, newmsgs, oldmsgs, vmexten);
25631 sip_pvt_unlock(p);
25632 dialog_unref(p, "unref dialog ptr p just before it goes out of scope at the end of sip_send_mwi_to_peer.");
25633
25634 return 0;
25635 }
25636
25637
25638 static void check_rtp_timeout(struct sip_pvt *dialog, time_t t)
25639 {
25640
25641 if (!dialog->rtp || !dialog->owner)
25642 return;
25643
25644
25645 if (dialog->owner->_state != AST_STATE_UP || !ast_sockaddr_isnull(&dialog->redirip))
25646 return;
25647
25648
25649 if (dialog->t38.state == T38_ENABLED)
25650 return;
25651
25652
25653 if (!ast_rtp_instance_get_keepalive(dialog->rtp) && !ast_rtp_instance_get_timeout(dialog->rtp) && !ast_rtp_instance_get_hold_timeout(dialog->rtp)) {
25654 return;
25655 }
25656
25657
25658 if (dialog->lastrtptx && ast_rtp_instance_get_keepalive(dialog->rtp) &&
25659 (t > dialog->lastrtptx + ast_rtp_instance_get_keepalive(dialog->rtp))) {
25660
25661 dialog->lastrtptx = time(NULL);
25662 ast_rtp_instance_sendcng(dialog->rtp, 0);
25663 }
25664
25665
25666
25667
25668
25669
25670
25671
25672 if (dialog->lastrtprx && (ast_rtp_instance_get_timeout(dialog->rtp) || ast_rtp_instance_get_hold_timeout(dialog->rtp)) && (t > dialog->lastrtprx + ast_rtp_instance_get_timeout(dialog->rtp))) {
25673 if (!ast_test_flag(&dialog->flags[1], SIP_PAGE2_CALL_ONHOLD) || (ast_rtp_instance_get_hold_timeout(dialog->rtp) && (t > dialog->lastrtprx + ast_rtp_instance_get_hold_timeout(dialog->rtp)))) {
25674
25675 if (ast_rtp_instance_get_timeout(dialog->rtp)) {
25676 if (!dialog->owner || ast_channel_trylock(dialog->owner)) {
25677
25678
25679
25680
25681 return;
25682 }
25683 ast_log(LOG_NOTICE, "Disconnecting call '%s' for lack of RTP activity in %ld seconds\n",
25684 dialog->owner->name, (long) (t - dialog->lastrtprx));
25685
25686 ast_softhangup_nolock(dialog->owner, AST_SOFTHANGUP_DEV);
25687 ast_channel_unlock(dialog->owner);
25688
25689
25690
25691
25692 ast_rtp_instance_set_timeout(dialog->rtp, 0);
25693 ast_rtp_instance_set_hold_timeout(dialog->rtp, 0);
25694 if (dialog->vrtp) {
25695 ast_rtp_instance_set_timeout(dialog->vrtp, 0);
25696 ast_rtp_instance_set_hold_timeout(dialog->vrtp, 0);
25697 }
25698 }
25699 }
25700 }
25701 }
25702
25703
25704
25705
25706
25707 static void *do_monitor(void *data)
25708 {
25709 int res;
25710 time_t t;
25711 int reloading;
25712
25713
25714 if (sipsock > -1)
25715 sipsock_read_id = ast_io_add(io, sipsock, sipsock_read, AST_IO_IN, NULL);
25716
25717
25718 for(;;) {
25719
25720 ast_mutex_lock(&sip_reload_lock);
25721 reloading = sip_reloading;
25722 sip_reloading = FALSE;
25723 ast_mutex_unlock(&sip_reload_lock);
25724 if (reloading) {
25725 ast_verb(1, "Reloading SIP\n");
25726 sip_do_reload(sip_reloadreason);
25727
25728
25729 if (sipsock > -1) {
25730 if (sipsock_read_id)
25731 sipsock_read_id = ast_io_change(io, sipsock_read_id, sipsock, NULL, 0, NULL);
25732 else
25733 sipsock_read_id = ast_io_add(io, sipsock, sipsock_read, AST_IO_IN, NULL);
25734 } else if (sipsock_read_id) {
25735 ast_io_remove(io, sipsock_read_id);
25736 sipsock_read_id = NULL;
25737 }
25738 }
25739
25740
25741 t = time(NULL);
25742
25743
25744
25745
25746
25747
25748
25749
25750
25751
25752 ao2_t_callback(dialogs, OBJ_NODATA | OBJ_MULTIPLE, dialog_needdestroy, &t,
25753 "callback to monitor dialog status");
25754 if (ao2_container_count(dialogs_to_destroy)) {
25755
25756 ao2_t_callback(dialogs_to_destroy, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE,
25757 dialog_unlink_callback, NULL, "callback to dialog_unlink_all");
25758 }
25759
25760
25761
25762
25763
25764
25765
25766 pthread_testcancel();
25767
25768 res = ast_sched_wait(sched);
25769 if ((res < 0) || (res > 1000))
25770 res = 1000;
25771 res = ast_io_wait(io, res);
25772 if (res > 20)
25773 ast_debug(1, "chan_sip: ast_io_wait ran %d all at once\n", res);
25774 ast_mutex_lock(&monlock);
25775 res = ast_sched_runq(sched);
25776 if (res >= 20)
25777 ast_debug(1, "chan_sip: ast_sched_runq ran %d all at once\n", res);
25778 if (global_store_sip_cause && res >= 100)
25779 ast_log(LOG_WARNING, "scheduler delays detected, setting 'storesipcause' to 'no' in %s will improve performance\n", config);
25780 ast_mutex_unlock(&monlock);
25781 }
25782
25783
25784 return NULL;
25785 }
25786
25787
25788 static int restart_monitor(void)
25789 {
25790
25791 if (monitor_thread == AST_PTHREADT_STOP)
25792 return 0;
25793 ast_mutex_lock(&monlock);
25794 if (monitor_thread == pthread_self()) {
25795 ast_mutex_unlock(&monlock);
25796 ast_log(LOG_WARNING, "Cannot kill myself\n");
25797 return -1;
25798 }
25799 if (monitor_thread != AST_PTHREADT_NULL) {
25800
25801 pthread_kill(monitor_thread, SIGURG);
25802 } else {
25803
25804 if (ast_pthread_create_background(&monitor_thread, NULL, do_monitor, NULL) < 0) {
25805 ast_mutex_unlock(&monlock);
25806 ast_log(LOG_ERROR, "Unable to start monitor thread.\n");
25807 return -1;
25808 }
25809 }
25810 ast_mutex_unlock(&monlock);
25811 return 0;
25812 }
25813
25814
25815
25816 static void restart_session_timer(struct sip_pvt *p)
25817 {
25818 if (!p->stimer) {
25819 ast_log(LOG_WARNING, "Null stimer in restart_session_timer - %s\n", p->callid);
25820 return;
25821 }
25822
25823 if (p->stimer->st_active == TRUE) {
25824 ast_debug(2, "Session timer stopped: %d - %s\n", p->stimer->st_schedid, p->callid);
25825 AST_SCHED_DEL_UNREF(sched, p->stimer->st_schedid,
25826 dialog_unref(p, "Removing session timer ref"));
25827 start_session_timer(p);
25828 }
25829 }
25830
25831
25832
25833 static void stop_session_timer(struct sip_pvt *p)
25834 {
25835 if (!p->stimer) {
25836 ast_log(LOG_WARNING, "Null stimer in stop_session_timer - %s\n", p->callid);
25837 return;
25838 }
25839
25840 if (p->stimer->st_active == TRUE) {
25841 p->stimer->st_active = FALSE;
25842 ast_debug(2, "Session timer stopped: %d - %s\n", p->stimer->st_schedid, p->callid);
25843 AST_SCHED_DEL_UNREF(sched, p->stimer->st_schedid,
25844 dialog_unref(p, "removing session timer ref"));
25845 }
25846 }
25847
25848
25849
25850 static void start_session_timer(struct sip_pvt *p)
25851 {
25852 if (!p->stimer) {
25853 ast_log(LOG_WARNING, "Null stimer in start_session_timer - %s\n", p->callid);
25854 return;
25855 }
25856
25857 if (p->stimer->st_schedid > -1) {
25858
25859 ast_debug(2, "Session timer stopped: %d - %s\n", p->stimer->st_schedid, p->callid);
25860 AST_SCHED_DEL_UNREF(sched, p->stimer->st_schedid,
25861 dialog_unref(p, "unref stimer->st_schedid from dialog"));
25862 }
25863
25864 p->stimer->st_schedid = ast_sched_add(sched, p->stimer->st_interval * 1000 / 2, proc_session_timer,
25865 dialog_ref(p, "adding session timer ref"));
25866 if (p->stimer->st_schedid < 0) {
25867 dialog_unref(p, "removing session timer ref");
25868 ast_log(LOG_ERROR, "ast_sched_add failed - %s\n", p->callid);
25869 } else {
25870 p->stimer->st_active = TRUE;
25871 ast_debug(2, "Session timer started: %d - %s\n", p->stimer->st_schedid, p->callid);
25872 }
25873 }
25874
25875
25876
25877 static int proc_session_timer(const void *vp)
25878 {
25879 struct sip_pvt *p = (struct sip_pvt *) vp;
25880 int sendreinv = FALSE;
25881 int res = 0;
25882
25883 if (!p->stimer) {
25884 ast_log(LOG_WARNING, "Null stimer in proc_session_timer - %s\n", p->callid);
25885 goto return_unref;
25886 }
25887
25888 ast_debug(2, "Session timer expired: %d - %s\n", p->stimer->st_schedid, p->callid);
25889
25890 if (!p->owner) {
25891 goto return_unref;
25892 }
25893
25894 if ((p->stimer->st_active != TRUE) || (p->owner->_state != AST_STATE_UP)) {
25895 goto return_unref;
25896 }
25897
25898 switch (p->stimer->st_ref) {
25899 case SESSION_TIMER_REFRESHER_UAC:
25900 if (p->outgoing_call == TRUE) {
25901 sendreinv = TRUE;
25902 }
25903 break;
25904 case SESSION_TIMER_REFRESHER_UAS:
25905 if (p->outgoing_call != TRUE) {
25906 sendreinv = TRUE;
25907 }
25908 break;
25909 default:
25910 ast_log(LOG_ERROR, "Unknown session refresher %d\n", p->stimer->st_ref);
25911 goto return_unref;
25912 }
25913
25914 if (sendreinv == TRUE) {
25915 res = 1;
25916 transmit_reinvite_with_sdp(p, FALSE, TRUE);
25917 } else {
25918 p->stimer->st_expirys++;
25919 if (p->stimer->st_expirys >= 2) {
25920 if (p->stimer->quit_flag) {
25921 goto return_unref;
25922 }
25923 ast_log(LOG_WARNING, "Session-Timer expired - %s\n", p->callid);
25924 sip_pvt_lock(p);
25925 while (p->owner && ast_channel_trylock(p->owner)) {
25926 sip_pvt_unlock(p);
25927 usleep(1);
25928 if (p->stimer && p->stimer->quit_flag) {
25929 goto return_unref;
25930 }
25931 sip_pvt_lock(p);
25932 }
25933
25934 ast_softhangup_nolock(p->owner, AST_SOFTHANGUP_DEV);
25935 ast_channel_unlock(p->owner);
25936 sip_pvt_unlock(p);
25937 } else {
25938 res = 1;
25939 }
25940 }
25941
25942 return_unref:
25943 if (!res) {
25944
25945 if (p->stimer) {
25946 ast_debug(2, "Session timer stopped: %d - %s\n", p->stimer->st_schedid, p->callid);
25947 p->stimer->st_schedid = -1;
25948 stop_session_timer(p);
25949 }
25950
25951
25952
25953 dialog_unref(p, "removing session timer ref");
25954 }
25955
25956 return res;
25957 }
25958
25959
25960
25961 int parse_minse (const char *p_hdrval, int *const p_interval)
25962 {
25963 if (ast_strlen_zero(p_hdrval)) {
25964 ast_log(LOG_WARNING, "Null Min-SE header\n");
25965 return -1;
25966 }
25967
25968 *p_interval = 0;
25969 p_hdrval = ast_skip_blanks(p_hdrval);
25970 if (!sscanf(p_hdrval, "%30d", p_interval)) {
25971 ast_log(LOG_WARNING, "Parsing of Min-SE header failed %s\n", p_hdrval);
25972 return -1;
25973 }
25974
25975 ast_debug(2, "Received Min-SE: %d\n", *p_interval);
25976 return 0;
25977 }
25978
25979
25980
25981 int parse_session_expires(const char *p_hdrval, int *const p_interval, enum st_refresher *const p_ref)
25982 {
25983 char *p_token;
25984 int ref_idx;
25985 char *p_se_hdr;
25986
25987 if (ast_strlen_zero(p_hdrval)) {
25988 ast_log(LOG_WARNING, "Null Session-Expires header\n");
25989 return -1;
25990 }
25991
25992 *p_ref = SESSION_TIMER_REFRESHER_AUTO;
25993 *p_interval = 0;
25994
25995 p_se_hdr = ast_strdupa(p_hdrval);
25996 p_se_hdr = ast_skip_blanks(p_se_hdr);
25997
25998 while ((p_token = strsep(&p_se_hdr, ";"))) {
25999 p_token = ast_skip_blanks(p_token);
26000 if (!sscanf(p_token, "%30d", p_interval)) {
26001 ast_log(LOG_WARNING, "Parsing of Session-Expires failed\n");
26002 return -1;
26003 }
26004
26005 ast_debug(2, "Session-Expires: %d\n", *p_interval);
26006
26007 if (!p_se_hdr)
26008 continue;
26009
26010 p_se_hdr = ast_skip_blanks(p_se_hdr);
26011 ref_idx = strlen("refresher=");
26012 if (!strncasecmp(p_se_hdr, "refresher=", ref_idx)) {
26013 p_se_hdr += ref_idx;
26014 p_se_hdr = ast_skip_blanks(p_se_hdr);
26015
26016 if (!strncasecmp(p_se_hdr, "uac", strlen("uac"))) {
26017 *p_ref = SESSION_TIMER_REFRESHER_UAC;
26018 ast_debug(2, "Refresher: UAC\n");
26019 } else if (!strncasecmp(p_se_hdr, "uas", strlen("uas"))) {
26020 *p_ref = SESSION_TIMER_REFRESHER_UAS;
26021 ast_debug(2, "Refresher: UAS\n");
26022 } else {
26023 ast_log(LOG_WARNING, "Invalid refresher value %s\n", p_se_hdr);
26024 return -1;
26025 }
26026 break;
26027 }
26028 }
26029 return 0;
26030 }
26031
26032
26033
26034
26035
26036
26037
26038
26039
26040 static void proc_422_rsp(struct sip_pvt *p, struct sip_request *rsp)
26041 {
26042 int rtn;
26043 const char *p_hdrval;
26044 int minse;
26045
26046 p_hdrval = get_header(rsp, "Min-SE");
26047 if (ast_strlen_zero(p_hdrval)) {
26048 ast_log(LOG_WARNING, "422 response without a Min-SE header %s\n", p_hdrval);
26049 return;
26050 }
26051 rtn = parse_minse(p_hdrval, &minse);
26052 if (rtn != 0) {
26053 ast_log(LOG_WARNING, "Parsing of Min-SE header failed %s\n", p_hdrval);
26054 return;
26055 }
26056 p->stimer->st_interval = minse;
26057 transmit_invite(p, SIP_INVITE, 1, 2, NULL);
26058 }
26059
26060
26061
26062
26063
26064
26065 int st_get_se(struct sip_pvt *p, int max)
26066 {
26067 if (max == TRUE) {
26068 if (p->stimer->st_cached_max_se) {
26069 return p->stimer->st_cached_max_se;
26070 }
26071 if (p->relatedpeer) {
26072 p->stimer->st_cached_max_se = p->relatedpeer->stimer.st_max_se;
26073 return (p->stimer->st_cached_max_se);
26074 }
26075 p->stimer->st_cached_max_se = global_max_se;
26076 return (p->stimer->st_cached_max_se);
26077 }
26078
26079 if (p->stimer->st_cached_min_se) {
26080 return p->stimer->st_cached_min_se;
26081 }
26082 if (p->relatedpeer) {
26083 p->stimer->st_cached_min_se = p->relatedpeer->stimer.st_min_se;
26084 return (p->stimer->st_cached_min_se);
26085 }
26086 p->stimer->st_cached_min_se = global_min_se;
26087 return (p->stimer->st_cached_min_se);
26088 }
26089
26090
26091
26092
26093
26094 enum st_refresher st_get_refresher(struct sip_pvt *p)
26095 {
26096 if (p->stimer->st_cached_ref != SESSION_TIMER_REFRESHER_AUTO)
26097 return p->stimer->st_cached_ref;
26098
26099 if (p->relatedpeer) {
26100 p->stimer->st_cached_ref = p->relatedpeer->stimer.st_ref;
26101 return p->stimer->st_cached_ref;
26102 }
26103
26104 p->stimer->st_cached_ref = global_st_refresher;
26105 return global_st_refresher;
26106 }
26107
26108
26109
26110
26111
26112
26113
26114
26115 enum st_mode st_get_mode(struct sip_pvt *p, int no_cached)
26116 {
26117 if (!p->stimer)
26118 sip_st_alloc(p);
26119
26120 if (!no_cached && p->stimer->st_cached_mode != SESSION_TIMER_MODE_INVALID)
26121 return p->stimer->st_cached_mode;
26122
26123 if (p->relatedpeer) {
26124 p->stimer->st_cached_mode = p->relatedpeer->stimer.st_mode_oper;
26125 return p->stimer->st_cached_mode;
26126 }
26127
26128 p->stimer->st_cached_mode = global_st_mode;
26129 return global_st_mode;
26130 }
26131
26132
26133
26134 static int sip_poke_noanswer(const void *data)
26135 {
26136 struct sip_peer *peer = (struct sip_peer *)data;
26137
26138 peer->pokeexpire = -1;
26139
26140 if (peer->lastms > -1) {
26141 ast_log(LOG_NOTICE, "Peer '%s' is now UNREACHABLE! Last qualify: %d\n", peer->name, peer->lastms);
26142 if (sip_cfg.peer_rtupdate) {
26143 ast_update_realtime(ast_check_realtime("sipregs") ? "sipregs" : "sippeers", "name", peer->name, "lastms", "-1", SENTINEL);
26144 }
26145 manager_event(EVENT_FLAG_SYSTEM, "PeerStatus", "ChannelType: SIP\r\nPeer: SIP/%s\r\nPeerStatus: Unreachable\r\nTime: %d\r\n", peer->name, -1);
26146 if (sip_cfg.regextenonqualify) {
26147 register_peer_exten(peer, FALSE);
26148 }
26149 }
26150
26151 if (peer->call) {
26152 dialog_unlink_all(peer->call);
26153 peer->call = dialog_unref(peer->call, "unref dialog peer->call");
26154
26155 }
26156
26157
26158 if (peer->lastms > -1) {
26159 peer->lastms = -1;
26160 ast_devstate_changed(AST_DEVICE_UNKNOWN, "SIP/%s", peer->name);
26161 }
26162
26163
26164 AST_SCHED_REPLACE_UNREF(peer->pokeexpire, sched,
26165 DEFAULT_FREQ_NOTOK, sip_poke_peer_s, peer,
26166 unref_peer(_data, "removing poke peer ref"),
26167 unref_peer(peer, "removing poke peer ref"),
26168 ref_peer(peer, "adding poke peer ref"));
26169
26170
26171 unref_peer(peer, "release peer poke noanswer ref");
26172
26173 return 0;
26174 }
26175
26176
26177
26178
26179
26180
26181 static int sip_poke_peer(struct sip_peer *peer, int force)
26182 {
26183 struct sip_pvt *p;
26184 int xmitres = 0;
26185
26186 if ((!peer->maxms && !force) || ast_sockaddr_isnull(&peer->addr)) {
26187
26188
26189 AST_SCHED_DEL_UNREF(sched, peer->pokeexpire,
26190 unref_peer(peer, "removing poke peer ref"));
26191
26192 peer->lastms = 0;
26193 if (peer->call) {
26194 peer->call = dialog_unref(peer->call, "unref dialog peer->call");
26195 }
26196 return 0;
26197 }
26198 if (peer->call) {
26199 if (sipdebug) {
26200 ast_log(LOG_NOTICE, "Still have a QUALIFY dialog active, deleting\n");
26201 }
26202 dialog_unlink_all(peer->call);
26203 peer->call = dialog_unref(peer->call, "unref dialog peer->call");
26204
26205 }
26206 if (!(p = sip_alloc(NULL, NULL, 0, SIP_OPTIONS, NULL))) {
26207 return -1;
26208 }
26209 peer->call = dialog_ref(p, "copy sip alloc from p to peer->call");
26210
26211 p->sa = peer->addr;
26212 p->recv = peer->addr;
26213 copy_socket_data(&p->socket, &peer->socket);
26214 ast_copy_flags(&p->flags[0], &peer->flags[0], SIP_FLAGS_TO_COPY);
26215 ast_copy_flags(&p->flags[1], &peer->flags[1], SIP_PAGE2_FLAGS_TO_COPY);
26216 ast_copy_flags(&p->flags[2], &peer->flags[2], SIP_PAGE3_FLAGS_TO_COPY);
26217
26218
26219 if (!ast_strlen_zero(peer->fullcontact)) {
26220 ast_string_field_set(p, fullcontact, peer->fullcontact);
26221 }
26222
26223 if (!ast_strlen_zero(peer->fromuser)) {
26224 ast_string_field_set(p, fromuser, peer->fromuser);
26225 }
26226
26227 if (!ast_strlen_zero(peer->tohost)) {
26228 ast_string_field_set(p, tohost, peer->tohost);
26229 } else {
26230 ast_string_field_set(p, tohost, ast_sockaddr_stringify_host_remote(&peer->addr));
26231 }
26232
26233
26234 ast_sip_ouraddrfor(&p->sa, &p->ourip, p);
26235 build_via(p);
26236
26237
26238 change_callid_pvt(p, NULL);
26239
26240 AST_SCHED_DEL_UNREF(sched, peer->pokeexpire,
26241 unref_peer(peer, "removing poke peer ref"));
26242
26243 if (p->relatedpeer)
26244 p->relatedpeer = unref_peer(p->relatedpeer,"unsetting the relatedpeer field in the dialog, before it is set to something else.");
26245 p->relatedpeer = ref_peer(peer, "setting the relatedpeer field in the dialog");
26246 ast_set_flag(&p->flags[0], SIP_OUTGOING);
26247 #ifdef VOCAL_DATA_HACK
26248 ast_copy_string(p->username, "__VOCAL_DATA_SHOULD_READ_THE_SIP_SPEC__", sizeof(p->username));
26249 xmitres = transmit_invite(p, SIP_INVITE, 0, 2, NULL);
26250 #else
26251 xmitres = transmit_invite(p, SIP_OPTIONS, 0, 2, NULL);
26252 #endif
26253 peer->ps = ast_tvnow();
26254 if (xmitres == XMIT_ERROR) {
26255
26256 sip_poke_noanswer(ref_peer(peer, "add ref for peerexpire (fake, for sip_poke_noanswer to remove)"));
26257 } else if (!force) {
26258 AST_SCHED_REPLACE_UNREF(peer->pokeexpire, sched, peer->maxms * 2, sip_poke_noanswer, peer,
26259 unref_peer(_data, "removing poke peer ref"),
26260 unref_peer(peer, "removing poke peer ref"),
26261 ref_peer(peer, "adding poke peer ref"));
26262 }
26263 dialog_unref(p, "unref dialog at end of sip_poke_peer, obtained from sip_alloc, just before it goes out of scope");
26264 return 0;
26265 }
26266
26267
26268
26269
26270
26271
26272
26273
26274
26275
26276
26277
26278
26279
26280
26281
26282
26283
26284
26285
26286
26287
26288
26289
26290
26291
26292
26293
26294
26295
26296
26297
26298
26299
26300 static int sip_devicestate(void *data)
26301 {
26302 char *host;
26303 char *tmp;
26304 struct sip_peer *p;
26305
26306 int res = AST_DEVICE_INVALID;
26307
26308
26309 host = ast_strdupa(data ? data : "");
26310 if ((tmp = strchr(host, '@')))
26311 host = tmp + 1;
26312
26313 ast_debug(3, "Checking device state for peer %s\n", host);
26314
26315
26316
26317
26318
26319
26320
26321
26322 if ((p = find_peer(host, NULL, FALSE, FINDALLDEVICES, TRUE, 0))) {
26323 if (!(ast_sockaddr_isnull(&p->addr) && ast_sockaddr_isnull(&p->defaddr))) {
26324
26325
26326
26327
26328
26329
26330
26331
26332
26333
26334
26335 if (p->onHold)
26336
26337 res = AST_DEVICE_ONHOLD;
26338 else if (p->inRinging) {
26339 if (p->inRinging == p->inUse)
26340 res = AST_DEVICE_RINGING;
26341 else
26342 res = AST_DEVICE_RINGINUSE;
26343 } else if (p->call_limit && (p->inUse == p->call_limit))
26344
26345 res = AST_DEVICE_BUSY;
26346 else if (p->call_limit && p->busy_level && p->inUse >= p->busy_level)
26347
26348 res = AST_DEVICE_BUSY;
26349 else if (p->call_limit && p->inUse)
26350
26351 res = AST_DEVICE_INUSE;
26352 else if (p->maxms && ((p->lastms > p->maxms) || (p->lastms < 0)))
26353
26354 res = AST_DEVICE_UNAVAILABLE;
26355 else
26356 res = AST_DEVICE_NOT_INUSE;
26357 } else {
26358
26359 res = AST_DEVICE_UNAVAILABLE;
26360 }
26361 unref_peer(p, "unref_peer, from sip_devicestate, release ref from find_peer");
26362 } else {
26363 res = AST_DEVICE_UNKNOWN;
26364 }
26365
26366 return res;
26367 }
26368
26369
26370
26371
26372
26373
26374
26375
26376
26377
26378
26379 static struct ast_channel *sip_request_call(const char *type, format_t format, const struct ast_channel *requestor, void *data, int *cause)
26380 {
26381 struct sip_pvt *p;
26382 struct ast_channel *tmpc = NULL;
26383 char *ext = NULL, *host;
26384 char tmp[256];
26385 char *dest = data;
26386 char *dnid;
26387 char *secret = NULL;
26388 char *md5secret = NULL;
26389 char *authname = NULL;
26390 char *trans = NULL;
26391 char dialstring[256];
26392 char *remote_address;
26393 enum sip_transport transport = 0;
26394 struct ast_sockaddr remote_address_sa = { {0,} };
26395 format_t oldformat = format;
26396 AST_DECLARE_APP_ARGS(args,
26397 AST_APP_ARG(peerorhost);
26398 AST_APP_ARG(exten);
26399 AST_APP_ARG(remote_address);
26400 );
26401
26402
26403
26404
26405
26406
26407
26408
26409 format &= AST_FORMAT_AUDIO_MASK;
26410 if (!format) {
26411 ast_log(LOG_NOTICE, "Asked to get a channel of unsupported format %s while capability is %s\n", ast_getformatname(oldformat), ast_getformatname(sip_cfg.capability));
26412 *cause = AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
26413 return NULL;
26414 }
26415 ast_debug(1, "Asked to create a SIP channel with formats: %s\n", ast_getformatname_multiple(tmp, sizeof(tmp), oldformat));
26416
26417 if (ast_strlen_zero(dest)) {
26418 ast_log(LOG_ERROR, "Unable to create channel with empty destination.\n");
26419 *cause = AST_CAUSE_CHANNEL_UNACCEPTABLE;
26420 return NULL;
26421 }
26422
26423 if (!(p = sip_alloc(NULL, NULL, 0, SIP_INVITE, NULL))) {
26424 ast_log(LOG_ERROR, "Unable to build sip pvt data for '%s' (Out of memory or socket error)\n", dest);
26425 *cause = AST_CAUSE_SWITCH_CONGESTION;
26426 return NULL;
26427 }
26428
26429 p->outgoing_call = TRUE;
26430
26431 snprintf(dialstring, sizeof(dialstring), "%s/%s", type, dest);
26432 ast_string_field_set(p, dialstring, dialstring);
26433
26434 if (!(p->options = ast_calloc(1, sizeof(*p->options)))) {
26435 dialog_unlink_all(p);
26436 dialog_unref(p, "unref dialog p from mem fail");
26437
26438 ast_log(LOG_ERROR, "Unable to build option SIP data structure - Out of memory\n");
26439 *cause = AST_CAUSE_SWITCH_CONGESTION;
26440 return NULL;
26441 }
26442
26443
26444 ast_copy_string(tmp, dest, sizeof(tmp));
26445
26446
26447 dnid = strchr(tmp, '!');
26448 if (dnid != NULL) {
26449 *dnid++ = '\0';
26450 ast_string_field_set(p, todnid, dnid);
26451 }
26452
26453
26454 AST_NONSTANDARD_APP_ARGS(args, tmp, '/');
26455
26456
26457 host = strchr(args.peerorhost, '@');
26458 if (host) {
26459 *host++ = '\0';
26460 ext = args.peerorhost;
26461 secret = strchr(ext, ':');
26462 }
26463 if (secret) {
26464 *secret++ = '\0';
26465 md5secret = strchr(secret, ':');
26466 }
26467 if (md5secret) {
26468 *md5secret++ = '\0';
26469 authname = strchr(md5secret, ':');
26470 }
26471 if (authname) {
26472 *authname++ = '\0';
26473 trans = strchr(authname, ':');
26474 }
26475 if (trans) {
26476 *trans++ = '\0';
26477 if (!strcasecmp(trans, "tcp"))
26478 transport = SIP_TRANSPORT_TCP;
26479 else if (!strcasecmp(trans, "tls"))
26480 transport = SIP_TRANSPORT_TLS;
26481 else {
26482 if (strcasecmp(trans, "udp"))
26483 ast_log(LOG_WARNING, "'%s' is not a valid transport option to Dial() for SIP calls, using udp by default.\n", trans);
26484 transport = SIP_TRANSPORT_UDP;
26485 }
26486 } else {
26487 transport = SIP_TRANSPORT_UDP;
26488 }
26489
26490 if (!host) {
26491 ext = args.exten;
26492 host = args.peerorhost;
26493 remote_address = args.remote_address;
26494 } else {
26495 remote_address = args.remote_address;
26496 if (!ast_strlen_zero(args.exten)) {
26497 ast_log(LOG_NOTICE, "Conflicting extension values given. Using '%s' and not '%s'\n", ext, args.exten);
26498 }
26499 }
26500
26501 if (!ast_strlen_zero(remote_address)) {
26502 if (ast_sockaddr_resolve_first(&remote_address_sa, remote_address, 0)) {
26503 ast_log(LOG_WARNING, "Unable to find IP address for host %s. We will not use this remote IP address\n", remote_address);
26504 } else {
26505 if (!ast_sockaddr_port(&remote_address_sa)) {
26506 ast_sockaddr_set_port(&remote_address_sa,
26507 transport & SIP_TRANSPORT_TLS ?
26508 STANDARD_TLS_PORT :
26509 STANDARD_SIP_PORT);
26510 }
26511 }
26512 }
26513
26514 set_socket_transport(&p->socket, transport);
26515
26516
26517
26518
26519
26520
26521 if (create_addr(p, host, NULL, 1, &remote_address_sa)) {
26522 *cause = AST_CAUSE_UNREGISTERED;
26523 ast_debug(3, "Cant create SIP call - target device not registered\n");
26524 dialog_unlink_all(p);
26525 dialog_unref(p, "unref dialog p UNREGISTERED");
26526
26527 return NULL;
26528 }
26529 if (ast_strlen_zero(p->peername) && ext)
26530 ast_string_field_set(p, peername, ext);
26531
26532 ast_sip_ouraddrfor(&p->sa, &p->ourip, p);
26533 build_via(p);
26534
26535
26536 change_callid_pvt(p, NULL);
26537
26538
26539
26540
26541
26542
26543 if (ext) {
26544 ast_string_field_set(p, username, ext);
26545 ast_string_field_set(p, fullcontact, NULL);
26546 }
26547 if (secret && !ast_strlen_zero(secret))
26548 ast_string_field_set(p, peersecret, secret);
26549
26550 if (md5secret && !ast_strlen_zero(md5secret))
26551 ast_string_field_set(p, peermd5secret, md5secret);
26552
26553 if (authname && !ast_strlen_zero(authname))
26554 ast_string_field_set(p, authname, authname);
26555 #if 0
26556 printf("Setting up to call extension '%s' at '%s'\n", ext ? ext : "<none>", host);
26557 #endif
26558 p->prefcodec = oldformat;
26559 p->jointcapability = oldformat & p->capability;
26560 sip_pvt_lock(p);
26561 tmpc = sip_new(p, AST_STATE_DOWN, host, requestor ? requestor->linkedid : NULL);
26562 if (sip_cfg.callevents)
26563 manager_event(EVENT_FLAG_SYSTEM, "ChannelUpdate",
26564 "Channel: %s\r\nChanneltype: %s\r\nSIPcallid: %s\r\nSIPfullcontact: %s\r\nPeername: %s\r\n",
26565 p->owner? p->owner->name : "", "SIP", p->callid, p->fullcontact, p->peername);
26566 sip_pvt_unlock(p);
26567 if (!tmpc) {
26568 dialog_unlink_all(p);
26569
26570 } else {
26571 ast_channel_unlock(tmpc);
26572 }
26573 dialog_unref(p, "toss pvt ptr at end of sip_request_call");
26574 ast_update_use_count();
26575 restart_monitor();
26576 return tmpc;
26577 }
26578
26579
26580 static void set_insecure_flags (struct ast_flags *flags, const char *value, int lineno)
26581 {
26582 if (ast_strlen_zero(value))
26583 return;
26584
26585 if (!ast_false(value)) {
26586 char buf[64];
26587 char *word, *next;
26588
26589 ast_copy_string(buf, value, sizeof(buf));
26590 next = buf;
26591 while ((word = strsep(&next, ","))) {
26592 if (!strcasecmp(word, "port"))
26593 ast_set_flag(&flags[0], SIP_INSECURE_PORT);
26594 else if (!strcasecmp(word, "invite"))
26595 ast_set_flag(&flags[0], SIP_INSECURE_INVITE);
26596 else
26597 ast_log(LOG_WARNING, "Unknown insecure mode '%s' on line %d\n", value, lineno);
26598 }
26599 }
26600 }
26601
26602
26603
26604
26605
26606 static int handle_t38_options(struct ast_flags *flags, struct ast_flags *mask, struct ast_variable *v,
26607 int *maxdatagram)
26608 {
26609 int res = 1;
26610
26611 if (!strcasecmp(v->name, "t38pt_udptl")) {
26612 char *buf = ast_strdupa(v->value);
26613 char *word, *next = buf;
26614
26615 ast_set_flag(&mask[1], SIP_PAGE2_T38SUPPORT);
26616
26617 while ((word = strsep(&next, ","))) {
26618 if (ast_true(word) || !strcasecmp(word, "fec")) {
26619 ast_clear_flag(&flags[1], SIP_PAGE2_T38SUPPORT);
26620 ast_set_flag(&flags[1], SIP_PAGE2_T38SUPPORT_UDPTL_FEC);
26621 } else if (!strcasecmp(word, "redundancy")) {
26622 ast_clear_flag(&flags[1], SIP_PAGE2_T38SUPPORT);
26623 ast_set_flag(&flags[1], SIP_PAGE2_T38SUPPORT_UDPTL_REDUNDANCY);
26624 } else if (!strcasecmp(word, "none")) {
26625 ast_clear_flag(&flags[1], SIP_PAGE2_T38SUPPORT);
26626 ast_set_flag(&flags[1], SIP_PAGE2_T38SUPPORT_UDPTL);
26627 } else if (!strncasecmp(word, "maxdatagram=", 12)) {
26628 if (sscanf(&word[12], "%30u", maxdatagram) != 1) {
26629 ast_log(LOG_WARNING, "Invalid maxdatagram '%s' at line %d of %s\n", v->value, v->lineno, config);
26630 *maxdatagram = global_t38_maxdatagram;
26631 }
26632 }
26633 }
26634 } else if (!strcasecmp(v->name, "t38pt_usertpsource")) {
26635 ast_set_flag(&mask[1], SIP_PAGE2_UDPTL_DESTINATION);
26636 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_UDPTL_DESTINATION);
26637 } else {
26638 res = 0;
26639 }
26640
26641 return res;
26642 }
26643
26644
26645
26646
26647
26648
26649
26650
26651 static int handle_common_options(struct ast_flags *flags, struct ast_flags *mask, struct ast_variable *v)
26652 {
26653 int res = 1;
26654
26655 if (!strcasecmp(v->name, "trustrpid")) {
26656 ast_set_flag(&mask[0], SIP_TRUSTRPID);
26657 ast_set2_flag(&flags[0], ast_true(v->value), SIP_TRUSTRPID);
26658 } else if (!strcasecmp(v->name, "sendrpid")) {
26659 ast_set_flag(&mask[0], SIP_SENDRPID);
26660 if (!strcasecmp(v->value, "pai")) {
26661 ast_set_flag(&flags[0], SIP_SENDRPID_PAI);
26662 } else if (!strcasecmp(v->value, "rpid")) {
26663 ast_set_flag(&flags[0], SIP_SENDRPID_RPID);
26664 } else if (ast_true(v->value)) {
26665 ast_set_flag(&flags[0], SIP_SENDRPID_RPID);
26666 }
26667 } else if (!strcasecmp(v->name, "rpid_update")) {
26668 ast_set_flag(&mask[1], SIP_PAGE2_RPID_UPDATE);
26669 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_RPID_UPDATE);
26670 } else if (!strcasecmp(v->name, "rpid_immediate")) {
26671 ast_set_flag(&mask[1], SIP_PAGE2_RPID_IMMEDIATE);
26672 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_RPID_IMMEDIATE);
26673 } else if (!strcasecmp(v->name, "g726nonstandard")) {
26674 ast_set_flag(&mask[0], SIP_G726_NONSTANDARD);
26675 ast_set2_flag(&flags[0], ast_true(v->value), SIP_G726_NONSTANDARD);
26676 } else if (!strcasecmp(v->name, "useclientcode")) {
26677 ast_set_flag(&mask[0], SIP_USECLIENTCODE);
26678 ast_set2_flag(&flags[0], ast_true(v->value), SIP_USECLIENTCODE);
26679 } else if (!strcasecmp(v->name, "dtmfmode")) {
26680 ast_set_flag(&mask[0], SIP_DTMF);
26681 ast_clear_flag(&flags[0], SIP_DTMF);
26682 if (!strcasecmp(v->value, "inband"))
26683 ast_set_flag(&flags[0], SIP_DTMF_INBAND);
26684 else if (!strcasecmp(v->value, "rfc2833"))
26685 ast_set_flag(&flags[0], SIP_DTMF_RFC2833);
26686 else if (!strcasecmp(v->value, "info"))
26687 ast_set_flag(&flags[0], SIP_DTMF_INFO);
26688 else if (!strcasecmp(v->value, "shortinfo"))
26689 ast_set_flag(&flags[0], SIP_DTMF_SHORTINFO);
26690 else if (!strcasecmp(v->value, "auto"))
26691 ast_set_flag(&flags[0], SIP_DTMF_AUTO);
26692 else {
26693 ast_log(LOG_WARNING, "Unknown dtmf mode '%s' on line %d, using rfc2833\n", v->value, v->lineno);
26694 ast_set_flag(&flags[0], SIP_DTMF_RFC2833);
26695 }
26696 } else if (!strcasecmp(v->name, "nat")) {
26697 ast_set_flag(&mask[0], SIP_NAT_FORCE_RPORT);
26698 ast_set_flag(&flags[0], SIP_NAT_FORCE_RPORT);
26699 if (!strcasecmp(v->value, "no")) {
26700 ast_clear_flag(&flags[0], SIP_NAT_FORCE_RPORT);
26701 } else if (!strcasecmp(v->value, "yes")) {
26702
26703 ast_set_flag(&mask[1], SIP_PAGE2_SYMMETRICRTP);
26704 ast_set_flag(&flags[1], SIP_PAGE2_SYMMETRICRTP);
26705 } else if (!strcasecmp(v->value, "comedia")) {
26706 ast_clear_flag(&flags[0], SIP_NAT_FORCE_RPORT);
26707 ast_set_flag(&mask[1], SIP_PAGE2_SYMMETRICRTP);
26708 ast_set_flag(&flags[1], SIP_PAGE2_SYMMETRICRTP);
26709 }
26710 } else if (!strcasecmp(v->name, "directmedia") || !strcasecmp(v->name, "canreinvite")) {
26711 ast_set_flag(&mask[0], SIP_REINVITE);
26712 ast_clear_flag(&flags[0], SIP_REINVITE);
26713 if (ast_true(v->value)) {
26714 ast_set_flag(&flags[0], SIP_DIRECT_MEDIA | SIP_DIRECT_MEDIA_NAT);
26715 } else if (!ast_false(v->value)) {
26716 char buf[64];
26717 char *word, *next = buf;
26718
26719 ast_copy_string(buf, v->value, sizeof(buf));
26720 while ((word = strsep(&next, ","))) {
26721 if (!strcasecmp(word, "update")) {
26722 ast_set_flag(&flags[0], SIP_REINVITE_UPDATE | SIP_DIRECT_MEDIA);
26723 } else if (!strcasecmp(word, "nonat")) {
26724 ast_set_flag(&flags[0], SIP_DIRECT_MEDIA);
26725 ast_clear_flag(&flags[0], SIP_DIRECT_MEDIA_NAT);
26726 } else {
26727 ast_log(LOG_WARNING, "Unknown directmedia mode '%s' on line %d\n", v->value, v->lineno);
26728 }
26729 }
26730 }
26731 } else if (!strcasecmp(v->name, "insecure")) {
26732 ast_set_flag(&mask[0], SIP_INSECURE);
26733 ast_clear_flag(&flags[0], SIP_INSECURE);
26734 set_insecure_flags(&flags[0], v->value, v->lineno);
26735 } else if (!strcasecmp(v->name, "progressinband")) {
26736 ast_set_flag(&mask[0], SIP_PROG_INBAND);
26737 ast_clear_flag(&flags[0], SIP_PROG_INBAND);
26738 if (ast_true(v->value))
26739 ast_set_flag(&flags[0], SIP_PROG_INBAND_YES);
26740 else if (strcasecmp(v->value, "never"))
26741 ast_set_flag(&flags[0], SIP_PROG_INBAND_NO);
26742 } else if (!strcasecmp(v->name, "promiscredir")) {
26743 ast_set_flag(&mask[0], SIP_PROMISCREDIR);
26744 ast_set2_flag(&flags[0], ast_true(v->value), SIP_PROMISCREDIR);
26745 } else if (!strcasecmp(v->name, "videosupport")) {
26746 if (!strcasecmp(v->value, "always")) {
26747 ast_set_flag(&mask[1], SIP_PAGE2_VIDEOSUPPORT_ALWAYS);
26748 ast_set_flag(&flags[1], SIP_PAGE2_VIDEOSUPPORT_ALWAYS);
26749 } else {
26750 ast_set_flag(&mask[1], SIP_PAGE2_VIDEOSUPPORT);
26751 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_VIDEOSUPPORT);
26752 }
26753 } else if (!strcasecmp(v->name, "textsupport")) {
26754 ast_set_flag(&mask[1], SIP_PAGE2_TEXTSUPPORT);
26755 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_TEXTSUPPORT);
26756 res = 1;
26757 } else if (!strcasecmp(v->name, "allowoverlap")) {
26758 ast_set_flag(&mask[1], SIP_PAGE2_ALLOWOVERLAP);
26759 ast_clear_flag(&flags[1], SIP_PAGE2_ALLOWOVERLAP);
26760 if (ast_true(v->value)) {
26761 ast_set_flag(&flags[1], SIP_PAGE2_ALLOWOVERLAP_YES);
26762 } else if (!strcasecmp(v->value, "dtmf")){
26763 ast_set_flag(&flags[1], SIP_PAGE2_ALLOWOVERLAP_DTMF);
26764 }
26765 } else if (!strcasecmp(v->name, "allowsubscribe")) {
26766 ast_set_flag(&mask[1], SIP_PAGE2_ALLOWSUBSCRIBE);
26767 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_ALLOWSUBSCRIBE);
26768 } else if (!strcasecmp(v->name, "ignoresdpversion")) {
26769 ast_set_flag(&mask[1], SIP_PAGE2_IGNORESDPVERSION);
26770 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_IGNORESDPVERSION);
26771 } else if (!strcasecmp(v->name, "faxdetect")) {
26772 ast_set_flag(&mask[1], SIP_PAGE2_FAX_DETECT);
26773 if (ast_true(v->value)) {
26774 ast_set_flag(&flags[1], SIP_PAGE2_FAX_DETECT_BOTH);
26775 } else if (ast_false(v->value)) {
26776 ast_clear_flag(&flags[1], SIP_PAGE2_FAX_DETECT_BOTH);
26777 } else {
26778 char *buf = ast_strdupa(v->value);
26779 char *word, *next = buf;
26780
26781 while ((word = strsep(&next, ","))) {
26782 if (!strcasecmp(word, "cng")) {
26783 ast_set_flag(&flags[1], SIP_PAGE2_FAX_DETECT_CNG);
26784 } else if (!strcasecmp(word, "t38")) {
26785 ast_set_flag(&flags[1], SIP_PAGE2_FAX_DETECT_T38);
26786 } else {
26787 ast_log(LOG_WARNING, "Unknown faxdetect mode '%s' on line %d.\n", word, v->lineno);
26788 }
26789 }
26790 }
26791 } else if (!strcasecmp(v->name, "rfc2833compensate")) {
26792 ast_set_flag(&mask[1], SIP_PAGE2_RFC2833_COMPENSATE);
26793 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_RFC2833_COMPENSATE);
26794 } else if (!strcasecmp(v->name, "buggymwi")) {
26795 ast_set_flag(&mask[1], SIP_PAGE2_BUGGY_MWI);
26796 ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_BUGGY_MWI);
26797 } else
26798 res = 0;
26799
26800 return res;
26801 }
26802
26803
26804 static int add_sip_domain(const char *domain, const enum domain_mode mode, const char *context)
26805 {
26806 struct domain *d;
26807
26808 if (ast_strlen_zero(domain)) {
26809 ast_log(LOG_WARNING, "Zero length domain.\n");
26810 return 1;
26811 }
26812
26813 if (!(d = ast_calloc(1, sizeof(*d))))
26814 return 0;
26815
26816 ast_copy_string(d->domain, domain, sizeof(d->domain));
26817
26818 if (!ast_strlen_zero(context))
26819 ast_copy_string(d->context, context, sizeof(d->context));
26820
26821 d->mode = mode;
26822
26823 AST_LIST_LOCK(&domain_list);
26824 AST_LIST_INSERT_TAIL(&domain_list, d, list);
26825 AST_LIST_UNLOCK(&domain_list);
26826
26827 if (sipdebug)
26828 ast_debug(1, "Added local SIP domain '%s'\n", domain);
26829
26830 return 1;
26831 }
26832
26833
26834 static int check_sip_domain(const char *domain, char *context, size_t len)
26835 {
26836 struct domain *d;
26837 int result = 0;
26838
26839 AST_LIST_LOCK(&domain_list);
26840 AST_LIST_TRAVERSE(&domain_list, d, list) {
26841 if (strcasecmp(d->domain, domain)) {
26842 continue;
26843 }
26844
26845 if (len && !ast_strlen_zero(d->context))
26846 ast_copy_string(context, d->context, len);
26847
26848 result = 1;
26849 break;
26850 }
26851 AST_LIST_UNLOCK(&domain_list);
26852
26853 return result;
26854 }
26855
26856
26857 static void clear_sip_domains(void)
26858 {
26859 struct domain *d;
26860
26861 AST_LIST_LOCK(&domain_list);
26862 while ((d = AST_LIST_REMOVE_HEAD(&domain_list, list)))
26863 ast_free(d);
26864 AST_LIST_UNLOCK(&domain_list);
26865 }
26866
26867
26868
26869
26870
26871
26872
26873
26874
26875 static void destroy_realm_authentication(void *obj)
26876 {
26877 struct sip_auth_container *credentials = obj;
26878 struct sip_auth *auth;
26879
26880 while ((auth = AST_LIST_REMOVE_HEAD(&credentials->list, node))) {
26881 ast_free(auth);
26882 }
26883 }
26884
26885
26886
26887
26888
26889
26890
26891
26892
26893
26894
26895 static void add_realm_authentication(struct sip_auth_container **credentials, const char *configuration, int lineno)
26896 {
26897 char *authcopy;
26898 char *username=NULL, *realm=NULL, *secret=NULL, *md5secret=NULL;
26899 struct sip_auth *auth;
26900
26901 if (ast_strlen_zero(configuration)) {
26902
26903 return;
26904 }
26905
26906 ast_debug(1, "Auth config :: %s\n", configuration);
26907
26908 authcopy = ast_strdupa(configuration);
26909 username = authcopy;
26910
26911
26912 realm = strrchr(username, '@');
26913 if (realm)
26914 *realm++ = '\0';
26915 if (ast_strlen_zero(username) || ast_strlen_zero(realm)) {
26916 ast_log(LOG_WARNING, "Format for authentication entry is user[:secret]@realm at line %d\n", lineno);
26917 return;
26918 }
26919
26920
26921 if ((secret = strchr(username, ':'))) {
26922 *secret++ = '\0';
26923 } else if ((md5secret = strchr(username, '#'))) {
26924 *md5secret++ = '\0';
26925 }
26926
26927
26928 if (!*credentials) {
26929 *credentials = ao2_t_alloc(sizeof(**credentials), destroy_realm_authentication,
26930 "Create realm auth container.");
26931 if (!*credentials) {
26932
26933 return;
26934 }
26935 }
26936
26937
26938 auth = ast_calloc(1, sizeof(*auth));
26939 if (!auth) {
26940 return;
26941 }
26942 ast_copy_string(auth->realm, realm, sizeof(auth->realm));
26943 ast_copy_string(auth->username, username, sizeof(auth->username));
26944 if (secret)
26945 ast_copy_string(auth->secret, secret, sizeof(auth->secret));
26946 if (md5secret)
26947 ast_copy_string(auth->md5secret, md5secret, sizeof(auth->md5secret));
26948
26949
26950 AST_LIST_INSERT_TAIL(&(*credentials)->list, auth, node);
26951
26952 ast_verb(3, "Added authentication for realm %s\n", realm);
26953 }
26954
26955
26956
26957
26958
26959
26960
26961
26962
26963
26964 static struct sip_auth *find_realm_authentication(struct sip_auth_container *credentials, const char *realm)
26965 {
26966 struct sip_auth *auth;
26967
26968 if (credentials) {
26969 AST_LIST_TRAVERSE(&credentials->list, auth, node) {
26970 if (!strcasecmp(auth->realm, realm)) {
26971 break;
26972 }
26973 }
26974 } else {
26975 auth = NULL;
26976 }
26977
26978 return auth;
26979 }
26980
26981
26982
26983
26984 static struct ast_variable *add_var(const char *buf, struct ast_variable *list)
26985 {
26986 struct ast_variable *tmpvar = NULL;
26987 char *varname = ast_strdupa(buf), *varval = NULL;
26988
26989 if ((varval = strchr(varname, '='))) {
26990 *varval++ = '\0';
26991 if ((tmpvar = ast_variable_new(varname, varval, ""))) {
26992 tmpvar->next = list;
26993 list = tmpvar;
26994 }
26995 }
26996 return list;
26997 }
26998
26999
27000 static void set_peer_defaults(struct sip_peer *peer)
27001 {
27002 if (peer->expire == 0) {
27003
27004
27005
27006 peer->expire = -1;
27007 peer->pokeexpire = -1;
27008 set_socket_transport(&peer->socket, SIP_TRANSPORT_UDP);
27009 }
27010 peer->type = SIP_TYPE_PEER;
27011 ast_copy_flags(&peer->flags[0], &global_flags[0], SIP_FLAGS_TO_COPY);
27012 ast_copy_flags(&peer->flags[1], &global_flags[1], SIP_PAGE2_FLAGS_TO_COPY);
27013 ast_copy_flags(&peer->flags[2], &global_flags[2], SIP_PAGE3_FLAGS_TO_COPY);
27014 ast_string_field_set(peer, context, sip_cfg.default_context);
27015 ast_string_field_set(peer, subscribecontext, sip_cfg.default_subscribecontext);
27016 ast_string_field_set(peer, language, default_language);
27017 ast_string_field_set(peer, mohinterpret, default_mohinterpret);
27018 ast_string_field_set(peer, mohsuggest, default_mohsuggest);
27019 ast_string_field_set(peer, engine, default_engine);
27020 ast_sockaddr_setnull(&peer->addr);
27021 ast_sockaddr_setnull(&peer->defaddr);
27022 peer->capability = sip_cfg.capability;
27023 peer->maxcallbitrate = default_maxcallbitrate;
27024 peer->rtptimeout = global_rtptimeout;
27025 peer->rtpholdtimeout = global_rtpholdtimeout;
27026 peer->rtpkeepalive = global_rtpkeepalive;
27027 peer->allowtransfer = sip_cfg.allowtransfer;
27028 peer->autoframing = global_autoframing;
27029 peer->t38_maxdatagram = global_t38_maxdatagram;
27030 peer->qualifyfreq = global_qualifyfreq;
27031 if (global_callcounter)
27032 peer->call_limit=INT_MAX;
27033 ast_string_field_set(peer, vmexten, default_vmexten);
27034 ast_string_field_set(peer, secret, "");
27035 ast_string_field_set(peer, remotesecret, "");
27036 ast_string_field_set(peer, md5secret, "");
27037 ast_string_field_set(peer, cid_num, "");
27038 ast_string_field_set(peer, cid_name, "");
27039 ast_string_field_set(peer, cid_tag, "");
27040 ast_string_field_set(peer, fromdomain, "");
27041 ast_string_field_set(peer, fromuser, "");
27042 ast_string_field_set(peer, regexten, "");
27043 peer->callgroup = 0;
27044 peer->pickupgroup = 0;
27045 peer->maxms = default_qualify;
27046 peer->prefs = default_prefs;
27047 peer->stimer.st_mode_oper = global_st_mode;
27048 peer->stimer.st_ref = global_st_refresher;
27049 peer->stimer.st_min_se = global_min_se;
27050 peer->stimer.st_max_se = global_max_se;
27051 peer->timer_t1 = global_t1;
27052 peer->timer_b = global_timer_b;
27053 clear_peer_mailboxes(peer);
27054 peer->disallowed_methods = sip_cfg.disallowed_methods;
27055 peer->transports = default_transports;
27056 peer->default_outbound_transport = default_primary_transport;
27057 }
27058
27059
27060 static struct sip_peer *temp_peer(const char *name)
27061 {
27062 struct sip_peer *peer;
27063
27064 if (!(peer = ao2_t_alloc(sizeof(*peer), sip_destroy_peer_fn, "allocate a peer struct")))
27065 return NULL;
27066
27067 if (ast_string_field_init(peer, 512)) {
27068 ao2_t_ref(peer, -1, "failed to string_field_init, drop peer");
27069 return NULL;
27070 }
27071
27072 if (!(peer->cc_params = ast_cc_config_params_init())) {
27073 ao2_t_ref(peer, -1, "failed to allocate cc_params for peer");
27074 return NULL;
27075 }
27076
27077 ast_atomic_fetchadd_int(&apeerobjs, 1);
27078 set_peer_defaults(peer);
27079
27080 ast_copy_string(peer->name, name, sizeof(peer->name));
27081
27082 peer->selfdestruct = TRUE;
27083 peer->host_dynamic = TRUE;
27084 peer->prefs = default_prefs;
27085 reg_source_db(peer);
27086
27087 return peer;
27088 }
27089
27090
27091 static void add_peer_mailboxes(struct sip_peer *peer, const char *value)
27092 {
27093 char *next, *mbox, *context;
27094
27095 next = ast_strdupa(value);
27096
27097 while ((mbox = context = strsep(&next, ","))) {
27098 struct sip_mailbox *mailbox;
27099 int duplicate = 0;
27100
27101 mbox = ast_strip(mbox);
27102 strsep(&context, "@");
27103
27104 if (ast_strlen_zero(mbox)) {
27105 continue;
27106 }
27107
27108
27109 AST_LIST_TRAVERSE(&peer->mailboxes, mailbox, entry) {
27110 if (!strcmp(mailbox->mailbox, mbox) && !strcmp(S_OR(mailbox->context, ""), S_OR(context, ""))) {
27111 duplicate = 1;
27112 break;
27113 }
27114 }
27115 if (duplicate) {
27116 continue;
27117 }
27118
27119 if (!(mailbox = ast_calloc(1, sizeof(*mailbox) + strlen(mbox) + strlen(S_OR(context, ""))))) {
27120 continue;
27121 }
27122
27123 if (!ast_strlen_zero(context)) {
27124 mailbox->context = mailbox->mailbox + strlen(mbox) + 1;
27125 strcpy(mailbox->context, context);
27126 }
27127 strcpy(mailbox->mailbox, mbox);
27128
27129 AST_LIST_INSERT_TAIL(&peer->mailboxes, mailbox, entry);
27130 }
27131 }
27132
27133
27134 static struct sip_peer *build_peer(const char *name, struct ast_variable *v, struct ast_variable *alt, int realtime, int devstate_only)
27135 {
27136 struct sip_peer *peer = NULL;
27137 struct ast_ha *oldha = NULL;
27138 struct ast_ha *olddirectmediaha = NULL;
27139 int found = 0;
27140 int firstpass = 1;
27141 uint16_t port = 0;
27142 int format = 0;
27143 int timerb_set = 0, timert1_set = 0;
27144 time_t regseconds = 0;
27145 struct ast_flags peerflags[3] = {{(0)}};
27146 struct ast_flags mask[3] = {{(0)}};
27147 char callback[256] = "";
27148 struct sip_peer tmp_peer;
27149 const char *srvlookup = NULL;
27150 static int deprecation_warning = 1;
27151 int alt_fullcontact = alt ? 1 : 0, headercount = 0;
27152 struct ast_str *fullcontact = ast_str_alloca(512);
27153
27154 if (!realtime || ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
27155
27156
27157
27158
27159
27160 ast_copy_string(tmp_peer.name, name, sizeof(tmp_peer.name));
27161 peer = ao2_t_find(peers, &tmp_peer, OBJ_POINTER | OBJ_UNLINK, "find and unlink peer from peers table");
27162 }
27163
27164 if (peer) {
27165
27166 found++;
27167
27168
27169 if (!ast_sockaddr_isnull(&peer->addr)) {
27170 ao2_t_unlink(peers_by_ip, peer, "ao2_unlink peer from peers_by_ip table");
27171 }
27172 if (!(peer->the_mark))
27173 firstpass = 0;
27174 } else {
27175 if (!(peer = ao2_t_alloc(sizeof(*peer), sip_destroy_peer_fn, "allocate a peer struct")))
27176 return NULL;
27177
27178 if (ast_string_field_init(peer, 512)) {
27179 ao2_t_ref(peer, -1, "failed to string_field_init, drop peer");
27180 return NULL;
27181 }
27182
27183 if (!(peer->cc_params = ast_cc_config_params_init())) {
27184 ao2_t_ref(peer, -1, "failed to allocate cc_params for peer");
27185 return NULL;
27186 }
27187
27188 if (realtime && !ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS)) {
27189 ast_atomic_fetchadd_int(&rpeerobjs, 1);
27190 ast_debug(3, "-REALTIME- peer built. Name: %s. Peer objects: %d\n", name, rpeerobjs);
27191 } else
27192 ast_atomic_fetchadd_int(&speerobjs, 1);
27193 }
27194
27195
27196 if (firstpass) {
27197 peer->lastmsgssent = -1;
27198 oldha = peer->ha;
27199 peer->ha = NULL;
27200 olddirectmediaha = peer->directmediaha;
27201 peer->directmediaha = NULL;
27202 set_peer_defaults(peer);
27203 peer->type = 0;
27204 }
27205
27206
27207 ast_copy_string(peer->name, name, sizeof(peer->name));
27208
27209
27210 if (peer->chanvars) {
27211 ast_variables_destroy(peer->chanvars);
27212 peer->chanvars = NULL;
27213
27214 }
27215
27216 if (found)
27217 peer->portinuri = 0;
27218
27219
27220 ao2_lock(peer);
27221 if (peer->auth) {
27222 ao2_t_ref(peer->auth, -1, "Removing old peer authentication");
27223 peer->auth = NULL;
27224 }
27225 ao2_unlock(peer);
27226
27227
27228 peer->default_outbound_transport = 0;
27229 peer->transports = 0;
27230
27231 if (!devstate_only) {
27232 struct sip_mailbox *mailbox;
27233 AST_LIST_TRAVERSE(&peer->mailboxes, mailbox, entry) {
27234 mailbox->delme = 1;
27235 }
27236 }
27237
27238 for (; v || ((v = alt) && !(alt=NULL)); v = v->next) {
27239 if (!devstate_only) {
27240 if (handle_common_options(&peerflags[0], &mask[0], v)) {
27241 continue;
27242 }
27243 if (handle_t38_options(&peerflags[0], &mask[0], v, &peer->t38_maxdatagram)) {
27244 continue;
27245 }
27246 if (!strcasecmp(v->name, "transport") && !ast_strlen_zero(v->value)) {
27247 char *val = ast_strdupa(v->value);
27248 char *trans;
27249
27250 while ((trans = strsep(&val, ","))) {
27251 trans = ast_skip_blanks(trans);
27252
27253 if (!strncasecmp(trans, "udp", 3)) {
27254 peer->transports |= SIP_TRANSPORT_UDP;
27255 } else if (sip_cfg.tcp_enabled && !strncasecmp(trans, "tcp", 3)) {
27256 peer->transports |= SIP_TRANSPORT_TCP;
27257 } else if (default_tls_cfg.enabled && !strncasecmp(trans, "tls", 3)) {
27258 peer->transports |= SIP_TRANSPORT_TLS;
27259 } else if (!strncasecmp(trans, "tcp", 3) || !strncasecmp(trans, "tls", 3)) {
27260 ast_log(LOG_WARNING, "'%.3s' is not a valid transport type when %.3senabled=no. If no other is specified, the defaults from general will be used.\n", trans, trans);
27261 } else {
27262 ast_log(LOG_NOTICE, "'%s' is not a valid transport type. if no other is specified, the defaults from general will be used.\n", trans);
27263 }
27264
27265 if (!peer->default_outbound_transport) {
27266 peer->default_outbound_transport = peer->transports;
27267 }
27268 }
27269 } else if (realtime && !strcasecmp(v->name, "regseconds")) {
27270 ast_get_time_t(v->value, ®seconds, 0, NULL);
27271 } else if (realtime && !strcasecmp(v->name, "name")) {
27272 ast_copy_string(peer->name, v->value, sizeof(peer->name));
27273 } else if (realtime && !strcasecmp(v->name, "useragent")) {
27274 ast_string_field_set(peer, useragent, v->value);
27275 } else if (!strcasecmp(v->name, "type")) {
27276 if (!strcasecmp(v->value, "peer")) {
27277 peer->type |= SIP_TYPE_PEER;
27278 } else if (!strcasecmp(v->value, "user")) {
27279 peer->type |= SIP_TYPE_USER;
27280 } else if (!strcasecmp(v->value, "friend")) {
27281 peer->type = SIP_TYPE_USER | SIP_TYPE_PEER;
27282 }
27283 } else if (!strcasecmp(v->name, "remotesecret")) {
27284 ast_string_field_set(peer, remotesecret, v->value);
27285 } else if (!strcasecmp(v->name, "secret")) {
27286 ast_string_field_set(peer, secret, v->value);
27287 } else if (!strcasecmp(v->name, "md5secret")) {
27288 ast_string_field_set(peer, md5secret, v->value);
27289 } else if (!strcasecmp(v->name, "auth")) {
27290 add_realm_authentication(&peer->auth, v->value, v->lineno);
27291 } else if (!strcasecmp(v->name, "callerid")) {
27292 char cid_name[80] = { '\0' }, cid_num[80] = { '\0' };
27293
27294 ast_callerid_split(v->value, cid_name, sizeof(cid_name), cid_num, sizeof(cid_num));
27295 ast_string_field_set(peer, cid_name, cid_name);
27296 ast_string_field_set(peer, cid_num, cid_num);
27297 } else if (!strcasecmp(v->name, "mwi_from")) {
27298 ast_string_field_set(peer, mwi_from, v->value);
27299 } else if (!strcasecmp(v->name, "fullname")) {
27300 ast_string_field_set(peer, cid_name, v->value);
27301 } else if (!strcasecmp(v->name, "trunkname")) {
27302
27303 ast_string_field_set(peer, cid_name, "");
27304 } else if (!strcasecmp(v->name, "cid_number")) {
27305 ast_string_field_set(peer, cid_num, v->value);
27306 } else if (!strcasecmp(v->name, "cid_tag")) {
27307 ast_string_field_set(peer, cid_tag, v->value);
27308 } else if (!strcasecmp(v->name, "context")) {
27309 ast_string_field_set(peer, context, v->value);
27310 ast_set_flag(&peer->flags[1], SIP_PAGE2_HAVEPEERCONTEXT);
27311 } else if (!strcasecmp(v->name, "subscribecontext")) {
27312 ast_string_field_set(peer, subscribecontext, v->value);
27313 } else if (!strcasecmp(v->name, "fromdomain")) {
27314 char *fromdomainport;
27315 ast_string_field_set(peer, fromdomain, v->value);
27316 if ((fromdomainport = strchr(peer->fromdomain, ':'))) {
27317 *fromdomainport++ = '\0';
27318 if (!(peer->fromdomainport = port_str2int(fromdomainport, 0))) {
27319 ast_log(LOG_NOTICE, "'%s' is not a valid port number for fromdomain.\n",fromdomainport);
27320 }
27321 } else {
27322 peer->fromdomainport = STANDARD_SIP_PORT;
27323 }
27324 } else if (!strcasecmp(v->name, "usereqphone")) {
27325 ast_set2_flag(&peer->flags[0], ast_true(v->value), SIP_USEREQPHONE);
27326 } else if (!strcasecmp(v->name, "fromuser")) {
27327 ast_string_field_set(peer, fromuser, v->value);
27328 } else if (!strcasecmp(v->name, "outboundproxy")) {
27329 char *tok, *proxyname;
27330
27331 if (ast_strlen_zero(v->value)) {
27332 ast_log(LOG_WARNING, "no value given for outbound proxy on line %d of sip.conf.", v->lineno);
27333 continue;
27334 }
27335
27336 peer->outboundproxy =
27337 ao2_alloc(sizeof(*peer->outboundproxy), NULL);
27338
27339 tok = ast_skip_blanks(strtok(ast_strdupa(v->value), ","));
27340
27341 sip_parse_host(tok, v->lineno, &proxyname,
27342 &peer->outboundproxy->port,
27343 &peer->outboundproxy->transport);
27344
27345 tok = ast_skip_blanks(strtok(ast_strdupa(v->value), ","));
27346
27347 if ((tok = strtok(NULL, ","))) {
27348 peer->outboundproxy->force = !strncasecmp(ast_skip_blanks(tok), "force", 5);
27349 } else {
27350 peer->outboundproxy->force = FALSE;
27351 }
27352
27353 if (ast_strlen_zero(proxyname)) {
27354 ast_log(LOG_WARNING, "you must specify a name for the outboundproxy on line %d of sip.conf.", v->lineno);
27355 sip_cfg.outboundproxy.name[0] = '\0';
27356 continue;
27357 }
27358
27359 ast_copy_string(peer->outboundproxy->name, proxyname, sizeof(peer->outboundproxy->name));
27360
27361 proxy_update(peer->outboundproxy);
27362 } else if (!strcasecmp(v->name, "host")) {
27363 if (!strcasecmp(v->value, "dynamic")) {
27364
27365 if (!found || !peer->host_dynamic) {
27366
27367
27368 ast_sockaddr_setnull(&peer->addr);
27369 }
27370 peer->host_dynamic = TRUE;
27371 } else {
27372
27373 AST_SCHED_DEL_UNREF(sched, peer->expire,
27374 unref_peer(peer, "removing register expire ref"));
27375 peer->host_dynamic = FALSE;
27376 srvlookup = v->value;
27377 }
27378 } else if (!strcasecmp(v->name, "defaultip")) {
27379 if (!ast_strlen_zero(v->value) && ast_get_ip(&peer->defaddr, v->value)) {
27380 unref_peer(peer, "unref_peer: from build_peer defaultip");
27381 return NULL;
27382 }
27383 } else if (!strcasecmp(v->name, "permit") || !strcasecmp(v->name, "deny")) {
27384 int ha_error = 0;
27385 if (!ast_strlen_zero(v->value)) {
27386 peer->ha = ast_append_ha(v->name, v->value, peer->ha, &ha_error);
27387 }
27388 if (ha_error) {
27389 ast_log(LOG_ERROR, "Bad ACL entry in configuration line %d : %s\n", v->lineno, v->value);
27390 }
27391 } else if (!strcasecmp(v->name, "contactpermit") || !strcasecmp(v->name, "contactdeny")) {
27392 int ha_error = 0;
27393 if (!ast_strlen_zero(v->value)) {
27394 peer->contactha = ast_append_ha(v->name + 7, v->value, peer->contactha, &ha_error);
27395 }
27396 if (ha_error) {
27397 ast_log(LOG_ERROR, "Bad ACL entry in configuration line %d : %s\n", v->lineno, v->value);
27398 }
27399 } else if (!strcasecmp(v->name, "directmediapermit") || !strcasecmp(v->name, "directmediadeny")) {
27400 int ha_error = 0;
27401 peer->directmediaha = ast_append_ha(v->name + 11, v->value, peer->directmediaha, &ha_error);
27402 if (ha_error) {
27403 ast_log(LOG_ERROR, "Bad directmedia ACL entry in configuration line %d : %s\n", v->lineno, v->value);
27404 }
27405 } else if (!strcasecmp(v->name, "port")) {
27406 peer->portinuri = 1;
27407 if (!(port = port_str2int(v->value, 0))) {
27408 if (realtime) {
27409
27410 peer->portinuri = 0;
27411 } else {
27412 ast_log(LOG_WARNING, "Invalid peer port configuration at line %d : %s\n", v->lineno, v->value);
27413 }
27414 }
27415 } else if (!strcasecmp(v->name, "callingpres")) {
27416 peer->callingpres = ast_parse_caller_presentation(v->value);
27417 if (peer->callingpres == -1) {
27418 peer->callingpres = atoi(v->value);
27419 }
27420 } else if (!strcasecmp(v->name, "username") || !strcmp(v->name, "defaultuser")) {
27421 ast_string_field_set(peer, username, v->value);
27422 if (!strcasecmp(v->name, "username")) {
27423 if (deprecation_warning) {
27424 ast_log(LOG_NOTICE, "The 'username' field for sip peers has been deprecated in favor of the term 'defaultuser'\n");
27425 deprecation_warning = 0;
27426 }
27427 peer->deprecated_username = 1;
27428 }
27429 } else if (!strcasecmp(v->name, "language")) {
27430 ast_string_field_set(peer, language, v->value);
27431 } else if (!strcasecmp(v->name, "regexten")) {
27432 ast_string_field_set(peer, regexten, v->value);
27433 } else if (!strcasecmp(v->name, "callbackextension")) {
27434 ast_copy_string(callback, v->value, sizeof(callback));
27435 } else if (!strcasecmp(v->name, "amaflags")) {
27436 format = ast_cdr_amaflags2int(v->value);
27437 if (format < 0) {
27438 ast_log(LOG_WARNING, "Invalid AMA Flags for peer: %s at line %d\n", v->value, v->lineno);
27439 } else {
27440 peer->amaflags = format;
27441 }
27442 } else if (!strcasecmp(v->name, "maxforwards")) {
27443 if (sscanf(v->value, "%30d", &peer->maxforwards) != 1
27444 || peer->maxforwards < 1 || 255 < peer->maxforwards) {
27445 ast_log(LOG_WARNING, "'%s' is not a valid maxforwards value at line %d. Using default.\n", v->value, v->lineno);
27446 peer->maxforwards = sip_cfg.default_max_forwards;
27447 }
27448 } else if (!strcasecmp(v->name, "accountcode")) {
27449 ast_string_field_set(peer, accountcode, v->value);
27450 } else if (!strcasecmp(v->name, "mohinterpret")) {
27451 ast_string_field_set(peer, mohinterpret, v->value);
27452 } else if (!strcasecmp(v->name, "mohsuggest")) {
27453 ast_string_field_set(peer, mohsuggest, v->value);
27454 } else if (!strcasecmp(v->name, "parkinglot")) {
27455 ast_string_field_set(peer, parkinglot, v->value);
27456 } else if (!strcasecmp(v->name, "rtp_engine")) {
27457 ast_string_field_set(peer, engine, v->value);
27458 } else if (!strcasecmp(v->name, "mailbox")) {
27459 add_peer_mailboxes(peer, v->value);
27460 } else if (!strcasecmp(v->name, "hasvoicemail")) {
27461
27462
27463 if (ast_true(v->value) && AST_LIST_EMPTY(&peer->mailboxes)) {
27464 add_peer_mailboxes(peer, name);
27465 }
27466 } else if (!strcasecmp(v->name, "subscribemwi")) {
27467 ast_set2_flag(&peer->flags[1], ast_true(v->value), SIP_PAGE2_SUBSCRIBEMWIONLY);
27468 } else if (!strcasecmp(v->name, "vmexten")) {
27469 ast_string_field_set(peer, vmexten, v->value);
27470 } else if (!strcasecmp(v->name, "callgroup")) {
27471 peer->callgroup = ast_get_group(v->value);
27472 } else if (!strcasecmp(v->name, "allowtransfer")) {
27473 peer->allowtransfer = ast_true(v->value) ? TRANSFER_OPENFORALL : TRANSFER_CLOSED;
27474 } else if (!strcasecmp(v->name, "pickupgroup")) {
27475 peer->pickupgroup = ast_get_group(v->value);
27476 } else if (!strcasecmp(v->name, "allow")) {
27477 int error = ast_parse_allow_disallow(&peer->prefs, &peer->capability, v->value, TRUE);
27478 if (error) {
27479 ast_log(LOG_WARNING, "Codec configuration errors found in line %d : %s = %s\n", v->lineno, v->name, v->value);
27480 }
27481 } else if (!strcasecmp(v->name, "disallow")) {
27482 int error = ast_parse_allow_disallow(&peer->prefs, &peer->capability, v->value, FALSE);
27483 if (error) {
27484 ast_log(LOG_WARNING, "Codec configuration errors found in line %d : %s = %s\n", v->lineno, v->name, v->value);
27485 }
27486 } else if (!strcasecmp(v->name, "preferred_codec_only")) {
27487 ast_set2_flag(&peer->flags[1], ast_true(v->value), SIP_PAGE2_PREFERRED_CODEC);
27488 } else if (!strcasecmp(v->name, "autoframing")) {
27489 peer->autoframing = ast_true(v->value);
27490 } else if (!strcasecmp(v->name, "rtptimeout")) {
27491 if ((sscanf(v->value, "%30d", &peer->rtptimeout) != 1) || (peer->rtptimeout < 0)) {
27492 ast_log(LOG_WARNING, "'%s' is not a valid RTP hold time at line %d. Using default.\n", v->value, v->lineno);
27493 peer->rtptimeout = global_rtptimeout;
27494 }
27495 } else if (!strcasecmp(v->name, "rtpholdtimeout")) {
27496 if ((sscanf(v->value, "%30d", &peer->rtpholdtimeout) != 1) || (peer->rtpholdtimeout < 0)) {
27497 ast_log(LOG_WARNING, "'%s' is not a valid RTP hold time at line %d. Using default.\n", v->value, v->lineno);
27498 peer->rtpholdtimeout = global_rtpholdtimeout;
27499 }
27500 } else if (!strcasecmp(v->name, "rtpkeepalive")) {
27501 if ((sscanf(v->value, "%30d", &peer->rtpkeepalive) != 1) || (peer->rtpkeepalive < 0)) {
27502 ast_log(LOG_WARNING, "'%s' is not a valid RTP keepalive time at line %d. Using default.\n", v->value, v->lineno);
27503 peer->rtpkeepalive = global_rtpkeepalive;
27504 }
27505 } else if (!strcasecmp(v->name, "timert1")) {
27506 if ((sscanf(v->value, "%30d", &peer->timer_t1) != 1) || (peer->timer_t1 < 200) || (peer->timer_t1 < global_t1min)) {
27507 ast_log(LOG_WARNING, "'%s' is not a valid T1 time at line %d. Using default.\n", v->value, v->lineno);
27508 peer->timer_t1 = global_t1min;
27509 }
27510 timert1_set = 1;
27511 } else if (!strcasecmp(v->name, "timerb")) {
27512 if ((sscanf(v->value, "%30d", &peer->timer_b) != 1) || (peer->timer_b < 200)) {
27513 ast_log(LOG_WARNING, "'%s' is not a valid Timer B time at line %d. Using default.\n", v->value, v->lineno);
27514 peer->timer_b = global_timer_b;
27515 }
27516 timerb_set = 1;
27517 } else if (!strcasecmp(v->name, "setvar")) {
27518 peer->chanvars = add_var(v->value, peer->chanvars);
27519 } else if (!strcasecmp(v->name, "header")) {
27520 char tmp[4096];
27521 snprintf(tmp, sizeof(tmp), "__SIPADDHEADERpre%2d=%s", ++headercount, v->value);
27522 peer->chanvars = add_var(tmp, peer->chanvars);
27523 } else if (!strcasecmp(v->name, "qualifyfreq")) {
27524 int i;
27525 if (sscanf(v->value, "%30d", &i) == 1) {
27526 peer->qualifyfreq = i * 1000;
27527 } else {
27528 ast_log(LOG_WARNING, "Invalid qualifyfreq number '%s' at line %d of %s\n", v->value, v->lineno, config);
27529 peer->qualifyfreq = global_qualifyfreq;
27530 }
27531 } else if (!strcasecmp(v->name, "maxcallbitrate")) {
27532 peer->maxcallbitrate = atoi(v->value);
27533 if (peer->maxcallbitrate < 0) {
27534 peer->maxcallbitrate = default_maxcallbitrate;
27535 }
27536 } else if (!strcasecmp(v->name, "session-timers")) {
27537 int i = (int) str2stmode(v->value);
27538 if (i < 0) {
27539 ast_log(LOG_WARNING, "Invalid session-timers '%s' at line %d of %s\n", v->value, v->lineno, config);
27540 peer->stimer.st_mode_oper = global_st_mode;
27541 } else {
27542 peer->stimer.st_mode_oper = i;
27543 }
27544 } else if (!strcasecmp(v->name, "session-expires")) {
27545 if (sscanf(v->value, "%30d", &peer->stimer.st_max_se) != 1) {
27546 ast_log(LOG_WARNING, "Invalid session-expires '%s' at line %d of %s\n", v->value, v->lineno, config);
27547 peer->stimer.st_max_se = global_max_se;
27548 }
27549 } else if (!strcasecmp(v->name, "session-minse")) {
27550 if (sscanf(v->value, "%30d", &peer->stimer.st_min_se) != 1) {
27551 ast_log(LOG_WARNING, "Invalid session-minse '%s' at line %d of %s\n", v->value, v->lineno, config);
27552 peer->stimer.st_min_se = global_min_se;
27553 }
27554 if (peer->stimer.st_min_se < 90) {
27555 ast_log(LOG_WARNING, "session-minse '%s' at line %d of %s is not allowed to be < 90 secs\n", v->value, v->lineno, config);
27556 peer->stimer.st_min_se = global_min_se;
27557 }
27558 } else if (!strcasecmp(v->name, "session-refresher")) {
27559 int i = (int) str2strefresher(v->value);
27560 if (i < 0) {
27561 ast_log(LOG_WARNING, "Invalid session-refresher '%s' at line %d of %s\n", v->value, v->lineno, config);
27562 peer->stimer.st_ref = global_st_refresher;
27563 } else {
27564 peer->stimer.st_ref = i;
27565 }
27566 } else if (!strcasecmp(v->name, "disallowed_methods")) {
27567 char *disallow = ast_strdupa(v->value);
27568 mark_parsed_methods(&peer->disallowed_methods, disallow);
27569 } else if (!strcasecmp(v->name, "unsolicited_mailbox")) {
27570 ast_string_field_set(peer, unsolicited_mailbox, v->value);
27571 } else if (!strcasecmp(v->name, "use_q850_reason")) {
27572 ast_set2_flag(&peer->flags[1], ast_true(v->value), SIP_PAGE2_Q850_REASON);
27573 } else if (!strcasecmp(v->name, "encryption")) {
27574 ast_set2_flag(&peer->flags[1], ast_true(v->value), SIP_PAGE2_USE_SRTP);
27575 } else if (!strcasecmp(v->name, "snom_aoc_enabled")) {
27576 ast_set2_flag(&peer->flags[2], ast_true(v->value), SIP_PAGE3_SNOM_AOC);
27577 }
27578 }
27579
27580
27581 if (realtime && !strcasecmp(v->name, "lastms")) {
27582 sscanf(v->value, "%30d", &peer->lastms);
27583 } else if (realtime && !strcasecmp(v->name, "ipaddr") && !ast_strlen_zero(v->value) ) {
27584 ast_sockaddr_parse(&peer->addr, v->value, PARSE_PORT_FORBID);
27585 } else if (realtime && !strcasecmp(v->name, "fullcontact")) {
27586 if (alt_fullcontact && !alt) {
27587
27588
27589
27590
27591
27592 alt_fullcontact = 0;
27593 ast_str_reset(fullcontact);
27594 }
27595
27596 if (fullcontact->used > 0) {
27597 ast_str_append(&fullcontact, 0, ";%s", v->value);
27598 } else {
27599 ast_str_set(&fullcontact, 0, "%s", v->value);
27600 }
27601 } else if (!strcasecmp(v->name, "qualify")) {
27602 if (!strcasecmp(v->value, "no")) {
27603 peer->maxms = 0;
27604 } else if (!strcasecmp(v->value, "yes")) {
27605 peer->maxms = default_qualify ? default_qualify : DEFAULT_MAXMS;
27606 } else if (sscanf(v->value, "%30d", &peer->maxms) != 1) {
27607 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);
27608 peer->maxms = 0;
27609 }
27610 if (realtime && !ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS) && peer->maxms > 0) {
27611
27612
27613
27614
27615 ast_log(LOG_WARNING, "Qualify is incompatible with dynamic uncached realtime. Please either turn rtcachefriends on or turn qualify off on peer '%s'\n", peer->name);
27616 peer->maxms = 0;
27617 }
27618 } else if (!strcasecmp(v->name, "callcounter")) {
27619 peer->call_limit = ast_true(v->value) ? INT_MAX : 0;
27620 } else if (!strcasecmp(v->name, "call-limit")) {
27621 peer->call_limit = atoi(v->value);
27622 if (peer->call_limit < 0) {
27623 peer->call_limit = 0;
27624 }
27625 } else if (!strcasecmp(v->name, "busylevel")) {
27626 peer->busy_level = atoi(v->value);
27627 if (peer->busy_level < 0) {
27628 peer->busy_level = 0;
27629 }
27630 } else if (ast_cc_is_config_param(v->name)) {
27631 ast_cc_set_param(peer->cc_params, v->name, v->value);
27632 }
27633 }
27634
27635 if (!devstate_only) {
27636 struct sip_mailbox *mailbox;
27637 AST_LIST_TRAVERSE_SAFE_BEGIN(&peer->mailboxes, mailbox, entry) {
27638 if (mailbox->delme) {
27639 AST_LIST_REMOVE_CURRENT(entry);
27640 destroy_mailbox(mailbox);
27641 }
27642 }
27643 AST_LIST_TRAVERSE_SAFE_END;
27644 }
27645
27646 if (!can_parse_xml && (ast_get_cc_agent_policy(peer->cc_params) == AST_CC_AGENT_NATIVE)) {
27647 ast_log(LOG_WARNING, "Peer %s has a cc_agent_policy of 'native' but required libxml2 dependency is not installed. Changing policy to 'never'\n", peer->name);
27648 ast_set_cc_agent_policy(peer->cc_params, AST_CC_AGENT_NEVER);
27649 }
27650
27651
27652
27653 if (peer->timer_b < peer->timer_t1 * 64) {
27654 if (timerb_set && timert1_set) {
27655 ast_log(LOG_WARNING, "Timer B has been set lower than recommended for peer %s (%d < 64 * Timer-T1=%d)\n", peer->name, peer->timer_b, peer->timer_t1);
27656 } else if (timerb_set) {
27657 if ((peer->timer_t1 = peer->timer_b / 64) < global_t1min) {
27658 ast_log(LOG_WARNING, "Timer B has been set lower than recommended (%d < 64 * timert1=%d). (RFC 3261, 17.1.1.2)\n", peer->timer_b, peer->timer_t1);
27659 peer->timer_t1 = global_t1min;
27660 peer->timer_b = peer->timer_t1 * 64;
27661 }
27662 peer->timer_t1 = peer->timer_b / 64;
27663 } else {
27664 peer->timer_b = peer->timer_t1 * 64;
27665 }
27666 }
27667
27668 if (!peer->default_outbound_transport) {
27669
27670 peer->transports = default_transports;
27671
27672 peer->default_outbound_transport = default_primary_transport;
27673 }
27674
27675
27676
27677
27678
27679 if (((peer->socket.type != peer->default_outbound_transport) && (peer->expire == -1)) ||
27680 !(peer->socket.type & peer->transports) || !(peer->socket.type)) {
27681
27682 set_socket_transport(&peer->socket, peer->default_outbound_transport);
27683 }
27684
27685 if (ast_str_strlen(fullcontact)) {
27686 ast_string_field_set(peer, fullcontact, ast_str_buffer(fullcontact));
27687 peer->rt_fromcontact = TRUE;
27688
27689
27690
27691
27692
27693
27694
27695
27696 if (!ast_test_flag(&peer->flags[0], SIP_NAT_FORCE_RPORT) || ast_sockaddr_isnull(&peer->addr)) {
27697 __set_address_from_contact(fullcontact->str, &peer->addr, 0);
27698 }
27699 }
27700
27701 if (srvlookup && peer->dnsmgr == NULL) {
27702 char transport[MAXHOSTNAMELEN];
27703 char _srvlookup[MAXHOSTNAMELEN];
27704 char *params;
27705
27706 ast_copy_string(_srvlookup, srvlookup, sizeof(_srvlookup));
27707 if ((params = strchr(_srvlookup, ';'))) {
27708 *params++ = '\0';
27709 }
27710
27711 snprintf(transport, sizeof(transport), "_%s._%s", get_srv_service(peer->socket.type), get_srv_protocol(peer->socket.type));
27712
27713 peer->addr.ss.ss_family = get_address_family_filter(&bindaddr);
27714 if (ast_dnsmgr_lookup_cb(_srvlookup, &peer->addr, &peer->dnsmgr, sip_cfg.srvlookup && !peer->portinuri ? transport : NULL,
27715 on_dns_update_peer, ref_peer(peer, "Store peer on dnsmgr"))) {
27716 ast_log(LOG_ERROR, "srvlookup failed for host: %s, on peer %s, removing peer\n", _srvlookup, peer->name);
27717 unref_peer(peer, "dnsmgr lookup failed, getting rid of peer dnsmgr ref");
27718 unref_peer(peer, "getting rid of a peer pointer");
27719 return NULL;
27720 }
27721 if (!peer->dnsmgr) {
27722
27723 unref_peer(peer, "dnsmgr disabled, unref peer");
27724 }
27725
27726 ast_string_field_set(peer, tohost, srvlookup);
27727
27728 if (global_dynamic_exclude_static) {
27729 int ha_error = 0;
27730 sip_cfg.contact_ha = ast_append_ha("deny", ast_sockaddr_stringify_addr(&peer->addr),
27731 sip_cfg.contact_ha, &ha_error);
27732 if (ha_error) {
27733 ast_log(LOG_ERROR, "Bad or unresolved host/IP entry in configuration for peer %s, cannot add to contact ACL\n", peer->name);
27734 }
27735 }
27736 } else if (peer->dnsmgr && !peer->host_dynamic) {
27737
27738 ast_dnsmgr_refresh(peer->dnsmgr);
27739 }
27740
27741 if (port && !realtime && peer->host_dynamic) {
27742 ast_sockaddr_set_port(&peer->defaddr, port);
27743 } else if (port) {
27744 ast_sockaddr_set_port(&peer->addr, port);
27745 }
27746
27747 if (ast_sockaddr_port(&peer->addr) == 0) {
27748 ast_sockaddr_set_port(&peer->addr,
27749 (peer->socket.type & SIP_TRANSPORT_TLS) ?
27750 STANDARD_TLS_PORT : STANDARD_SIP_PORT);
27751 }
27752 if (ast_sockaddr_port(&peer->defaddr) == 0) {
27753 ast_sockaddr_set_port(&peer->defaddr,
27754 (peer->socket.type & SIP_TRANSPORT_TLS) ?
27755 STANDARD_TLS_PORT : STANDARD_SIP_PORT);
27756 }
27757 if (!peer->socket.port) {
27758 peer->socket.port = htons(((peer->socket.type & SIP_TRANSPORT_TLS) ? STANDARD_TLS_PORT : STANDARD_SIP_PORT));
27759 }
27760
27761 if (!sip_cfg.ignore_regexpire && peer->host_dynamic && realtime) {
27762 time_t nowtime = time(NULL);
27763
27764 if ((nowtime - regseconds) > 0) {
27765 destroy_association(peer);
27766 memset(&peer->addr, 0, sizeof(peer->addr));
27767 peer->lastms = -1;
27768 ast_debug(1, "Bah, we're expired (%d/%d/%d)!\n", (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
27769 }
27770 }
27771
27772
27773 if (!devstate_only && realtime && peer->lastms > 0) {
27774 ref_peer(peer, "schedule qualify");
27775 sip_poke_peer(peer, 0);
27776 }
27777
27778 ast_copy_flags(&peer->flags[0], &peerflags[0], mask[0].flags);
27779 ast_copy_flags(&peer->flags[1], &peerflags[1], mask[1].flags);
27780 ast_copy_flags(&peer->flags[2], &peerflags[2], mask[2].flags);
27781 if (ast_test_flag(&peer->flags[1], SIP_PAGE2_ALLOWSUBSCRIBE)) {
27782 sip_cfg.allowsubscribe = TRUE;
27783 }
27784
27785 if (peer->host_dynamic && (!peer->is_realtime || !sip_cfg.peer_rtupdate)) {
27786 reg_source_db(peer);
27787 }
27788
27789
27790
27791 if (!devstate_only && !ast_test_flag(&peer->flags[1], SIP_PAGE2_SUBSCRIBEMWIONLY) &&
27792 !AST_LIST_EMPTY(&peer->mailboxes)) {
27793 add_peer_mwi_subs(peer);
27794
27795
27796
27797 sip_send_mwi_to_peer(peer, 1);
27798 }
27799
27800 peer->the_mark = 0;
27801
27802 ast_free_ha(oldha);
27803 ast_free_ha(olddirectmediaha);
27804 if (!ast_strlen_zero(callback)) {
27805 char *reg_string;
27806 if (asprintf(®_string, "%s?%s:%s@%s/%s", peer->name, peer->username, !ast_strlen_zero(peer->remotesecret) ? peer->remotesecret : peer->secret, peer->tohost, callback) < 0) {
27807 ast_log(LOG_WARNING, "asprintf() failed: %s\n", strerror(errno));
27808 } else if (reg_string) {
27809 sip_register(reg_string, 0);
27810 ast_free(reg_string);
27811 }
27812 }
27813 return peer;
27814 }
27815
27816 static int peer_markall_func(void *device, void *arg, int flags)
27817 {
27818 struct sip_peer *peer = device;
27819 peer->the_mark = 1;
27820 return 0;
27821 }
27822
27823 static void display_nat_warning(const char *cat, int reason, struct ast_flags *flags) {
27824 int global_nat, specific_nat;
27825
27826 if (reason == CHANNEL_MODULE_LOAD && (specific_nat = ast_test_flag(&flags[0], SIP_NAT_FORCE_RPORT)) != (global_nat = ast_test_flag(&global_flags[0], SIP_NAT_FORCE_RPORT))) {
27827 ast_log(LOG_WARNING, "!!! PLEASE NOTE: Setting 'nat' for a peer/user that differs from the global setting can make\n");
27828 ast_log(LOG_WARNING, "!!! the name of that peer/user discoverable by an attacker. Replies for non-existent peers/users\n");
27829 ast_log(LOG_WARNING, "!!! will be sent to a different port than replies for an existing peer/user. If at all possible,\n");
27830 ast_log(LOG_WARNING, "!!! use the global 'nat' setting and do not set 'nat' per peer/user.\n");
27831 ast_log(LOG_WARNING, "!!! (config category='%s' global force_rport='%s' peer/user force_rport='%s')\n", cat, AST_CLI_YESNO(global_nat), AST_CLI_YESNO(specific_nat));
27832 }
27833 }
27834
27835 static void cleanup_all_regs(void)
27836 {
27837
27838
27839 ASTOBJ_CONTAINER_TRAVERSE(®l, 1, do {
27840 ASTOBJ_WRLOCK(iterator);
27841 if (iterator->call) {
27842 ast_debug(3, "Destroying active SIP dialog for registry %s@%s\n", iterator->username, iterator->hostname);
27843
27844 dialog_unlink_all(iterator->call);
27845 iterator->call = dialog_unref(iterator->call, "remove iterator->call from registry traversal");
27846 }
27847 if (iterator->expire > -1) {
27848 AST_SCHED_DEL_UNREF(sched, iterator->expire, registry_unref(iterator, "reg ptr unref from reload config"));
27849 }
27850 if (iterator->timeout > -1) {
27851 AST_SCHED_DEL_UNREF(sched, iterator->timeout, registry_unref(iterator, "reg ptr unref from reload config"));
27852 }
27853 if (iterator->dnsmgr) {
27854 ast_dnsmgr_release(iterator->dnsmgr);
27855 iterator->dnsmgr = NULL;
27856 registry_unref(iterator, "reg ptr unref from dnsmgr");
27857 }
27858 ASTOBJ_UNLOCK(iterator);
27859 } while(0));
27860 }
27861
27862
27863
27864
27865
27866
27867
27868 static int reload_config(enum channelreloadreason reason)
27869 {
27870 struct ast_config *cfg, *ucfg;
27871 struct ast_variable *v;
27872 struct sip_peer *peer;
27873 char *cat, *stringp, *context, *oldregcontext;
27874 char newcontexts[AST_MAX_CONTEXT], oldcontexts[AST_MAX_CONTEXT];
27875 struct ast_flags dummy[2];
27876 struct ast_flags config_flags = { reason == CHANNEL_MODULE_LOAD ? 0 : ast_test_flag(&global_flags[1], SIP_PAGE2_RTCACHEFRIENDS) ? 0 : CONFIG_FLAG_FILEUNCHANGED };
27877 int auto_sip_domains = FALSE;
27878 struct ast_sockaddr old_bindaddr = bindaddr;
27879 int registry_count = 0, peer_count = 0, timerb_set = 0, timert1_set = 0;
27880 int subscribe_network_change = 1;
27881 time_t run_start, run_end;
27882 int bindport = 0;
27883
27884 run_start = time(0);
27885 ast_unload_realtime("sipregs");
27886 ast_unload_realtime("sippeers");
27887 cfg = ast_config_load(config, config_flags);
27888
27889
27890 if (!cfg) {
27891 ast_log(LOG_NOTICE, "Unable to load config %s\n", config);
27892 return -1;
27893 } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
27894 ucfg = ast_config_load("users.conf", config_flags);
27895 if (ucfg == CONFIG_STATUS_FILEUNCHANGED) {
27896 return 1;
27897 } else if (ucfg == CONFIG_STATUS_FILEINVALID) {
27898 ast_log(LOG_ERROR, "Contents of users.conf are invalid and cannot be parsed\n");
27899 return 1;
27900 }
27901
27902 ast_clear_flag(&config_flags, CONFIG_FLAG_FILEUNCHANGED);
27903 if ((cfg = ast_config_load(config, config_flags)) == CONFIG_STATUS_FILEINVALID) {
27904 ast_log(LOG_ERROR, "Contents of %s are invalid and cannot be parsed\n", config);
27905 ast_config_destroy(ucfg);
27906 return 1;
27907 }
27908 } else if (cfg == CONFIG_STATUS_FILEINVALID) {
27909 ast_log(LOG_ERROR, "Contents of %s are invalid and cannot be parsed\n", config);
27910 return 1;
27911 } else {
27912 ast_clear_flag(&config_flags, CONFIG_FLAG_FILEUNCHANGED);
27913 if ((ucfg = ast_config_load("users.conf", config_flags)) == CONFIG_STATUS_FILEINVALID) {
27914 ast_log(LOG_ERROR, "Contents of users.conf are invalid and cannot be parsed\n");
27915 ast_config_destroy(cfg);
27916 return 1;
27917 }
27918 }
27919
27920 ast_free_ha(sip_cfg.contact_ha);
27921 sip_cfg.contact_ha = NULL;
27922
27923 default_tls_cfg.enabled = FALSE;
27924
27925 if (reason != CHANNEL_MODULE_LOAD) {
27926 ast_debug(4, "--------------- SIP reload started\n");
27927
27928 clear_sip_domains();
27929 ast_mutex_lock(&authl_lock);
27930 if (authl) {
27931 ao2_t_ref(authl, -1, "Removing old global authentication");
27932 authl = NULL;
27933 }
27934 ast_mutex_unlock(&authl_lock);
27935
27936
27937 cleanup_all_regs();
27938
27939 ASTOBJ_CONTAINER_DESTROYALL(®l, sip_registry_destroy);
27940 ast_debug(4, "--------------- Done destroying registry list\n");
27941 ao2_t_callback(peers, OBJ_NODATA, peer_markall_func, NULL, "callback to mark all peers");
27942 }
27943
27944
27945 if (reason != CHANNEL_MODULE_LOAD) {
27946 ast_free(default_tls_cfg.certfile);
27947 ast_free(default_tls_cfg.pvtfile);
27948 ast_free(default_tls_cfg.cipher);
27949 ast_free(default_tls_cfg.cafile);
27950 ast_free(default_tls_cfg.capath);
27951 }
27952 default_tls_cfg.certfile = ast_strdup(AST_CERTFILE);
27953 default_tls_cfg.pvtfile = ast_strdup("");
27954 default_tls_cfg.cipher = ast_strdup("");
27955 default_tls_cfg.cafile = ast_strdup("");
27956 default_tls_cfg.capath = ast_strdup("");
27957
27958
27959 ast_copy_string(oldcontexts, sip_cfg.regcontext, sizeof(oldcontexts));
27960 oldregcontext = oldcontexts;
27961
27962
27963
27964 sipdebug &= sip_debug_console;
27965 ast_clear_flag(&global_flags[0], AST_FLAGS_ALL);
27966 ast_clear_flag(&global_flags[1], AST_FLAGS_ALL);
27967 ast_clear_flag(&global_flags[2], AST_FLAGS_ALL);
27968
27969
27970 ast_sockaddr_parse(&bindaddr, "0.0.0.0:0", 0);
27971 memset(&internip, 0, sizeof(internip));
27972
27973
27974 ast_free_ha(localaddr);
27975 memset(&localaddr, 0, sizeof(localaddr));
27976 memset(&externaddr, 0, sizeof(externaddr));
27977 memset(&media_address, 0, sizeof(media_address));
27978 memset(&default_prefs, 0 , sizeof(default_prefs));
27979 memset(&sip_cfg.outboundproxy, 0, sizeof(struct sip_proxy));
27980 sip_cfg.outboundproxy.force = FALSE;
27981 default_transports = 0;
27982 default_primary_transport = 0;
27983 ourport_tcp = STANDARD_SIP_PORT;
27984 ourport_tls = STANDARD_TLS_PORT;
27985 externtcpport = STANDARD_SIP_PORT;
27986 externtlsport = STANDARD_TLS_PORT;
27987 sip_cfg.srvlookup = DEFAULT_SRVLOOKUP;
27988 global_tos_sip = DEFAULT_TOS_SIP;
27989 global_tos_audio = DEFAULT_TOS_AUDIO;
27990 global_tos_video = DEFAULT_TOS_VIDEO;
27991 global_tos_text = DEFAULT_TOS_TEXT;
27992 global_cos_sip = DEFAULT_COS_SIP;
27993 global_cos_audio = DEFAULT_COS_AUDIO;
27994 global_cos_video = DEFAULT_COS_VIDEO;
27995 global_cos_text = DEFAULT_COS_TEXT;
27996
27997 externhost[0] = '\0';
27998 externexpire = 0;
27999 externrefresh = 10;
28000
28001
28002 sip_cfg.allow_external_domains = DEFAULT_ALLOW_EXT_DOM;
28003 sip_cfg.regcontext[0] = '\0';
28004 sip_cfg.capability = DEFAULT_CAPABILITY;
28005 sip_cfg.regextenonqualify = DEFAULT_REGEXTENONQUALIFY;
28006 sip_cfg.legacy_useroption_parsing = DEFAULT_LEGACY_USEROPTION_PARSING;
28007 sip_cfg.notifyringing = DEFAULT_NOTIFYRINGING;
28008 sip_cfg.notifycid = DEFAULT_NOTIFYCID;
28009 sip_cfg.notifyhold = FALSE;
28010 sip_cfg.directrtpsetup = FALSE;
28011 sip_cfg.alwaysauthreject = DEFAULT_ALWAYSAUTHREJECT;
28012 sip_cfg.auth_options_requests = DEFAULT_AUTH_OPTIONS;
28013 sip_cfg.allowsubscribe = FALSE;
28014 sip_cfg.disallowed_methods = SIP_UNKNOWN;
28015 sip_cfg.contact_ha = NULL;
28016 snprintf(global_useragent, sizeof(global_useragent), "%s %s", DEFAULT_USERAGENT, ast_get_version());
28017 snprintf(global_sdpsession, sizeof(global_sdpsession), "%s %s", DEFAULT_SDPSESSION, ast_get_version());
28018 snprintf(global_sdpowner, sizeof(global_sdpowner), "%s", DEFAULT_SDPOWNER);
28019 global_prematuremediafilter = TRUE;
28020 ast_copy_string(default_notifymime, DEFAULT_NOTIFYMIME, sizeof(default_notifymime));
28021 ast_copy_string(sip_cfg.realm, S_OR(ast_config_AST_SYSTEM_NAME, DEFAULT_REALM), sizeof(sip_cfg.realm));
28022 sip_cfg.domainsasrealm = DEFAULT_DOMAINSASREALM;
28023 ast_copy_string(default_callerid, DEFAULT_CALLERID, sizeof(default_callerid));
28024 ast_copy_string(default_mwi_from, DEFAULT_MWI_FROM, sizeof(default_mwi_from));
28025 sip_cfg.compactheaders = DEFAULT_COMPACTHEADERS;
28026 global_reg_timeout = DEFAULT_REGISTRATION_TIMEOUT;
28027 global_regattempts_max = 0;
28028 sip_cfg.pedanticsipchecking = DEFAULT_PEDANTIC;
28029 sip_cfg.autocreatepeer = DEFAULT_AUTOCREATEPEER;
28030 global_autoframing = 0;
28031 sip_cfg.allowguest = DEFAULT_ALLOWGUEST;
28032 global_callcounter = DEFAULT_CALLCOUNTER;
28033 global_match_auth_username = FALSE;
28034 global_rtptimeout = 0;
28035 global_rtpholdtimeout = 0;
28036 global_rtpkeepalive = DEFAULT_RTPKEEPALIVE;
28037 sip_cfg.allowtransfer = TRANSFER_OPENFORALL;
28038 sip_cfg.rtautoclear = 120;
28039 ast_set_flag(&global_flags[1], SIP_PAGE2_ALLOWSUBSCRIBE);
28040 ast_set_flag(&global_flags[1], SIP_PAGE2_ALLOWOVERLAP_YES);
28041 sip_cfg.peer_rtupdate = TRUE;
28042 global_dynamic_exclude_static = 0;
28043 sip_cfg.tcp_enabled = FALSE;
28044
28045
28046 global_st_mode = SESSION_TIMER_MODE_ACCEPT;
28047 global_st_refresher = SESSION_TIMER_REFRESHER_UAS;
28048 global_min_se = DEFAULT_MIN_SE;
28049 global_max_se = DEFAULT_MAX_SE;
28050
28051
28052 global_qualify_gap = DEFAULT_QUALIFY_GAP;
28053 global_qualify_peers = DEFAULT_QUALIFY_PEERS;
28054
28055
28056 ast_copy_string(sip_cfg.default_context, DEFAULT_CONTEXT, sizeof(sip_cfg.default_context));
28057 sip_cfg.default_subscribecontext[0] = '\0';
28058 sip_cfg.default_max_forwards = DEFAULT_MAX_FORWARDS;
28059 default_language[0] = '\0';
28060 default_fromdomain[0] = '\0';
28061 default_fromdomainport = 0;
28062 default_qualify = DEFAULT_QUALIFY;
28063 default_maxcallbitrate = DEFAULT_MAX_CALL_BITRATE;
28064 ast_copy_string(default_mohinterpret, DEFAULT_MOHINTERPRET, sizeof(default_mohinterpret));
28065 ast_copy_string(default_mohsuggest, DEFAULT_MOHSUGGEST, sizeof(default_mohsuggest));
28066 ast_copy_string(default_vmexten, DEFAULT_VMEXTEN, sizeof(default_vmexten));
28067 ast_set_flag(&global_flags[0], SIP_DTMF_RFC2833);
28068 ast_set_flag(&global_flags[0], SIP_DIRECT_MEDIA);
28069 ast_set_flag(&global_flags[0], SIP_NAT_FORCE_RPORT);
28070 ast_copy_string(default_engine, DEFAULT_ENGINE, sizeof(default_engine));
28071 ast_copy_string(default_parkinglot, DEFAULT_PARKINGLOT, sizeof(default_parkinglot));
28072
28073
28074 dumphistory = FALSE;
28075 recordhistory = FALSE;
28076 sipdebug &= ~sip_debug_config;
28077
28078
28079 global_relaxdtmf = FALSE;
28080 sip_cfg.callevents = DEFAULT_CALLEVENTS;
28081 global_authfailureevents = FALSE;
28082 global_t1 = DEFAULT_TIMER_T1;
28083 global_timer_b = 64 * DEFAULT_TIMER_T1;
28084 global_t1min = DEFAULT_T1MIN;
28085 global_qualifyfreq = DEFAULT_QUALIFYFREQ;
28086 global_t38_maxdatagram = -1;
28087 global_shrinkcallerid = 1;
28088 authlimit = DEFAULT_AUTHLIMIT;
28089 authtimeout = DEFAULT_AUTHTIMEOUT;
28090 global_store_sip_cause = DEFAULT_STORE_SIP_CAUSE;
28091
28092 sip_cfg.matchexternaddrlocally = DEFAULT_MATCHEXTERNADDRLOCALLY;
28093
28094
28095 memcpy(&global_jbconf, &default_jbconf, sizeof(struct ast_jb_conf));
28096
28097 ast_clear_flag(&global_flags[1], SIP_PAGE2_FAX_DETECT);
28098 ast_clear_flag(&global_flags[1], SIP_PAGE2_VIDEOSUPPORT | SIP_PAGE2_VIDEOSUPPORT_ALWAYS);
28099 ast_clear_flag(&global_flags[1], SIP_PAGE2_TEXTSUPPORT);
28100 ast_clear_flag(&global_flags[1], SIP_PAGE2_IGNORESDPVERSION);
28101
28102
28103
28104 for (v = ast_variable_browse(cfg, "general"); v; v = v->next) {
28105 if (handle_common_options(&global_flags[0], &dummy[0], v)) {
28106 continue;
28107 }
28108 if (handle_t38_options(&global_flags[0], &dummy[0], v, &global_t38_maxdatagram)) {
28109 continue;
28110 }
28111
28112 if (!ast_jb_read_conf(&global_jbconf, v->name, v->value))
28113 continue;
28114
28115
28116 if (!ast_tls_read_conf(&default_tls_cfg, &sip_tls_desc, v->name, v->value)) {
28117 continue;
28118 }
28119
28120 if (!strcasecmp(v->name, "context")) {
28121 ast_copy_string(sip_cfg.default_context, v->value, sizeof(sip_cfg.default_context));
28122 } else if (!strcasecmp(v->name, "subscribecontext")) {
28123 ast_copy_string(sip_cfg.default_subscribecontext, v->value, sizeof(sip_cfg.default_subscribecontext));
28124 } else if (!strcasecmp(v->name, "callcounter")) {
28125 global_callcounter = ast_true(v->value) ? 1 : 0;
28126 } else if (!strcasecmp(v->name, "allowguest")) {
28127 sip_cfg.allowguest = ast_true(v->value) ? 1 : 0;
28128 } else if (!strcasecmp(v->name, "realm")) {
28129 ast_copy_string(sip_cfg.realm, v->value, sizeof(sip_cfg.realm));
28130 } else if (!strcasecmp(v->name, "domainsasrealm")) {
28131 sip_cfg.domainsasrealm = ast_true(v->value);
28132 } else if (!strcasecmp(v->name, "useragent")) {
28133 ast_copy_string(global_useragent, v->value, sizeof(global_useragent));
28134 ast_debug(1, "Setting SIP channel User-Agent Name to %s\n", global_useragent);
28135 } else if (!strcasecmp(v->name, "sdpsession")) {
28136 ast_copy_string(global_sdpsession, v->value, sizeof(global_sdpsession));
28137 } else if (!strcasecmp(v->name, "sdpowner")) {
28138
28139 if (!strstr(v->value, " ")) {
28140 ast_copy_string(global_sdpowner, v->value, sizeof(global_sdpowner));
28141 } else {
28142 ast_log(LOG_WARNING, "'%s' must not contain spaces at line %d. Using default.\n", v->value, v->lineno);
28143 }
28144 } else if (!strcasecmp(v->name, "allowtransfer")) {
28145 sip_cfg.allowtransfer = ast_true(v->value) ? TRANSFER_OPENFORALL : TRANSFER_CLOSED;
28146 } else if (!strcasecmp(v->name, "rtcachefriends")) {
28147 ast_set2_flag(&global_flags[1], ast_true(v->value), SIP_PAGE2_RTCACHEFRIENDS);
28148 } else if (!strcasecmp(v->name, "rtsavesysname")) {
28149 sip_cfg.rtsave_sysname = ast_true(v->value);
28150 } else if (!strcasecmp(v->name, "rtupdate")) {
28151 sip_cfg.peer_rtupdate = ast_true(v->value);
28152 } else if (!strcasecmp(v->name, "ignoreregexpire")) {
28153 sip_cfg.ignore_regexpire = ast_true(v->value);
28154 } else if (!strcasecmp(v->name, "timert1")) {
28155
28156
28157
28158 global_t1 = atoi(v->value);
28159 } else if (!strcasecmp(v->name, "timerb")) {
28160 int tmp = atoi(v->value);
28161 if (tmp < 500) {
28162 global_timer_b = global_t1 * 64;
28163 ast_log(LOG_WARNING, "Invalid value for timerb ('%s'). Setting to default ('%d').\n", v->value, global_timer_b);
28164 }
28165 timerb_set = 1;
28166 } else if (!strcasecmp(v->name, "t1min")) {
28167 global_t1min = atoi(v->value);
28168 } else if (!strcasecmp(v->name, "transport") && !ast_strlen_zero(v->value)) {
28169 char *val = ast_strdupa(v->value);
28170 char *trans;
28171
28172 while ((trans = strsep(&val, ","))) {
28173 trans = ast_skip_blanks(trans);
28174
28175 if (!strncasecmp(trans, "udp", 3)) {
28176 default_transports |= SIP_TRANSPORT_UDP;
28177 } else if (!strncasecmp(trans, "tcp", 3)) {
28178 default_transports |= SIP_TRANSPORT_TCP;
28179 } else if (!strncasecmp(trans, "tls", 3)) {
28180 default_transports |= SIP_TRANSPORT_TLS;
28181 } else {
28182 ast_log(LOG_NOTICE, "'%s' is not a valid transport type. if no other is specified, udp will be used.\n", trans);
28183 }
28184 if (default_primary_transport == 0) {
28185 default_primary_transport = default_transports;
28186 }
28187 }
28188 } else if (!strcasecmp(v->name, "tcpenable")) {
28189 if (!ast_false(v->value)) {
28190 ast_debug(2, "Enabling TCP socket for listening\n");
28191 sip_cfg.tcp_enabled = TRUE;
28192 }
28193 } else if (!strcasecmp(v->name, "tcpbindaddr")) {
28194 if (ast_parse_arg(v->value, PARSE_ADDR,
28195 &sip_tcp_desc.local_address)) {
28196 ast_log(LOG_WARNING, "Invalid %s '%s' at line %d of %s\n",
28197 v->name, v->value, v->lineno, config);
28198 }
28199 ast_debug(2, "Setting TCP socket address to %s\n",
28200 ast_sockaddr_stringify(&sip_tcp_desc.local_address));
28201 } else if (!strcasecmp(v->name, "dynamic_exclude_static") || !strcasecmp(v->name, "dynamic_excludes_static")) {
28202 global_dynamic_exclude_static = ast_true(v->value);
28203 } else if (!strcasecmp(v->name, "contactpermit") || !strcasecmp(v->name, "contactdeny")) {
28204 int ha_error = 0;
28205 sip_cfg.contact_ha = ast_append_ha(v->name + 7, v->value, sip_cfg.contact_ha, &ha_error);
28206 if (ha_error) {
28207 ast_log(LOG_ERROR, "Bad ACL entry in configuration line %d : %s\n", v->lineno, v->value);
28208 }
28209 } else if (!strcasecmp(v->name, "rtautoclear")) {
28210 int i = atoi(v->value);
28211 if (i > 0) {
28212 sip_cfg.rtautoclear = i;
28213 } else {
28214 i = 0;
28215 }
28216 ast_set2_flag(&global_flags[1], i || ast_true(v->value), SIP_PAGE2_RTAUTOCLEAR);
28217 } else if (!strcasecmp(v->name, "usereqphone")) {
28218 ast_set2_flag(&global_flags[0], ast_true(v->value), SIP_USEREQPHONE);
28219 } else if (!strcasecmp(v->name, "prematuremedia")) {
28220 global_prematuremediafilter = ast_true(v->value);
28221 } else if (!strcasecmp(v->name, "relaxdtmf")) {
28222 global_relaxdtmf = ast_true(v->value);
28223 } else if (!strcasecmp(v->name, "vmexten")) {
28224 ast_copy_string(default_vmexten, v->value, sizeof(default_vmexten));
28225 } else if (!strcasecmp(v->name, "rtptimeout")) {
28226 if ((sscanf(v->value, "%30d", &global_rtptimeout) != 1) || (global_rtptimeout < 0)) {
28227 ast_log(LOG_WARNING, "'%s' is not a valid RTP hold time at line %d. Using default.\n", v->value, v->lineno);
28228 global_rtptimeout = 0;
28229 }
28230 } else if (!strcasecmp(v->name, "rtpholdtimeout")) {
28231 if ((sscanf(v->value, "%30d", &global_rtpholdtimeout) != 1) || (global_rtpholdtimeout < 0)) {
28232 ast_log(LOG_WARNING, "'%s' is not a valid RTP hold time at line %d. Using default.\n", v->value, v->lineno);
28233 global_rtpholdtimeout = 0;
28234 }
28235 } else if (!strcasecmp(v->name, "rtpkeepalive")) {
28236 if ((sscanf(v->value, "%30d", &global_rtpkeepalive) != 1) || (global_rtpkeepalive < 0)) {
28237 ast_log(LOG_WARNING, "'%s' is not a valid RTP keepalive time at line %d. Using default.\n", v->value, v->lineno);
28238 global_rtpkeepalive = DEFAULT_RTPKEEPALIVE;
28239 }
28240 } else if (!strcasecmp(v->name, "compactheaders")) {
28241 sip_cfg.compactheaders = ast_true(v->value);
28242 } else if (!strcasecmp(v->name, "notifymimetype")) {
28243 ast_copy_string(default_notifymime, v->value, sizeof(default_notifymime));
28244 } else if (!strcasecmp(v->name, "directrtpsetup")) {
28245 sip_cfg.directrtpsetup = ast_true(v->value);
28246 } else if (!strcasecmp(v->name, "notifyringing")) {
28247 sip_cfg.notifyringing = ast_true(v->value);
28248 } else if (!strcasecmp(v->name, "notifyhold")) {
28249 sip_cfg.notifyhold = ast_true(v->value);
28250 } else if (!strcasecmp(v->name, "notifycid")) {
28251 if (!strcasecmp(v->value, "ignore-context")) {
28252 sip_cfg.notifycid = IGNORE_CONTEXT;
28253 } else {
28254 sip_cfg.notifycid = ast_true(v->value) ? ENABLED : DISABLED;
28255 }
28256 } else if (!strcasecmp(v->name, "alwaysauthreject")) {
28257 sip_cfg.alwaysauthreject = ast_true(v->value);
28258 } else if (!strcasecmp(v->name, "auth_options_requests")) {
28259 if (ast_true(v->value)) {
28260 sip_cfg.auth_options_requests = 1;
28261 }
28262 } else if (!strcasecmp(v->name, "mohinterpret")) {
28263 ast_copy_string(default_mohinterpret, v->value, sizeof(default_mohinterpret));
28264 } else if (!strcasecmp(v->name, "mohsuggest")) {
28265 ast_copy_string(default_mohsuggest, v->value, sizeof(default_mohsuggest));
28266 } else if (!strcasecmp(v->name, "language")) {
28267 ast_copy_string(default_language, v->value, sizeof(default_language));
28268 } else if (!strcasecmp(v->name, "regcontext")) {
28269 ast_copy_string(newcontexts, v->value, sizeof(newcontexts));
28270 stringp = newcontexts;
28271
28272 cleanup_stale_contexts(stringp, oldregcontext);
28273
28274 while ((context = strsep(&stringp, "&"))) {
28275 ast_copy_string(used_context, context, sizeof(used_context));
28276 ast_context_find_or_create(NULL, NULL, context, "SIP");
28277 }
28278 ast_copy_string(sip_cfg.regcontext, v->value, sizeof(sip_cfg.regcontext));
28279 } else if (!strcasecmp(v->name, "regextenonqualify")) {
28280 sip_cfg.regextenonqualify = ast_true(v->value);
28281 } else if (!strcasecmp(v->name, "legacy_useroption_parsing")) {
28282 sip_cfg.legacy_useroption_parsing = ast_true(v->value);
28283 } else if (!strcasecmp(v->name, "callerid")) {
28284 ast_copy_string(default_callerid, v->value, sizeof(default_callerid));
28285 } else if (!strcasecmp(v->name, "mwi_from")) {
28286 ast_copy_string(default_mwi_from, v->value, sizeof(default_mwi_from));
28287 } else if (!strcasecmp(v->name, "fromdomain")) {
28288 char *fromdomainport;
28289 ast_copy_string(default_fromdomain, v->value, sizeof(default_fromdomain));
28290 if ((fromdomainport = strchr(default_fromdomain, ':'))) {
28291 *fromdomainport++ = '\0';
28292 if (!(default_fromdomainport = port_str2int(fromdomainport, 0))) {
28293 ast_log(LOG_NOTICE, "'%s' is not a valid port number for fromdomain.\n",fromdomainport);
28294 }
28295 } else {
28296 default_fromdomainport = STANDARD_SIP_PORT;
28297 }
28298 } else if (!strcasecmp(v->name, "outboundproxy")) {
28299 char *tok, *proxyname;
28300
28301 if (ast_strlen_zero(v->value)) {
28302 ast_log(LOG_WARNING, "no value given for outbound proxy on line %d of sip.conf.", v->lineno);
28303 continue;
28304 }
28305
28306 tok = ast_skip_blanks(strtok(ast_strdupa(v->value), ","));
28307
28308 sip_parse_host(tok, v->lineno, &proxyname,
28309 &sip_cfg.outboundproxy.port,
28310 &sip_cfg.outboundproxy.transport);
28311
28312 if ((tok = strtok(NULL, ","))) {
28313 sip_cfg.outboundproxy.force = !strncasecmp(ast_skip_blanks(tok), "force", 5);
28314 } else {
28315 sip_cfg.outboundproxy.force = FALSE;
28316 }
28317
28318 if (ast_strlen_zero(proxyname)) {
28319 ast_log(LOG_WARNING, "you must specify a name for the outboundproxy on line %d of sip.conf.", v->lineno);
28320 sip_cfg.outboundproxy.name[0] = '\0';
28321 continue;
28322 }
28323
28324 ast_copy_string(sip_cfg.outboundproxy.name, proxyname, sizeof(sip_cfg.outboundproxy.name));
28325
28326 proxy_update(&sip_cfg.outboundproxy);
28327 } else if (!strcasecmp(v->name, "autocreatepeer")) {
28328 sip_cfg.autocreatepeer = ast_true(v->value);
28329 } else if (!strcasecmp(v->name, "match_auth_username")) {
28330 global_match_auth_username = ast_true(v->value);
28331 } else if (!strcasecmp(v->name, "srvlookup")) {
28332 sip_cfg.srvlookup = ast_true(v->value);
28333 } else if (!strcasecmp(v->name, "pedantic")) {
28334 sip_cfg.pedanticsipchecking = ast_true(v->value);
28335 } else if (!strcasecmp(v->name, "maxexpirey") || !strcasecmp(v->name, "maxexpiry")) {
28336 max_expiry = atoi(v->value);
28337 if (max_expiry < 1) {
28338 max_expiry = DEFAULT_MAX_EXPIRY;
28339 }
28340 } else if (!strcasecmp(v->name, "minexpirey") || !strcasecmp(v->name, "minexpiry")) {
28341 min_expiry = atoi(v->value);
28342 if (min_expiry < 1) {
28343 min_expiry = DEFAULT_MIN_EXPIRY;
28344 }
28345 } else if (!strcasecmp(v->name, "defaultexpiry") || !strcasecmp(v->name, "defaultexpirey")) {
28346 default_expiry = atoi(v->value);
28347 if (default_expiry < 1) {
28348 default_expiry = DEFAULT_DEFAULT_EXPIRY;
28349 }
28350 } else if (!strcasecmp(v->name, "mwiexpiry") || !strcasecmp(v->name, "mwiexpirey")) {
28351 mwi_expiry = atoi(v->value);
28352 if (mwi_expiry < 1) {
28353 mwi_expiry = DEFAULT_MWI_EXPIRY;
28354 }
28355 } else if (!strcasecmp(v->name, "tcpauthtimeout")) {
28356 if (ast_parse_arg(v->value, PARSE_INT32|PARSE_DEFAULT|PARSE_IN_RANGE,
28357 &authtimeout, DEFAULT_AUTHTIMEOUT, 1, INT_MAX)) {
28358 ast_log(LOG_WARNING, "Invalid %s '%s' at line %d of %s\n",
28359 v->name, v->value, v->lineno, config);
28360 }
28361 } else if (!strcasecmp(v->name, "tcpauthlimit")) {
28362 if (ast_parse_arg(v->value, PARSE_INT32|PARSE_DEFAULT|PARSE_IN_RANGE,
28363 &authlimit, DEFAULT_AUTHLIMIT, 1, INT_MAX)) {
28364 ast_log(LOG_WARNING, "Invalid %s '%s' at line %d of %s\n",
28365 v->name, v->value, v->lineno, config);
28366 }
28367 } else if (!strcasecmp(v->name, "sipdebug")) {
28368 if (ast_true(v->value))
28369 sipdebug |= sip_debug_config;
28370 } else if (!strcasecmp(v->name, "dumphistory")) {
28371 dumphistory = ast_true(v->value);
28372 } else if (!strcasecmp(v->name, "recordhistory")) {
28373 recordhistory = ast_true(v->value);
28374 } else if (!strcasecmp(v->name, "registertimeout")) {
28375 global_reg_timeout = atoi(v->value);
28376 if (global_reg_timeout < 1) {
28377 global_reg_timeout = DEFAULT_REGISTRATION_TIMEOUT;
28378 }
28379 } else if (!strcasecmp(v->name, "registerattempts")) {
28380 global_regattempts_max = atoi(v->value);
28381 } else if (!strcasecmp(v->name, "bindaddr") || !strcasecmp(v->name, "udpbindaddr")) {
28382 if (ast_parse_arg(v->value, PARSE_ADDR, &bindaddr)) {
28383 ast_log(LOG_WARNING, "Invalid address: %s\n", v->value);
28384 }
28385 } else if (!strcasecmp(v->name, "localnet")) {
28386 struct ast_ha *na;
28387 int ha_error = 0;
28388
28389 if (!(na = ast_append_ha("d", v->value, localaddr, &ha_error))) {
28390 ast_log(LOG_WARNING, "Invalid localnet value: %s\n", v->value);
28391 } else {
28392 localaddr = na;
28393 }
28394 if (ha_error) {
28395 ast_log(LOG_ERROR, "Bad localnet configuration value line %d : %s\n", v->lineno, v->value);
28396 }
28397 } else if (!strcasecmp(v->name, "media_address")) {
28398 if (ast_parse_arg(v->value, PARSE_ADDR, &media_address))
28399 ast_log(LOG_WARNING, "Invalid address for media_address keyword: %s\n", v->value);
28400 } else if (!strcasecmp(v->name, "externaddr") || !strcasecmp(v->name, "externip")) {
28401 if (ast_parse_arg(v->value, PARSE_ADDR, &externaddr)) {
28402 ast_log(LOG_WARNING,
28403 "Invalid address for externaddr keyword: %s\n",
28404 v->value);
28405 }
28406 externexpire = 0;
28407 } else if (!strcasecmp(v->name, "externhost")) {
28408 ast_copy_string(externhost, v->value, sizeof(externhost));
28409 if (ast_sockaddr_resolve_first(&externaddr, externhost, 0)) {
28410 ast_log(LOG_WARNING, "Invalid address for externhost keyword: %s\n", externhost);
28411 }
28412 externexpire = time(NULL);
28413 } else if (!strcasecmp(v->name, "externrefresh")) {
28414 if (sscanf(v->value, "%30d", &externrefresh) != 1) {
28415 ast_log(LOG_WARNING, "Invalid externrefresh value '%s', must be an integer >0 at line %d\n", v->value, v->lineno);
28416 externrefresh = 10;
28417 }
28418 } else if (!strcasecmp(v->name, "externtcpport")) {
28419 if (!(externtcpport = port_str2int(v->value, 0))) {
28420 ast_log(LOG_WARNING, "Invalid externtcpport value, must be a positive integer between 1 and 65535 at line %d\n", v->lineno);
28421 externtcpport = 0;
28422 }
28423 } else if (!strcasecmp(v->name, "externtlsport")) {
28424 if (!(externtlsport = port_str2int(v->value, STANDARD_TLS_PORT))) {
28425 ast_log(LOG_WARNING, "Invalid externtlsport value, must be a positive integer between 1 and 65535 at line %d\n", v->lineno);
28426 }
28427 } else if (!strcasecmp(v->name, "allow")) {
28428 int error = ast_parse_allow_disallow(&default_prefs, &sip_cfg.capability, v->value, TRUE);
28429 if (error) {
28430 ast_log(LOG_WARNING, "Codec configuration errors found in line %d : %s = %s\n", v->lineno, v->name, v->value);
28431 }
28432 } else if (!strcasecmp(v->name, "disallow")) {
28433 int error = ast_parse_allow_disallow(&default_prefs, &sip_cfg.capability, v->value, FALSE);
28434 if (error) {
28435 ast_log(LOG_WARNING, "Codec configuration errors found in line %d : %s = %s\n", v->lineno, v->name, v->value);
28436 }
28437 } else if (!strcasecmp(v->name, "preferred_codec_only")) {
28438 ast_set2_flag(&global_flags[1], ast_true(v->value), SIP_PAGE2_PREFERRED_CODEC);
28439 } else if (!strcasecmp(v->name, "autoframing")) {
28440 global_autoframing = ast_true(v->value);
28441 } else if (!strcasecmp(v->name, "allowexternaldomains")) {
28442 sip_cfg.allow_external_domains = ast_true(v->value);
28443 } else if (!strcasecmp(v->name, "autodomain")) {
28444 auto_sip_domains = ast_true(v->value);
28445 } else if (!strcasecmp(v->name, "domain")) {
28446 char *domain = ast_strdupa(v->value);
28447 char *cntx = strchr(domain, ',');
28448
28449 if (cntx) {
28450 *cntx++ = '\0';
28451 }
28452
28453 if (ast_strlen_zero(cntx)) {
28454 ast_debug(1, "No context specified at line %d for domain '%s'\n", v->lineno, domain);
28455 }
28456 if (ast_strlen_zero(domain)) {
28457 ast_log(LOG_WARNING, "Empty domain specified at line %d\n", v->lineno);
28458 } else {
28459 add_sip_domain(ast_strip(domain), SIP_DOMAIN_CONFIG, cntx ? ast_strip(cntx) : "");
28460 }
28461 } else if (!strcasecmp(v->name, "register")) {
28462 if (sip_register(v->value, v->lineno) == 0) {
28463 registry_count++;
28464 }
28465 } else if (!strcasecmp(v->name, "mwi")) {
28466 sip_subscribe_mwi(v->value, v->lineno);
28467 } else if (!strcasecmp(v->name, "tos_sip")) {
28468 if (ast_str2tos(v->value, &global_tos_sip)) {
28469 ast_log(LOG_WARNING, "Invalid tos_sip value at line %d, refer to QoS documentation\n", v->lineno);
28470 }
28471 } else if (!strcasecmp(v->name, "tos_audio")) {
28472 if (ast_str2tos(v->value, &global_tos_audio)) {
28473 ast_log(LOG_WARNING, "Invalid tos_audio value at line %d, refer to QoS documentation\n", v->lineno);
28474 }
28475 } else if (!strcasecmp(v->name, "tos_video")) {
28476 if (ast_str2tos(v->value, &global_tos_video)) {
28477 ast_log(LOG_WARNING, "Invalid tos_video value at line %d, refer to QoS documentation\n", v->lineno);
28478 }
28479 } else if (!strcasecmp(v->name, "tos_text")) {
28480 if (ast_str2tos(v->value, &global_tos_text)) {
28481 ast_log(LOG_WARNING, "Invalid tos_text value at line %d, refer to QoS documentation\n", v->lineno);
28482 }
28483 } else if (!strcasecmp(v->name, "cos_sip")) {
28484 if (ast_str2cos(v->value, &global_cos_sip)) {
28485 ast_log(LOG_WARNING, "Invalid cos_sip value at line %d, refer to QoS documentation\n", v->lineno);
28486 }
28487 } else if (!strcasecmp(v->name, "cos_audio")) {
28488 if (ast_str2cos(v->value, &global_cos_audio)) {
28489 ast_log(LOG_WARNING, "Invalid cos_audio value at line %d, refer to QoS documentation\n", v->lineno);
28490 }
28491 } else if (!strcasecmp(v->name, "cos_video")) {
28492 if (ast_str2cos(v->value, &global_cos_video)) {
28493 ast_log(LOG_WARNING, "Invalid cos_video value at line %d, refer to QoS documentation\n", v->lineno);
28494 }
28495 } else if (!strcasecmp(v->name, "cos_text")) {
28496 if (ast_str2cos(v->value, &global_cos_text)) {
28497 ast_log(LOG_WARNING, "Invalid cos_text value at line %d, refer to QoS documentation\n", v->lineno);
28498 }
28499 } else if (!strcasecmp(v->name, "bindport")) {
28500 if (sscanf(v->value, "%5d", &bindport) != 1) {
28501 ast_log(LOG_WARNING, "Invalid port number '%s' at line %d of %s\n", v->value, v->lineno, config);
28502 }
28503 } else if (!strcasecmp(v->name, "qualify")) {
28504 if (!strcasecmp(v->value, "no")) {
28505 default_qualify = 0;
28506 } else if (!strcasecmp(v->value, "yes")) {
28507 default_qualify = DEFAULT_MAXMS;
28508 } else if (sscanf(v->value, "%30d", &default_qualify) != 1) {
28509 ast_log(LOG_WARNING, "Qualification default should be 'yes', 'no', or a number of milliseconds at line %d of sip.conf\n", v->lineno);
28510 default_qualify = 0;
28511 }
28512 } else if (!strcasecmp(v->name, "qualifyfreq")) {
28513 int i;
28514 if (sscanf(v->value, "%30d", &i) == 1) {
28515 global_qualifyfreq = i * 1000;
28516 } else {
28517 ast_log(LOG_WARNING, "Invalid qualifyfreq number '%s' at line %d of %s\n", v->value, v->lineno, config);
28518 global_qualifyfreq = DEFAULT_QUALIFYFREQ;
28519 }
28520 } else if (!strcasecmp(v->name, "callevents")) {
28521 sip_cfg.callevents = ast_true(v->value);
28522 } else if (!strcasecmp(v->name, "authfailureevents")) {
28523 global_authfailureevents = ast_true(v->value);
28524 } else if (!strcasecmp(v->name, "maxcallbitrate")) {
28525 default_maxcallbitrate = atoi(v->value);
28526 if (default_maxcallbitrate < 0)
28527 default_maxcallbitrate = DEFAULT_MAX_CALL_BITRATE;
28528 } else if (!strcasecmp(v->name, "matchexternaddrlocally") || !strcasecmp(v->name, "matchexterniplocally")) {
28529 sip_cfg.matchexternaddrlocally = ast_true(v->value);
28530 } else if (!strcasecmp(v->name, "session-timers")) {
28531 int i = (int) str2stmode(v->value);
28532 if (i < 0) {
28533 ast_log(LOG_WARNING, "Invalid session-timers '%s' at line %d of %s\n", v->value, v->lineno, config);
28534 global_st_mode = SESSION_TIMER_MODE_ACCEPT;
28535 } else {
28536 global_st_mode = i;
28537 }
28538 } else if (!strcasecmp(v->name, "session-expires")) {
28539 if (sscanf(v->value, "%30d", &global_max_se) != 1) {
28540 ast_log(LOG_WARNING, "Invalid session-expires '%s' at line %d of %s\n", v->value, v->lineno, config);
28541 global_max_se = DEFAULT_MAX_SE;
28542 }
28543 } else if (!strcasecmp(v->name, "session-minse")) {
28544 if (sscanf(v->value, "%30d", &global_min_se) != 1) {
28545 ast_log(LOG_WARNING, "Invalid session-minse '%s' at line %d of %s\n", v->value, v->lineno, config);
28546 global_min_se = DEFAULT_MIN_SE;
28547 }
28548 if (global_min_se < 90) {
28549 ast_log(LOG_WARNING, "session-minse '%s' at line %d of %s is not allowed to be < 90 secs\n", v->value, v->lineno, config);
28550 global_min_se = DEFAULT_MIN_SE;
28551 }
28552 } else if (!strcasecmp(v->name, "session-refresher")) {
28553 int i = (int) str2strefresher(v->value);
28554 if (i < 0) {
28555 ast_log(LOG_WARNING, "Invalid session-refresher '%s' at line %d of %s\n", v->value, v->lineno, config);
28556 global_st_refresher = SESSION_TIMER_REFRESHER_UAS;
28557 } else {
28558 global_st_refresher = i;
28559 }
28560 } else if (!strcasecmp(v->name, "storesipcause")) {
28561 global_store_sip_cause = ast_true(v->value);
28562 } else if (!strcasecmp(v->name, "qualifygap")) {
28563 if (sscanf(v->value, "%30d", &global_qualify_gap) != 1) {
28564 ast_log(LOG_WARNING, "Invalid qualifygap '%s' at line %d of %s\n", v->value, v->lineno, config);
28565 global_qualify_gap = DEFAULT_QUALIFY_GAP;
28566 }
28567 } else if (!strcasecmp(v->name, "qualifypeers")) {
28568 if (sscanf(v->value, "%30d", &global_qualify_peers) != 1) {
28569 ast_log(LOG_WARNING, "Invalid pokepeers '%s' at line %d of %s\n", v->value, v->lineno, config);
28570 global_qualify_peers = DEFAULT_QUALIFY_PEERS;
28571 }
28572 } else if (!strcasecmp(v->name, "disallowed_methods")) {
28573 char *disallow = ast_strdupa(v->value);
28574 mark_parsed_methods(&sip_cfg.disallowed_methods, disallow);
28575 } else if (!strcasecmp(v->name, "shrinkcallerid")) {
28576 if (ast_true(v->value)) {
28577 global_shrinkcallerid = 1;
28578 } else if (ast_false(v->value)) {
28579 global_shrinkcallerid = 0;
28580 } else {
28581 ast_log(LOG_WARNING, "shrinkcallerid value %s is not valid at line %d.\n", v->value, v->lineno);
28582 }
28583 } else if (!strcasecmp(v->name, "use_q850_reason")) {
28584 ast_set2_flag(&global_flags[1], ast_true(v->value), SIP_PAGE2_Q850_REASON);
28585 } else if (!strcasecmp(v->name, "maxforwards")) {
28586 if ((sscanf(v->value, "%30d", &sip_cfg.default_max_forwards) != 1) || (sip_cfg.default_max_forwards < 1)) {
28587 ast_log(LOG_WARNING, "'%s' is not a valid maxforwards value at line %d. Using default.\n", v->value, v->lineno);
28588 sip_cfg.default_max_forwards = DEFAULT_MAX_FORWARDS;
28589 }
28590 } else if (!strcasecmp(v->name, "subscribe_network_change_event")) {
28591 if (ast_true(v->value)) {
28592 subscribe_network_change = 1;
28593 } else if (ast_false(v->value)) {
28594 subscribe_network_change = 0;
28595 } else {
28596 ast_log(LOG_WARNING, "subscribe_network_change_event value %s is not valid at line %d.\n", v->value, v->lineno);
28597 }
28598 } else if (!strcasecmp(v->name, "snom_aoc_enabled")) {
28599 ast_set2_flag(&global_flags[2], ast_true(v->value), SIP_PAGE3_SNOM_AOC);
28600 } else if (!strcasecmp(v->name, "parkinglot")) {
28601 ast_copy_string(default_parkinglot, v->value, sizeof(default_parkinglot));
28602 }
28603 }
28604
28605 if (subscribe_network_change) {
28606 network_change_event_subscribe();
28607 } else {
28608 network_change_event_unsubscribe();
28609 }
28610
28611 if (global_t1 < global_t1min) {
28612 ast_log(LOG_WARNING, "'t1min' (%d) cannot be greater than 't1timer' (%d). Resetting 't1timer' to the value of 't1min'\n", global_t1min, global_t1);
28613 global_t1 = global_t1min;
28614 }
28615
28616 if (global_timer_b < global_t1 * 64) {
28617 if (timerb_set && timert1_set) {
28618 ast_log(LOG_WARNING, "Timer B has been set lower than recommended (%d < 64 * timert1=%d). (RFC 3261, 17.1.1.2)\n", global_timer_b, global_t1);
28619 } else if (timerb_set) {
28620 if ((global_t1 = global_timer_b / 64) < global_t1min) {
28621 ast_log(LOG_WARNING, "Timer B has been set lower than recommended (%d < 64 * timert1=%d). (RFC 3261, 17.1.1.2)\n", global_timer_b, global_t1);
28622 global_t1 = global_t1min;
28623 global_timer_b = global_t1 * 64;
28624 }
28625 } else {
28626 global_timer_b = global_t1 * 64;
28627 }
28628 }
28629 if (!sip_cfg.allow_external_domains && AST_LIST_EMPTY(&domain_list)) {
28630 ast_log(LOG_WARNING, "To disallow external domains, you need to configure local SIP domains.\n");
28631 sip_cfg.allow_external_domains = 1;
28632 }
28633
28634 if (!sip_cfg.tcp_enabled && (default_transports & SIP_TRANSPORT_TCP)) {
28635 ast_log(LOG_WARNING, "Cannot use 'tcp' transport with tcpenable=no. Removing from available transports.\n");
28636 default_primary_transport &= ~SIP_TRANSPORT_TCP;
28637 default_transports &= ~SIP_TRANSPORT_TCP;
28638 }
28639 if (!default_tls_cfg.enabled && (default_transports & SIP_TRANSPORT_TLS)) {
28640 ast_log(LOG_WARNING, "Cannot use 'tls' transport with tlsenable=no. Removing from available transports.\n");
28641 default_primary_transport &= ~SIP_TRANSPORT_TLS;
28642 default_transports &= ~SIP_TRANSPORT_TLS;
28643 }
28644 if (!default_transports) {
28645 ast_log(LOG_WARNING, "No valid transports available, falling back to 'udp'.\n");
28646 default_transports = default_primary_transport = SIP_TRANSPORT_UDP;
28647 } else if (!default_primary_transport) {
28648 ast_log(LOG_WARNING, "No valid default transport. Selecting 'udp' as default.\n");
28649 default_primary_transport = SIP_TRANSPORT_UDP;
28650 }
28651
28652
28653 for (v = ast_variable_browse(cfg, "authentication"); v ; v = v->next) {
28654
28655 if (!strcasecmp(v->name, "auth")) {
28656 add_realm_authentication(&authl, v->value, v->lineno);
28657 }
28658 }
28659
28660 if (bindport) {
28661 if (ast_sockaddr_port(&bindaddr)) {
28662 ast_log(LOG_WARNING, "bindport is also specified in bindaddr. "
28663 "Using %d.\n", bindport);
28664 }
28665 ast_sockaddr_set_port(&bindaddr, bindport);
28666 }
28667
28668 if (!ast_sockaddr_port(&bindaddr)) {
28669 ast_sockaddr_set_port(&bindaddr, STANDARD_SIP_PORT);
28670 }
28671
28672
28673 ast_sockaddr_copy(&internip, &bindaddr);
28674 if (ast_find_ourip(&internip, &bindaddr, 0)) {
28675 ast_log(LOG_WARNING, "Unable to get own IP address, SIP disabled\n");
28676 ast_config_destroy(cfg);
28677 return 0;
28678 }
28679
28680 ast_mutex_lock(&netlock);
28681 if ((sipsock > -1) && (ast_sockaddr_cmp(&old_bindaddr, &bindaddr))) {
28682 close(sipsock);
28683 sipsock = -1;
28684 }
28685 if (sipsock < 0) {
28686 sipsock = socket(ast_sockaddr_is_ipv6(&bindaddr) ?
28687 AF_INET6 : AF_INET, SOCK_DGRAM, 0);
28688 if (sipsock < 0) {
28689 ast_log(LOG_WARNING, "Unable to create SIP socket: %s\n", strerror(errno));
28690 ast_config_destroy(cfg);
28691 ast_mutex_unlock(&netlock);
28692 return -1;
28693 } else {
28694
28695 const int reuseFlag = 1;
28696
28697 setsockopt(sipsock, SOL_SOCKET, SO_REUSEADDR,
28698 (const char*)&reuseFlag,
28699 sizeof reuseFlag);
28700
28701 ast_enable_packet_fragmentation(sipsock);
28702
28703 if (ast_bind(sipsock, &bindaddr) < 0) {
28704 ast_log(LOG_WARNING, "Failed to bind to %s: %s\n",
28705 ast_sockaddr_stringify(&bindaddr), strerror(errno));
28706 close(sipsock);
28707 sipsock = -1;
28708 } else {
28709 ast_verb(2, "SIP Listening on %s\n", ast_sockaddr_stringify(&bindaddr));
28710 ast_set_qos(sipsock, global_tos_sip, global_cos_sip, "SIP");
28711 }
28712 }
28713 } else {
28714 ast_set_qos(sipsock, global_tos_sip, global_cos_sip, "SIP");
28715 }
28716 ast_mutex_unlock(&netlock);
28717
28718
28719 if (sip_cfg.tcp_enabled) {
28720 if (ast_sockaddr_isnull(&sip_tcp_desc.local_address)) {
28721 ast_sockaddr_copy(&sip_tcp_desc.local_address, &bindaddr);
28722 }
28723 if (!ast_sockaddr_port(&sip_tcp_desc.local_address)) {
28724 ast_sockaddr_set_port(&sip_tcp_desc.local_address, STANDARD_SIP_PORT);
28725 }
28726 } else {
28727 ast_sockaddr_setnull(&sip_tcp_desc.local_address);
28728 }
28729 ast_tcptls_server_start(&sip_tcp_desc);
28730 if (sip_cfg.tcp_enabled && sip_tcp_desc.accept_fd == -1) {
28731
28732 ast_log(LOG_ERROR, "SIP TCP Server start failed. Not listening on TCP socket.\n");
28733 } else {
28734 ast_debug(2, "SIP TCP server started\n");
28735 }
28736
28737
28738 memcpy(sip_tls_desc.tls_cfg, &default_tls_cfg, sizeof(default_tls_cfg));
28739
28740 if (ast_ssl_setup(sip_tls_desc.tls_cfg)) {
28741 if (ast_sockaddr_isnull(&sip_tls_desc.local_address)) {
28742 ast_sockaddr_copy(&sip_tls_desc.local_address, &bindaddr);
28743 ast_sockaddr_set_port(&sip_tls_desc.local_address,
28744 STANDARD_TLS_PORT);
28745 }
28746 if (!ast_sockaddr_port(&sip_tls_desc.local_address)) {
28747 ast_sockaddr_set_port(&sip_tls_desc.local_address,
28748 STANDARD_TLS_PORT);
28749 }
28750 ast_tcptls_server_start(&sip_tls_desc);
28751 if (default_tls_cfg.enabled && sip_tls_desc.accept_fd == -1) {
28752 ast_log(LOG_ERROR, "TLS Server start failed. Not listening on TLS socket.\n");
28753 sip_tls_desc.tls_cfg = NULL;
28754 }
28755 } else if (sip_tls_desc.tls_cfg->enabled) {
28756 sip_tls_desc.tls_cfg = NULL;
28757 ast_log(LOG_WARNING, "SIP TLS server did not load because of errors.\n");
28758 }
28759
28760 if (ucfg) {
28761 struct ast_variable *gen;
28762 int genhassip, genregistersip;
28763 const char *hassip, *registersip;
28764
28765 genhassip = ast_true(ast_variable_retrieve(ucfg, "general", "hassip"));
28766 genregistersip = ast_true(ast_variable_retrieve(ucfg, "general", "registersip"));
28767 gen = ast_variable_browse(ucfg, "general");
28768 cat = ast_category_browse(ucfg, NULL);
28769 while (cat) {
28770 if (strcasecmp(cat, "general")) {
28771 hassip = ast_variable_retrieve(ucfg, cat, "hassip");
28772 registersip = ast_variable_retrieve(ucfg, cat, "registersip");
28773 if (ast_true(hassip) || (!hassip && genhassip)) {
28774 peer = build_peer(cat, gen, ast_variable_browse(ucfg, cat), 0, 0);
28775 if (peer) {
28776
28777 peer->type = SIP_TYPE_USER | SIP_TYPE_PEER;
28778 ao2_t_link(peers, peer, "link peer into peer table");
28779 if ((peer->type & SIP_TYPE_PEER) && !ast_sockaddr_isnull(&peer->addr)) {
28780 ao2_t_link(peers_by_ip, peer, "link peer into peers_by_ip table");
28781 }
28782
28783 unref_peer(peer, "unref_peer: from reload_config");
28784 peer_count++;
28785 }
28786 }
28787 if (ast_true(registersip) || (!registersip && genregistersip)) {
28788 char tmp[256];
28789 const char *host = ast_variable_retrieve(ucfg, cat, "host");
28790 const char *username = ast_variable_retrieve(ucfg, cat, "username");
28791 const char *secret = ast_variable_retrieve(ucfg, cat, "secret");
28792 const char *contact = ast_variable_retrieve(ucfg, cat, "contact");
28793 const char *authuser = ast_variable_retrieve(ucfg, cat, "authuser");
28794 if (!host) {
28795 host = ast_variable_retrieve(ucfg, "general", "host");
28796 }
28797 if (!username) {
28798 username = ast_variable_retrieve(ucfg, "general", "username");
28799 }
28800 if (!secret) {
28801 secret = ast_variable_retrieve(ucfg, "general", "secret");
28802 }
28803 if (!contact) {
28804 contact = "s";
28805 }
28806 if (!ast_strlen_zero(username) && !ast_strlen_zero(host)) {
28807 if (!ast_strlen_zero(secret)) {
28808 if (!ast_strlen_zero(authuser)) {
28809 snprintf(tmp, sizeof(tmp), "%s?%s:%s:%s@%s/%s", cat, username, secret, authuser, host, contact);
28810 } else {
28811 snprintf(tmp, sizeof(tmp), "%s?%s:%s@%s/%s", cat, username, secret, host, contact);
28812 }
28813 } else if (!ast_strlen_zero(authuser)) {
28814 snprintf(tmp, sizeof(tmp), "%s?%s::%s@%s/%s", cat, username, authuser, host, contact);
28815 } else {
28816 snprintf(tmp, sizeof(tmp), "%s?%s@%s/%s", cat, username, host, contact);
28817 }
28818 if (sip_register(tmp, 0) == 0) {
28819 registry_count++;
28820 }
28821 }
28822 }
28823 }
28824 cat = ast_category_browse(ucfg, cat);
28825 }
28826 ast_config_destroy(ucfg);
28827 }
28828
28829
28830 cat = NULL;
28831 while ( (cat = ast_category_browse(cfg, cat)) ) {
28832 const char *utype;
28833 if (!strcasecmp(cat, "general") || !strcasecmp(cat, "authentication"))
28834 continue;
28835 utype = ast_variable_retrieve(cfg, cat, "type");
28836 if (!utype) {
28837 ast_log(LOG_WARNING, "Section '%s' lacks type\n", cat);
28838 continue;
28839 } else {
28840 if (!strcasecmp(utype, "user")) {
28841 ;
28842 } else if (!strcasecmp(utype, "friend")) {
28843 ;
28844 } else if (!strcasecmp(utype, "peer")) {
28845 ;
28846 } else {
28847 ast_log(LOG_WARNING, "Unknown type '%s' for '%s' in %s\n", utype, cat, "sip.conf");
28848 continue;
28849 }
28850 peer = build_peer(cat, ast_variable_browse(cfg, cat), NULL, 0, 0);
28851 if (peer) {
28852 display_nat_warning(cat, reason, &peer->flags[0]);
28853 ao2_t_link(peers, peer, "link peer into peers table");
28854 if ((peer->type & SIP_TYPE_PEER) && !ast_sockaddr_isnull(&peer->addr)) {
28855 ao2_t_link(peers_by_ip, peer, "link peer into peers_by_ip table");
28856 }
28857 unref_peer(peer, "unref the result of the build_peer call. Now, the links from the tables are the only ones left.");
28858 peer_count++;
28859 }
28860 }
28861 }
28862
28863
28864
28865
28866
28867
28868 if (auto_sip_domains) {
28869 char temp[MAXHOSTNAMELEN];
28870
28871
28872 if (!ast_sockaddr_isnull(&bindaddr) && !ast_sockaddr_is_any(&bindaddr)) {
28873 add_sip_domain(ast_sockaddr_stringify_addr(&bindaddr),
28874 SIP_DOMAIN_AUTO, NULL);
28875 } else if (!ast_sockaddr_isnull(&internip) && !ast_sockaddr_is_any(&internip)) {
28876
28877 add_sip_domain(ast_sockaddr_stringify_addr(&internip),
28878 SIP_DOMAIN_AUTO, NULL);
28879 } else {
28880 ast_log(LOG_NOTICE, "Can't add wildcard IP address to domain list, please add IP address to domain manually.\n");
28881 }
28882
28883
28884 if (!ast_sockaddr_isnull(&sip_tcp_desc.local_address) &&
28885 !ast_sockaddr_cmp(&bindaddr, &sip_tcp_desc.local_address)) {
28886 add_sip_domain(ast_sockaddr_stringify_addr(&sip_tcp_desc.local_address),
28887 SIP_DOMAIN_AUTO, NULL);
28888 }
28889
28890
28891 if (!ast_sockaddr_isnull(&sip_tls_desc.local_address) &&
28892 !ast_sockaddr_cmp(&bindaddr, &sip_tls_desc.local_address) &&
28893 !ast_sockaddr_cmp(&sip_tcp_desc.local_address,
28894 &sip_tls_desc.local_address)) {
28895 add_sip_domain(ast_sockaddr_stringify_addr(&sip_tcp_desc.local_address),
28896 SIP_DOMAIN_AUTO, NULL);
28897 }
28898
28899
28900 if (!ast_sockaddr_isnull(&externaddr)) {
28901 add_sip_domain(ast_sockaddr_stringify_addr(&externaddr),
28902 SIP_DOMAIN_AUTO, NULL);
28903 }
28904
28905
28906 if (!ast_strlen_zero(externhost)) {
28907 add_sip_domain(externhost, SIP_DOMAIN_AUTO, NULL);
28908 }
28909
28910
28911 if (!gethostname(temp, sizeof(temp))) {
28912 add_sip_domain(temp, SIP_DOMAIN_AUTO, NULL);
28913 }
28914 }
28915
28916
28917 ast_config_destroy(cfg);
28918
28919
28920 if (notify_types)
28921 ast_config_destroy(notify_types);
28922 if ((notify_types = ast_config_load(notify_config, config_flags)) == CONFIG_STATUS_FILEINVALID) {
28923 ast_log(LOG_ERROR, "Contents of %s are invalid and cannot be parsed.\n", notify_config);
28924 notify_types = NULL;
28925 }
28926
28927
28928 manager_event(EVENT_FLAG_SYSTEM, "ChannelReload", "ChannelType: SIP\r\nReloadReason: %s\r\nRegistry_Count: %d\r\nPeer_Count: %d\r\n", channelreloadreason2txt(reason), registry_count, peer_count);
28929 run_end = time(0);
28930 ast_debug(4, "SIP reload_config done...Runtime= %d sec\n", (int)(run_end-run_start));
28931
28932 return 0;
28933 }
28934
28935 static int apply_directmedia_ha(struct sip_pvt *p, const char *op)
28936 {
28937 struct ast_sockaddr us = { { 0, }, }, them = { { 0, }, };
28938 int res = AST_SENSE_ALLOW;
28939
28940 ast_rtp_instance_get_remote_address(p->rtp, &them);
28941 ast_rtp_instance_get_local_address(p->rtp, &us);
28942
28943 if ((res = ast_apply_ha(p->directmediaha, &them)) == AST_SENSE_DENY) {
28944 const char *us_addr = ast_strdupa(ast_sockaddr_stringify(&us));
28945 const char *them_addr = ast_strdupa(ast_sockaddr_stringify(&them));
28946
28947 ast_debug(3, "Reinvite %s to %s denied by directmedia ACL on %s\n",
28948 op, them_addr, us_addr);
28949 }
28950
28951 return res;
28952 }
28953
28954 static struct ast_udptl *sip_get_udptl_peer(struct ast_channel *chan)
28955 {
28956 struct sip_pvt *p;
28957 struct ast_udptl *udptl = NULL;
28958
28959 p = chan->tech_pvt;
28960 if (!p) {
28961 return NULL;
28962 }
28963
28964 sip_pvt_lock(p);
28965 if (p->udptl && ast_test_flag(&p->flags[0], SIP_DIRECT_MEDIA)) {
28966 if (apply_directmedia_ha(p, "UDPTL T.38 data")) {
28967 udptl = p->udptl;
28968 }
28969 }
28970 sip_pvt_unlock(p);
28971 return udptl;
28972 }
28973
28974 static int sip_set_udptl_peer(struct ast_channel *chan, struct ast_udptl *udptl)
28975 {
28976 struct sip_pvt *p;
28977
28978
28979 ast_channel_lock(chan);
28980 p = chan->tech_pvt;
28981 if (!p) {
28982 ast_channel_unlock(chan);
28983 return -1;
28984 }
28985 sip_pvt_lock(p);
28986 if (p->owner != chan) {
28987
28988 ast_debug(1, "The private is not owned by channel %s anymore.\n", chan->name);
28989 sip_pvt_unlock(p);
28990 ast_channel_unlock(chan);
28991 return 0;
28992 }
28993
28994 if (udptl) {
28995 ast_udptl_get_peer(udptl, &p->udptlredirip);
28996 } else {
28997 memset(&p->udptlredirip, 0, sizeof(p->udptlredirip));
28998 }
28999 if (!ast_test_flag(&p->flags[0], SIP_GOTREFER)) {
29000 if (!p->pendinginvite) {
29001 ast_debug(3, "Sending reinvite on SIP '%s' - It's UDPTL soon redirected to IP %s\n",
29002 p->callid, ast_sockaddr_stringify(udptl ? &p->udptlredirip : &p->ourip));
29003 transmit_reinvite_with_sdp(p, TRUE, FALSE);
29004 } else if (!ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
29005 ast_debug(3, "Deferring reinvite on SIP '%s' - It's UDPTL will be redirected to IP %s\n",
29006 p->callid, ast_sockaddr_stringify(udptl ? &p->udptlredirip : &p->ourip));
29007 ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
29008 }
29009 }
29010
29011 p->lastrtprx = p->lastrtptx = time(NULL);
29012 sip_pvt_unlock(p);
29013 ast_channel_unlock(chan);
29014 return 0;
29015 }
29016
29017 static enum ast_rtp_glue_result sip_get_rtp_peer(struct ast_channel *chan, struct ast_rtp_instance **instance)
29018 {
29019 struct sip_pvt *p = NULL;
29020 enum ast_rtp_glue_result res = AST_RTP_GLUE_RESULT_LOCAL;
29021
29022 if (!(p = chan->tech_pvt)) {
29023 return AST_RTP_GLUE_RESULT_FORBID;
29024 }
29025
29026 sip_pvt_lock(p);
29027 if (!(p->rtp)) {
29028 sip_pvt_unlock(p);
29029 return AST_RTP_GLUE_RESULT_FORBID;
29030 }
29031
29032 ao2_ref(p->rtp, +1);
29033 *instance = p->rtp;
29034
29035 if (ast_test_flag(&p->flags[0], SIP_DIRECT_MEDIA)) {
29036 res = AST_RTP_GLUE_RESULT_REMOTE;
29037 if (!apply_directmedia_ha(p, "audio")) {
29038 res = AST_RTP_GLUE_RESULT_FORBID;
29039 }
29040 } else if (ast_test_flag(&p->flags[0], SIP_DIRECT_MEDIA_NAT)) {
29041 res = AST_RTP_GLUE_RESULT_REMOTE;
29042 } else if (ast_test_flag(&global_jbconf, AST_JB_FORCED)) {
29043 res = AST_RTP_GLUE_RESULT_FORBID;
29044 }
29045
29046 if (p->srtp) {
29047 res = AST_RTP_GLUE_RESULT_FORBID;
29048 }
29049
29050 sip_pvt_unlock(p);
29051
29052 return res;
29053 }
29054
29055 static enum ast_rtp_glue_result sip_get_vrtp_peer(struct ast_channel *chan, struct ast_rtp_instance **instance)
29056 {
29057 struct sip_pvt *p = NULL;
29058 enum ast_rtp_glue_result res = AST_RTP_GLUE_RESULT_FORBID;
29059
29060 if (!(p = chan->tech_pvt)) {
29061 return AST_RTP_GLUE_RESULT_FORBID;
29062 }
29063
29064 sip_pvt_lock(p);
29065 if (!(p->vrtp)) {
29066 sip_pvt_unlock(p);
29067 return AST_RTP_GLUE_RESULT_FORBID;
29068 }
29069
29070 ao2_ref(p->vrtp, +1);
29071 *instance = p->vrtp;
29072
29073 if (ast_test_flag(&p->flags[0], SIP_DIRECT_MEDIA)) {
29074 res = AST_RTP_GLUE_RESULT_REMOTE;
29075 if (!apply_directmedia_ha(p, "video")) {
29076 res = AST_RTP_GLUE_RESULT_FORBID;
29077 }
29078 }
29079
29080 sip_pvt_unlock(p);
29081
29082 return res;
29083 }
29084
29085 static enum ast_rtp_glue_result sip_get_trtp_peer(struct ast_channel *chan, struct ast_rtp_instance **instance)
29086 {
29087 struct sip_pvt *p = NULL;
29088 enum ast_rtp_glue_result res = AST_RTP_GLUE_RESULT_FORBID;
29089
29090 if (!(p = chan->tech_pvt)) {
29091 return AST_RTP_GLUE_RESULT_FORBID;
29092 }
29093
29094 sip_pvt_lock(p);
29095 if (!(p->trtp)) {
29096 sip_pvt_unlock(p);
29097 return AST_RTP_GLUE_RESULT_FORBID;
29098 }
29099
29100 ao2_ref(p->trtp, +1);
29101 *instance = p->trtp;
29102
29103 if (ast_test_flag(&p->flags[0], SIP_DIRECT_MEDIA)) {
29104 res = AST_RTP_GLUE_RESULT_REMOTE;
29105 if (!apply_directmedia_ha(p, "text")) {
29106 res = AST_RTP_GLUE_RESULT_FORBID;
29107 }
29108 }
29109
29110 sip_pvt_unlock(p);
29111
29112 return res;
29113 }
29114
29115 static int sip_set_rtp_peer(struct ast_channel *chan, struct ast_rtp_instance *instance, struct ast_rtp_instance *vinstance, struct ast_rtp_instance *tinstance, format_t codecs, int nat_active)
29116 {
29117 struct sip_pvt *p;
29118 int changed = 0;
29119
29120
29121 ast_channel_lock(chan);
29122 p = chan->tech_pvt;
29123 if (!p) {
29124 ast_channel_unlock(chan);
29125 return -1;
29126 }
29127 sip_pvt_lock(p);
29128 if (p->owner != chan) {
29129
29130 ast_debug(1, "The private is not owned by channel %s anymore.\n", chan->name);
29131 sip_pvt_unlock(p);
29132 ast_channel_unlock(chan);
29133 return 0;
29134 }
29135
29136
29137 if ((instance || vinstance || tinstance) &&
29138 !ast_bridged_channel(chan) &&
29139 !sip_cfg.directrtpsetup) {
29140 sip_pvt_unlock(p);
29141 ast_channel_unlock(chan);
29142 return 0;
29143 }
29144
29145 if (p->alreadygone) {
29146
29147 sip_pvt_unlock(p);
29148 ast_channel_unlock(chan);
29149 return 0;
29150 }
29151
29152
29153
29154
29155 if (nat_active && !ast_test_flag(&p->flags[0], SIP_DIRECT_MEDIA_NAT)) {
29156 sip_pvt_unlock(p);
29157 ast_channel_unlock(chan);
29158 return 0;
29159 }
29160
29161 if (instance) {
29162 changed |= ast_rtp_instance_get_and_cmp_remote_address(instance, &p->redirip);
29163 } else if (!ast_sockaddr_isnull(&p->redirip)) {
29164 memset(&p->redirip, 0, sizeof(p->redirip));
29165 changed = 1;
29166 }
29167 if (vinstance) {
29168 changed |= ast_rtp_instance_get_and_cmp_remote_address(vinstance, &p->vredirip);
29169 } else if (!ast_sockaddr_isnull(&p->vredirip)) {
29170 memset(&p->vredirip, 0, sizeof(p->vredirip));
29171 changed = 1;
29172 }
29173 if (tinstance) {
29174 changed |= ast_rtp_instance_get_and_cmp_remote_address(tinstance, &p->tredirip);
29175 } else if (!ast_sockaddr_isnull(&p->tredirip)) {
29176 memset(&p->tredirip, 0, sizeof(p->tredirip));
29177 changed = 1;
29178 }
29179 if (codecs && (p->redircodecs != codecs)) {
29180 p->redircodecs = codecs;
29181 changed = 1;
29182 }
29183 if (changed && !ast_test_flag(&p->flags[0], SIP_GOTREFER) && !ast_test_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER)) {
29184 if (chan->_state != AST_STATE_UP) {
29185 if (p->do_history)
29186 append_history(p, "ExtInv", "Initial invite sent with remote bridge proposal.");
29187 ast_debug(1, "Early remote bridge setting SIP '%s' - Sending media to %s\n", p->callid, ast_sockaddr_stringify(instance ? &p->redirip : &p->ourip));
29188 } else if (!p->pendinginvite) {
29189 ast_debug(3, "Sending reinvite on SIP '%s' - It's audio soon redirected to IP %s\n", p->callid, ast_sockaddr_stringify(instance ? &p->redirip : &p->ourip));
29190 transmit_reinvite_with_sdp(p, FALSE, FALSE);
29191 } else if (!ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
29192 ast_debug(3, "Deferring reinvite on SIP '%s' - It's audio will be redirected to IP %s\n", p->callid, ast_sockaddr_stringify(instance ? &p->redirip : &p->ourip));
29193
29194 ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
29195 }
29196 }
29197
29198 p->lastrtprx = p->lastrtptx = time(NULL);
29199 sip_pvt_unlock(p);
29200 ast_channel_unlock(chan);
29201 return 0;
29202 }
29203
29204 static format_t sip_get_codec(struct ast_channel *chan)
29205 {
29206 struct sip_pvt *p = chan->tech_pvt;
29207 return p->peercapability ? p->peercapability : p->capability;
29208 }
29209
29210 static struct ast_rtp_glue sip_rtp_glue = {
29211 .type = "SIP",
29212 .get_rtp_info = sip_get_rtp_peer,
29213 .get_vrtp_info = sip_get_vrtp_peer,
29214 .get_trtp_info = sip_get_trtp_peer,
29215 .update_peer = sip_set_rtp_peer,
29216 .get_codec = sip_get_codec,
29217 };
29218
29219 static char *app_dtmfmode = "SIPDtmfMode";
29220 static char *app_sipaddheader = "SIPAddHeader";
29221 static char *app_sipremoveheader = "SIPRemoveHeader";
29222
29223
29224 static int sip_dtmfmode(struct ast_channel *chan, const char *data)
29225 {
29226 struct sip_pvt *p;
29227 const char *mode = data;
29228
29229 if (!data) {
29230 ast_log(LOG_WARNING, "This application requires the argument: info, inband, rfc2833\n");
29231 return 0;
29232 }
29233 ast_channel_lock(chan);
29234 if (!IS_SIP_TECH(chan->tech)) {
29235 ast_log(LOG_WARNING, "Call this application only on SIP incoming calls\n");
29236 ast_channel_unlock(chan);
29237 return 0;
29238 }
29239 p = chan->tech_pvt;
29240 if (!p) {
29241 ast_channel_unlock(chan);
29242 return 0;
29243 }
29244 sip_pvt_lock(p);
29245 if (!strcasecmp(mode, "info")) {
29246 ast_clear_flag(&p->flags[0], SIP_DTMF);
29247 ast_set_flag(&p->flags[0], SIP_DTMF_INFO);
29248 p->jointnoncodeccapability &= ~AST_RTP_DTMF;
29249 } else if (!strcasecmp(mode, "shortinfo")) {
29250 ast_clear_flag(&p->flags[0], SIP_DTMF);
29251 ast_set_flag(&p->flags[0], SIP_DTMF_SHORTINFO);
29252 p->jointnoncodeccapability &= ~AST_RTP_DTMF;
29253 } else if (!strcasecmp(mode, "rfc2833")) {
29254 ast_clear_flag(&p->flags[0], SIP_DTMF);
29255 ast_set_flag(&p->flags[0], SIP_DTMF_RFC2833);
29256 p->jointnoncodeccapability |= AST_RTP_DTMF;
29257 } else if (!strcasecmp(mode, "inband")) {
29258 ast_clear_flag(&p->flags[0], SIP_DTMF);
29259 ast_set_flag(&p->flags[0], SIP_DTMF_INBAND);
29260 p->jointnoncodeccapability &= ~AST_RTP_DTMF;
29261 } else {
29262 ast_log(LOG_WARNING, "I don't know about this dtmf mode: %s\n", mode);
29263 }
29264 if (p->rtp)
29265 ast_rtp_instance_set_prop(p->rtp, AST_RTP_PROPERTY_DTMF, ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833);
29266 if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_INBAND) ||
29267 (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO)) {
29268 enable_dsp_detect(p);
29269 } else {
29270 disable_dsp_detect(p);
29271 }
29272 sip_pvt_unlock(p);
29273 ast_channel_unlock(chan);
29274 return 0;
29275 }
29276
29277
29278 static int sip_addheader(struct ast_channel *chan, const char *data)
29279 {
29280 int no = 0;
29281 int ok = FALSE;
29282 char varbuf[30];
29283 const char *inbuf = data;
29284 char *subbuf;
29285
29286 if (ast_strlen_zero(inbuf)) {
29287 ast_log(LOG_WARNING, "This application requires the argument: Header\n");
29288 return 0;
29289 }
29290 ast_channel_lock(chan);
29291
29292
29293 while (!ok && no <= 50) {
29294 no++;
29295 snprintf(varbuf, sizeof(varbuf), "__SIPADDHEADER%.2d", no);
29296
29297
29298 if ((pbx_builtin_getvar_helper(chan, (const char *) varbuf + 2) == (const char *) NULL)) {
29299 ok = TRUE;
29300 }
29301 }
29302 if (ok) {
29303 size_t len = strlen(inbuf);
29304 subbuf = alloca(len + 1);
29305 ast_get_encoded_str(inbuf, subbuf, len + 1);
29306 pbx_builtin_setvar_helper(chan, varbuf, subbuf);
29307 if (sipdebug) {
29308 ast_debug(1, "SIP Header added \"%s\" as %s\n", inbuf, varbuf);
29309 }
29310 } else {
29311 ast_log(LOG_WARNING, "Too many SIP headers added, max 50\n");
29312 }
29313 ast_channel_unlock(chan);
29314 return 0;
29315 }
29316
29317
29318 static int sip_removeheader(struct ast_channel *chan, const char *data)
29319 {
29320 struct ast_var_t *newvariable;
29321 struct varshead *headp;
29322 int removeall = 0;
29323 char *inbuf = (char *) data;
29324
29325 if (ast_strlen_zero(inbuf)) {
29326 removeall = 1;
29327 }
29328 ast_channel_lock(chan);
29329
29330 headp=&chan->varshead;
29331 AST_LIST_TRAVERSE_SAFE_BEGIN (headp, newvariable, entries) {
29332 if (strncasecmp(ast_var_name(newvariable), "SIPADDHEADER", strlen("SIPADDHEADER")) == 0) {
29333 if (removeall || (!strncasecmp(ast_var_value(newvariable),inbuf,strlen(inbuf)))) {
29334 if (sipdebug)
29335 ast_debug(1,"removing SIP Header \"%s\" as %s\n",
29336 ast_var_value(newvariable),
29337 ast_var_name(newvariable));
29338 AST_LIST_REMOVE_CURRENT(entries);
29339 ast_var_delete(newvariable);
29340 }
29341 }
29342 }
29343 AST_LIST_TRAVERSE_SAFE_END;
29344
29345 ast_channel_unlock(chan);
29346 return 0;
29347 }
29348
29349
29350
29351
29352
29353
29354
29355 static int sip_sipredirect(struct sip_pvt *p, const char *dest)
29356 {
29357 char *cdest;
29358 char *extension, *domain;
29359
29360 cdest = ast_strdupa(dest);
29361
29362 extension = strsep(&cdest, "@");
29363 domain = strsep(&cdest, ":");
29364 if (ast_strlen_zero(extension)) {
29365 ast_log(LOG_ERROR, "Missing mandatory argument: extension\n");
29366 return 0;
29367 }
29368
29369
29370 if (!domain) {
29371 char *local_to_header;
29372 char to_header[256];
29373
29374 ast_copy_string(to_header, get_header(&p->initreq, "To"), sizeof(to_header));
29375 if (ast_strlen_zero(to_header)) {
29376 ast_log(LOG_ERROR, "Cannot retrieve the 'To' header from the original SIP request!\n");
29377 return 0;
29378 }
29379 if (((local_to_header = strcasestr(to_header, "sip:")) || (local_to_header = strcasestr(to_header, "sips:")))
29380 && (local_to_header = strchr(local_to_header, '@'))) {
29381 char ldomain[256];
29382
29383 memset(ldomain, 0, sizeof(ldomain));
29384 local_to_header++;
29385
29386 sscanf(local_to_header, "%256[^<>; ]", ldomain);
29387 if (ast_strlen_zero(ldomain)) {
29388 ast_log(LOG_ERROR, "Can't find the host address\n");
29389 return 0;
29390 }
29391 domain = ast_strdupa(ldomain);
29392 }
29393 }
29394
29395 ast_string_field_build(p, our_contact, "Transfer <sip:%s@%s>", extension, domain);
29396 transmit_response_reliable(p, "302 Moved Temporarily", &p->initreq);
29397
29398 sip_scheddestroy(p, SIP_TRANS_TIMEOUT);
29399 sip_alreadygone(p);
29400
29401 if (p->owner) {
29402 enum ast_control_transfer message = AST_TRANSFER_SUCCESS;
29403 ast_queue_control_data(p->owner, AST_CONTROL_TRANSFER, &message, sizeof(message));
29404 }
29405
29406 return 0;
29407 }
29408
29409 static int sip_is_xml_parsable(void)
29410 {
29411 #ifdef HAVE_LIBXML2
29412 return TRUE;
29413 #else
29414 return FALSE;
29415 #endif
29416 }
29417
29418
29419 static void sip_poke_all_peers(void)
29420 {
29421 int ms = 0, num = 0;
29422 struct ao2_iterator i;
29423 struct sip_peer *peer;
29424
29425 if (!speerobjs) {
29426 return;
29427 }
29428
29429 i = ao2_iterator_init(peers, 0);
29430 while ((peer = ao2_t_iterator_next(&i, "iterate thru peers table"))) {
29431 ao2_lock(peer);
29432 if (num == global_qualify_peers) {
29433 ms += global_qualify_gap;
29434 num = 0;
29435 } else {
29436 num++;
29437 }
29438 AST_SCHED_REPLACE_UNREF(peer->pokeexpire, sched, ms, sip_poke_peer_s, peer,
29439 unref_peer(_data, "removing poke peer ref"),
29440 unref_peer(peer, "removing poke peer ref"),
29441 ref_peer(peer, "adding poke peer ref"));
29442 ao2_unlock(peer);
29443 unref_peer(peer, "toss iterator peer ptr");
29444 }
29445 ao2_iterator_destroy(&i);
29446 }
29447
29448
29449 static void sip_send_all_registers(void)
29450 {
29451 int ms;
29452 int regspacing;
29453 if (!regobjs)
29454 return;
29455 regspacing = default_expiry * 1000/regobjs;
29456 if (regspacing > 100) {
29457 regspacing = 100;
29458 }
29459 ms = regspacing;
29460 ASTOBJ_CONTAINER_TRAVERSE(®l, 1, do {
29461 ASTOBJ_WRLOCK(iterator);
29462 ms += regspacing;
29463 AST_SCHED_REPLACE_UNREF(iterator->expire, sched, ms, sip_reregister, iterator,
29464 registry_unref(_data, "REPLACE sched del decs the refcount"),
29465 registry_unref(iterator, "REPLACE sched add failure decs the refcount"),
29466 registry_addref(iterator, "REPLACE sched add incs the refcount"));
29467 ASTOBJ_UNLOCK(iterator);
29468 } while (0)
29469 );
29470 }
29471
29472
29473 static void sip_send_all_mwi_subscriptions(void)
29474 {
29475 ASTOBJ_CONTAINER_TRAVERSE(&submwil, 1, do {
29476 ASTOBJ_WRLOCK(iterator);
29477 AST_SCHED_DEL(sched, iterator->resub);
29478 if ((iterator->resub = ast_sched_add(sched, 1, sip_subscribe_mwi_do, ASTOBJ_REF(iterator))) < 0) {
29479 ASTOBJ_UNREF(iterator, sip_subscribe_mwi_destroy);
29480 }
29481 ASTOBJ_UNLOCK(iterator);
29482 } while (0));
29483 }
29484
29485
29486 static int setup_srtp(struct sip_srtp **srtp)
29487 {
29488 if (!ast_rtp_engine_srtp_is_registered()) {
29489 ast_log(LOG_ERROR, "No SRTP module loaded, can't setup SRTP session.\n");
29490 return -1;
29491 }
29492
29493 if (!(*srtp = sip_srtp_alloc())) {
29494 return -1;
29495 }
29496
29497 return 0;
29498 }
29499
29500 static int process_crypto(struct sip_pvt *p, struct ast_rtp_instance *rtp, struct sip_srtp **srtp, const char *a)
29501 {
29502
29503 if (!rtp) {
29504 ast_debug(3, "Received offer with crypto line for media stream that is not enabled\n");
29505 return FALSE;
29506 }
29507
29508 if (strncasecmp(a, "crypto:", 7)) {
29509 return FALSE;
29510 }
29511 if (!*srtp) {
29512 if (ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
29513 ast_log(LOG_WARNING, "Ignoring unexpected crypto attribute in SDP answer\n");
29514 return FALSE;
29515 }
29516
29517 if (setup_srtp(srtp) < 0) {
29518 return FALSE;
29519 }
29520 }
29521
29522
29523 if ((*srtp)->crypto && !ast_test_flag(&p->flags[0], SIP_OUTGOING)) {
29524 ast_debug(3, "We've already processed a crypto attribute, skipping '%s'\n", a);
29525 return FALSE;
29526 }
29527
29528 if (!(*srtp)->crypto && !((*srtp)->crypto = sdp_crypto_setup())) {
29529 return FALSE;
29530 }
29531
29532 if (sdp_crypto_process((*srtp)->crypto, a, rtp) < 0) {
29533 return FALSE;
29534 }
29535
29536 ast_set_flag(*srtp, SRTP_CRYPTO_OFFER_OK);
29537
29538 return TRUE;
29539 }
29540
29541
29542 static int sip_do_reload(enum channelreloadreason reason)
29543 {
29544 time_t start_poke, end_poke;
29545
29546 reload_config(reason);
29547 ast_sched_dump(sched);
29548
29549 start_poke = time(0);
29550
29551 unlink_marked_peers_from_tables();
29552
29553 ast_debug(4, "--------------- Done destroying pruned peers\n");
29554
29555
29556 sip_poke_all_peers();
29557
29558
29559 sip_send_all_registers();
29560
29561 sip_send_all_mwi_subscriptions();
29562
29563 end_poke = time(0);
29564
29565 ast_debug(4, "do_reload finished. peer poke/prune reg contact time = %d sec.\n", (int)(end_poke-start_poke));
29566
29567 ast_debug(4, "--------------- SIP reload done\n");
29568
29569 return 0;
29570 }
29571
29572
29573 static char *sip_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
29574 {
29575
29576 switch (cmd) {
29577 case CLI_INIT:
29578 e->command = "sip reload";
29579 e->usage =
29580 "Usage: sip reload\n"
29581 " Reloads SIP configuration from sip.conf\n";
29582 return NULL;
29583 case CLI_GENERATE:
29584 return NULL;
29585 }
29586
29587 ast_mutex_lock(&sip_reload_lock);
29588 if (sip_reloading) {
29589 ast_verbose("Previous SIP reload not yet done\n");
29590 } else {
29591 sip_reloading = TRUE;
29592 sip_reloadreason = (a && a->fd) ? CHANNEL_CLI_RELOAD : CHANNEL_MODULE_RELOAD;
29593 }
29594 ast_mutex_unlock(&sip_reload_lock);
29595 restart_monitor();
29596
29597 return CLI_SUCCESS;
29598 }
29599
29600
29601 static int reload(void)
29602 {
29603 if (sip_reload(0, 0, NULL))
29604 return 0;
29605 return 1;
29606 }
29607
29608
29609
29610
29611
29612 static int ast_sockaddr_resolve_first_af(struct ast_sockaddr *addr,
29613 const char* name, int flag, int family)
29614 {
29615 struct ast_sockaddr *addrs;
29616 int addrs_cnt;
29617
29618 addrs_cnt = ast_sockaddr_resolve(&addrs, name, flag, family);
29619 if (addrs_cnt <= 0) {
29620 return 1;
29621 }
29622 if (addrs_cnt > 1) {
29623 ast_debug(1, "Multiple addresses, using the first one only\n");
29624 }
29625
29626 ast_sockaddr_copy(addr, &addrs[0]);
29627
29628 ast_free(addrs);
29629 return 0;
29630 }
29631
29632
29633
29634
29635
29636 static int ast_sockaddr_resolve_first(struct ast_sockaddr *addr,
29637 const char* name, int flag)
29638 {
29639 return ast_sockaddr_resolve_first_af(addr, name, flag, get_address_family_filter(&bindaddr));
29640 }
29641
29642
29643
29644
29645 static int peer_hash_cb(const void *obj, const int flags)
29646 {
29647 const struct sip_peer *peer = obj;
29648
29649 return ast_str_case_hash(peer->name);
29650 }
29651
29652
29653
29654
29655 static int peer_cmp_cb(void *obj, void *arg, int flags)
29656 {
29657 struct sip_peer *peer = obj, *peer2 = arg;
29658
29659 return !strcasecmp(peer->name, peer2->name) ? CMP_MATCH | CMP_STOP : 0;
29660 }
29661
29662
29663
29664
29665
29666
29667 static int peer_iphash_cb(const void *obj, const int flags)
29668 {
29669 const struct sip_peer *peer = obj;
29670 int ret = 0;
29671
29672 if (ast_sockaddr_isnull(&peer->addr)) {
29673 ast_log(LOG_ERROR, "Empty address\n");
29674 }
29675
29676 ret = ast_sockaddr_hash(&peer->addr);
29677
29678 if (ret < 0) {
29679 ret = -ret;
29680 }
29681
29682 return ret;
29683 }
29684
29685
29686
29687
29688
29689
29690
29691
29692
29693
29694
29695
29696
29697
29698
29699
29700
29701
29702
29703 static int peer_ipcmp_cb(void *obj, void *arg, int flags)
29704 {
29705 struct sip_peer *peer = obj, *peer2 = arg;
29706
29707 if (ast_sockaddr_cmp_addr(&peer->addr, &peer2->addr)) {
29708
29709 return 0;
29710 }
29711
29712
29713 if ((peer->transports & peer2->transports) & (SIP_TRANSPORT_TLS | SIP_TRANSPORT_TCP)) {
29714
29715 return CMP_MATCH | CMP_STOP;
29716 } else if (ast_test_flag(&peer2->flags[0], SIP_INSECURE_PORT)) {
29717
29718
29719 return ast_test_flag(&peer->flags[0], SIP_INSECURE_PORT) ?
29720 (CMP_MATCH | CMP_STOP) : 0;
29721 }
29722
29723
29724 return ast_sockaddr_port(&peer->addr) == ast_sockaddr_port(&peer2->addr) ?
29725 (CMP_MATCH | CMP_STOP) : 0;
29726 }
29727
29728
29729 static int threadt_hash_cb(const void *obj, const int flags)
29730 {
29731 const struct sip_threadinfo *th = obj;
29732
29733 return ast_sockaddr_hash(&th->tcptls_session->remote_address);
29734 }
29735
29736 static int threadt_cmp_cb(void *obj, void *arg, int flags)
29737 {
29738 struct sip_threadinfo *th = obj, *th2 = arg;
29739
29740 return (th->tcptls_session == th2->tcptls_session) ? CMP_MATCH | CMP_STOP : 0;
29741 }
29742
29743
29744
29745
29746 static int dialog_hash_cb(const void *obj, const int flags)
29747 {
29748 const struct sip_pvt *pvt = obj;
29749
29750 return ast_str_case_hash(pvt->callid);
29751 }
29752
29753
29754
29755
29756 static int dialog_find_multiple(void *obj, void *arg, int flags)
29757 {
29758 struct sip_pvt *pvt = obj, *pvt2 = arg;
29759
29760 return !strcasecmp(pvt->callid, pvt2->callid) ? CMP_MATCH : 0;
29761 }
29762
29763
29764
29765
29766 static int dialog_cmp_cb(void *obj, void *arg, int flags)
29767 {
29768 struct sip_pvt *pvt = obj, *pvt2 = arg;
29769
29770 return !strcasecmp(pvt->callid, pvt2->callid) ? CMP_MATCH | CMP_STOP : 0;
29771 }
29772
29773
29774 static struct ast_cli_entry cli_sip[] = {
29775 AST_CLI_DEFINE(sip_show_channels, "List active SIP channels or subscriptions"),
29776 AST_CLI_DEFINE(sip_show_channelstats, "List statistics for active SIP channels"),
29777 AST_CLI_DEFINE(sip_show_domains, "List our local SIP domains"),
29778 AST_CLI_DEFINE(sip_show_inuse, "List all inuse/limits"),
29779 AST_CLI_DEFINE(sip_show_objects, "List all SIP object allocations"),
29780 AST_CLI_DEFINE(sip_show_peers, "List defined SIP peers"),
29781 AST_CLI_DEFINE(sip_show_registry, "List SIP registration status"),
29782 AST_CLI_DEFINE(sip_unregister, "Unregister (force expiration) a SIP peer from the registry"),
29783 AST_CLI_DEFINE(sip_show_settings, "Show SIP global settings"),
29784 AST_CLI_DEFINE(sip_show_mwi, "Show MWI subscriptions"),
29785 AST_CLI_DEFINE(sip_cli_notify, "Send a notify packet to a SIP peer"),
29786 AST_CLI_DEFINE(sip_show_channel, "Show detailed SIP channel info"),
29787 AST_CLI_DEFINE(sip_show_history, "Show SIP dialog history"),
29788 AST_CLI_DEFINE(sip_show_peer, "Show details on specific SIP peer"),
29789 AST_CLI_DEFINE(sip_show_users, "List defined SIP users"),
29790 AST_CLI_DEFINE(sip_show_user, "Show details on specific SIP user"),
29791 AST_CLI_DEFINE(sip_qualify_peer, "Send an OPTIONS packet to a peer"),
29792 AST_CLI_DEFINE(sip_show_sched, "Present a report on the status of the scheduler queue"),
29793 AST_CLI_DEFINE(sip_prune_realtime, "Prune cached Realtime users/peers"),
29794 AST_CLI_DEFINE(sip_do_debug, "Enable/Disable SIP debugging"),
29795 AST_CLI_DEFINE(sip_set_history, "Enable/Disable SIP history"),
29796 AST_CLI_DEFINE(sip_reload, "Reload SIP configuration"),
29797 AST_CLI_DEFINE(sip_show_tcp, "List TCP Connections")
29798 };
29799
29800
29801 static void sip_register_tests(void)
29802 {
29803 sip_config_parser_register_tests();
29804 sip_request_parser_register_tests();
29805 sip_dialplan_function_register_tests();
29806 }
29807
29808
29809 static void sip_unregister_tests(void)
29810 {
29811 sip_config_parser_unregister_tests();
29812 sip_request_parser_unregister_tests();
29813 sip_dialplan_function_unregister_tests();
29814 }
29815
29816 #ifdef TEST_FRAMEWORK
29817 AST_TEST_DEFINE(test_sip_mwi_subscribe_parse)
29818 {
29819 int found = 0;
29820 enum ast_test_result_state res = AST_TEST_PASS;
29821 const char *mwi1 = "1234@mysipprovider.com/1234";
29822 const char *mwi2 = "1234:password@mysipprovider.com/1234";
29823 const char *mwi3 = "1234:password@mysipprovider.com:5061/1234";
29824 const char *mwi4 = "1234:password:authuser@mysipprovider.com/1234";
29825 const char *mwi5 = "1234:password:authuser@mysipprovider.com:5061/1234";
29826 const char *mwi6 = "1234:password";
29827
29828 switch (cmd) {
29829 case TEST_INIT:
29830 info->name = "sip_mwi_subscribe_parse_test";
29831 info->category = "/channels/chan_sip/";
29832 info->summary = "SIP MWI subscribe line parse unit test";
29833 info->description =
29834 "Tests the parsing of mwi subscription lines (e.g., mwi => from sip.conf)";
29835 return AST_TEST_NOT_RUN;
29836 case TEST_EXECUTE:
29837 break;
29838 }
29839
29840 if (sip_subscribe_mwi(mwi1, 1)) {
29841 res = AST_TEST_FAIL;
29842 } else {
29843 found = 0;
29844 res = AST_TEST_FAIL;
29845 ASTOBJ_CONTAINER_TRAVERSE(&submwil, 1, do {
29846 ASTOBJ_WRLOCK(iterator);
29847 if (
29848 !strcmp(iterator->hostname, "mysipprovider.com") &&
29849 !strcmp(iterator->username, "1234") &&
29850 !strcmp(iterator->secret, "") &&
29851 !strcmp(iterator->authuser, "") &&
29852 !strcmp(iterator->mailbox, "1234") &&
29853 iterator->portno == 0) {
29854 found = 1;
29855 res = AST_TEST_PASS;
29856 }
29857 ASTOBJ_UNLOCK(iterator);
29858 } while(0));
29859 if (!found) {
29860 ast_test_status_update(test, "sip_subscribe_mwi test 1 failed\n");
29861 }
29862 }
29863
29864 if (sip_subscribe_mwi(mwi2, 1)) {
29865 res = AST_TEST_FAIL;
29866 } else {
29867 found = 0;
29868 res = AST_TEST_FAIL;
29869 ASTOBJ_CONTAINER_TRAVERSE(&submwil, 1, do {
29870 ASTOBJ_WRLOCK(iterator);
29871 if (
29872 !strcmp(iterator->hostname, "mysipprovider.com") &&
29873 !strcmp(iterator->username, "1234") &&
29874 !strcmp(iterator->secret, "password") &&
29875 !strcmp(iterator->authuser, "") &&
29876 !strcmp(iterator->mailbox, "1234") &&
29877 iterator->portno == 0) {
29878 found = 1;
29879 res = AST_TEST_PASS;
29880 }
29881 ASTOBJ_UNLOCK(iterator);
29882 } while(0));
29883 if (!found) {
29884 ast_test_status_update(test, "sip_subscribe_mwi test 2 failed\n");
29885 }
29886 }
29887
29888 if (sip_subscribe_mwi(mwi3, 1)) {
29889 res = AST_TEST_FAIL;
29890 } else {
29891 found = 0;
29892 res = AST_TEST_FAIL;
29893 ASTOBJ_CONTAINER_TRAVERSE(&submwil, 1, do {
29894 ASTOBJ_WRLOCK(iterator);
29895 if (
29896 !strcmp(iterator->hostname, "mysipprovider.com") &&
29897 !strcmp(iterator->username, "1234") &&
29898 !strcmp(iterator->secret, "password") &&
29899 !strcmp(iterator->authuser, "") &&
29900 !strcmp(iterator->mailbox, "1234") &&
29901 iterator->portno == 5061) {
29902 found = 1;
29903 res = AST_TEST_PASS;
29904 }
29905 ASTOBJ_UNLOCK(iterator);
29906 } while(0));
29907 if (!found) {
29908 ast_test_status_update(test, "sip_subscribe_mwi test 3 failed\n");
29909 }
29910 }
29911
29912 if (sip_subscribe_mwi(mwi4, 1)) {
29913 res = AST_TEST_FAIL;
29914 } else {
29915 found = 0;
29916 res = AST_TEST_FAIL;
29917 ASTOBJ_CONTAINER_TRAVERSE(&submwil, 1, do {
29918 ASTOBJ_WRLOCK(iterator);
29919 if (
29920 !strcmp(iterator->hostname, "mysipprovider.com") &&
29921 !strcmp(iterator->username, "1234") &&
29922 !strcmp(iterator->secret, "password") &&
29923 !strcmp(iterator->authuser, "authuser") &&
29924 !strcmp(iterator->mailbox, "1234") &&
29925 iterator->portno == 0) {
29926 found = 1;
29927 res = AST_TEST_PASS;
29928 }
29929 ASTOBJ_UNLOCK(iterator);
29930 } while(0));
29931 if (!found) {
29932 ast_test_status_update(test, "sip_subscribe_mwi test 4 failed\n");
29933 }
29934 }
29935
29936 if (sip_subscribe_mwi(mwi5, 1)) {
29937 res = AST_TEST_FAIL;
29938 } else {
29939 found = 0;
29940 res = AST_TEST_FAIL;
29941 ASTOBJ_CONTAINER_TRAVERSE(&submwil, 1, do {
29942 ASTOBJ_WRLOCK(iterator);
29943 if (
29944 !strcmp(iterator->hostname, "mysipprovider.com") &&
29945 !strcmp(iterator->username, "1234") &&
29946 !strcmp(iterator->secret, "password") &&
29947 !strcmp(iterator->authuser, "authuser") &&
29948 !strcmp(iterator->mailbox, "1234") &&
29949 iterator->portno == 5061) {
29950 found = 1;
29951 res = AST_TEST_PASS;
29952 }
29953 ASTOBJ_UNLOCK(iterator);
29954 } while(0));
29955 if (!found) {
29956 ast_test_status_update(test, "sip_subscribe_mwi test 5 failed\n");
29957 }
29958 }
29959
29960 if (sip_subscribe_mwi(mwi6, 1)) {
29961 res = AST_TEST_PASS;
29962 } else {
29963 res = AST_TEST_FAIL;
29964 }
29965 return res;
29966 }
29967
29968 AST_TEST_DEFINE(test_sip_peers_get)
29969 {
29970 struct sip_peer *peer;
29971 struct ast_data *node;
29972 struct ast_data_query query = {
29973 .path = "/asterisk/channel/sip/peers",
29974 .search = "peers/peer/name=test_peer_data_provider"
29975 };
29976
29977 switch (cmd) {
29978 case TEST_INIT:
29979 info->name = "sip_peers_get_data_test";
29980 info->category = "/main/data/sip/peers/";
29981 info->summary = "SIP peers data providers unit test";
29982 info->description =
29983 "Tests whether the SIP peers data provider implementation works as expected.";
29984 return AST_TEST_NOT_RUN;
29985 case TEST_EXECUTE:
29986 break;
29987 }
29988
29989
29990 peer = build_peer("test_peer_data_provider", NULL, NULL, 0, 0);
29991 if (!peer) {
29992 return AST_TEST_FAIL;
29993 }
29994 peer->type = SIP_TYPE_USER;
29995 peer->call_limit = 10;
29996 ao2_link(peers, peer);
29997
29998
29999 node = ast_data_get(&query);
30000 if (!node) {
30001 ao2_unlink(peers, peer);
30002 ao2_ref(peer, -1);
30003 return AST_TEST_FAIL;
30004 }
30005
30006
30007 if (strcmp(ast_data_retrieve_string(node, "peer/name"), "test_peer_data_provider")) {
30008 ao2_unlink(peers, peer);
30009 ao2_ref(peer, -1);
30010 ast_data_free(node);
30011 return AST_TEST_FAIL;
30012 }
30013
30014 if (strcmp(ast_data_retrieve_string(node, "peer/type"), "user")) {
30015 ao2_unlink(peers, peer);
30016 ao2_ref(peer, -1);
30017 ast_data_free(node);
30018 return AST_TEST_FAIL;
30019 }
30020
30021 if (ast_data_retrieve_int(node, "peer/call_limit") != 10) {
30022 ao2_unlink(peers, peer);
30023 ao2_ref(peer, -1);
30024 ast_data_free(node);
30025 return AST_TEST_FAIL;
30026 }
30027
30028
30029 ast_data_free(node);
30030
30031 ao2_unlink(peers, peer);
30032 ao2_ref(peer, -1);
30033
30034 return AST_TEST_PASS;
30035 }
30036
30037 #endif
30038
30039 #define DATA_EXPORT_SIP_PEER(MEMBER) \
30040 MEMBER(sip_peer, name, AST_DATA_STRING) \
30041 MEMBER(sip_peer, secret, AST_DATA_PASSWORD) \
30042 MEMBER(sip_peer, md5secret, AST_DATA_PASSWORD) \
30043 MEMBER(sip_peer, remotesecret, AST_DATA_PASSWORD) \
30044 MEMBER(sip_peer, context, AST_DATA_STRING) \
30045 MEMBER(sip_peer, subscribecontext, AST_DATA_STRING) \
30046 MEMBER(sip_peer, username, AST_DATA_STRING) \
30047 MEMBER(sip_peer, accountcode, AST_DATA_STRING) \
30048 MEMBER(sip_peer, tohost, AST_DATA_STRING) \
30049 MEMBER(sip_peer, regexten, AST_DATA_STRING) \
30050 MEMBER(sip_peer, fromuser, AST_DATA_STRING) \
30051 MEMBER(sip_peer, fromdomain, AST_DATA_STRING) \
30052 MEMBER(sip_peer, fullcontact, AST_DATA_STRING) \
30053 MEMBER(sip_peer, cid_num, AST_DATA_STRING) \
30054 MEMBER(sip_peer, cid_name, AST_DATA_STRING) \
30055 MEMBER(sip_peer, vmexten, AST_DATA_STRING) \
30056 MEMBER(sip_peer, language, AST_DATA_STRING) \
30057 MEMBER(sip_peer, mohinterpret, AST_DATA_STRING) \
30058 MEMBER(sip_peer, mohsuggest, AST_DATA_STRING) \
30059 MEMBER(sip_peer, parkinglot, AST_DATA_STRING) \
30060 MEMBER(sip_peer, useragent, AST_DATA_STRING) \
30061 MEMBER(sip_peer, mwi_from, AST_DATA_STRING) \
30062 MEMBER(sip_peer, engine, AST_DATA_STRING) \
30063 MEMBER(sip_peer, unsolicited_mailbox, AST_DATA_STRING) \
30064 MEMBER(sip_peer, is_realtime, AST_DATA_BOOLEAN) \
30065 MEMBER(sip_peer, host_dynamic, AST_DATA_BOOLEAN) \
30066 MEMBER(sip_peer, autoframing, AST_DATA_BOOLEAN) \
30067 MEMBER(sip_peer, inUse, AST_DATA_INTEGER) \
30068 MEMBER(sip_peer, inRinging, AST_DATA_INTEGER) \
30069 MEMBER(sip_peer, onHold, AST_DATA_INTEGER) \
30070 MEMBER(sip_peer, call_limit, AST_DATA_INTEGER) \
30071 MEMBER(sip_peer, t38_maxdatagram, AST_DATA_INTEGER) \
30072 MEMBER(sip_peer, maxcallbitrate, AST_DATA_INTEGER) \
30073 MEMBER(sip_peer, rtptimeout, AST_DATA_SECONDS) \
30074 MEMBER(sip_peer, rtpholdtimeout, AST_DATA_SECONDS) \
30075 MEMBER(sip_peer, rtpkeepalive, AST_DATA_SECONDS) \
30076 MEMBER(sip_peer, lastms, AST_DATA_MILLISECONDS) \
30077 MEMBER(sip_peer, maxms, AST_DATA_MILLISECONDS) \
30078 MEMBER(sip_peer, qualifyfreq, AST_DATA_MILLISECONDS) \
30079 MEMBER(sip_peer, timer_t1, AST_DATA_MILLISECONDS) \
30080 MEMBER(sip_peer, timer_b, AST_DATA_MILLISECONDS)
30081
30082 AST_DATA_STRUCTURE(sip_peer, DATA_EXPORT_SIP_PEER);
30083
30084 static int peers_data_provider_get(const struct ast_data_search *search,
30085 struct ast_data *data_root)
30086 {
30087 struct sip_peer *peer;
30088 struct ao2_iterator i;
30089 struct ast_data *data_peer, *data_peer_mailboxes = NULL, *data_peer_mailbox, *enum_node;
30090 struct ast_data *data_sip_options;
30091 int total_mailboxes, x;
30092 struct sip_mailbox *mailbox;
30093
30094 i = ao2_iterator_init(peers, 0);
30095 while ((peer = ao2_iterator_next(&i))) {
30096 ao2_lock(peer);
30097
30098 data_peer = ast_data_add_node(data_root, "peer");
30099 if (!data_peer) {
30100 ao2_unlock(peer);
30101 ao2_ref(peer, -1);
30102 continue;
30103 }
30104
30105 ast_data_add_structure(sip_peer, data_peer, peer);
30106
30107
30108 enum_node = ast_data_add_node(data_peer, "allowtransfer");
30109 if (!enum_node) {
30110 ao2_unlock(peer);
30111 ao2_ref(peer, -1);
30112 continue;
30113 }
30114 ast_data_add_str(enum_node, "text", transfermode2str(peer->allowtransfer));
30115 ast_data_add_int(enum_node, "value", peer->allowtransfer);
30116
30117
30118 ast_data_add_str(data_peer, "transports", get_transport_list(peer->transports));
30119
30120
30121 if ((peer->type & SIP_TYPE_USER) && (peer->type & SIP_TYPE_PEER)) {
30122 ast_data_add_str(data_peer, "type", "friend");
30123 } else if (peer->type & SIP_TYPE_PEER) {
30124 ast_data_add_str(data_peer, "type", "peer");
30125 } else if (peer->type & SIP_TYPE_USER) {
30126 ast_data_add_str(data_peer, "type", "user");
30127 }
30128
30129
30130 total_mailboxes = 0;
30131 AST_LIST_TRAVERSE(&peer->mailboxes, mailbox, entry) {
30132 if (!total_mailboxes) {
30133 data_peer_mailboxes = ast_data_add_node(data_peer, "mailboxes");
30134 if (!data_peer_mailboxes) {
30135 break;
30136 }
30137 total_mailboxes++;
30138 }
30139
30140 data_peer_mailbox = ast_data_add_node(data_peer_mailboxes, "mailbox");
30141 if (!data_peer_mailbox) {
30142 continue;
30143 }
30144 ast_data_add_str(data_peer_mailbox, "mailbox", mailbox->mailbox);
30145 ast_data_add_str(data_peer_mailbox, "context", mailbox->context);
30146 }
30147
30148
30149 enum_node = ast_data_add_node(data_peer, "amaflags");
30150 if (!enum_node) {
30151 ao2_unlock(peer);
30152 ao2_ref(peer, -1);
30153 continue;
30154 }
30155 ast_data_add_int(enum_node, "value", peer->amaflags);
30156 ast_data_add_str(enum_node, "text", ast_cdr_flags2str(peer->amaflags));
30157
30158
30159 data_sip_options = ast_data_add_node(data_peer, "sipoptions");
30160 if (!data_sip_options) {
30161 ao2_unlock(peer);
30162 ao2_ref(peer, -1);
30163 continue;
30164 }
30165 for (x = 0 ; x < ARRAY_LEN(sip_options); x++) {
30166 ast_data_add_bool(data_sip_options, sip_options[x].text, peer->sipoptions & sip_options[x].id);
30167 }
30168
30169
30170 enum_node = ast_data_add_node(data_peer, "callingpres");
30171 if (!enum_node) {
30172 ao2_unlock(peer);
30173 ao2_ref(peer, -1);
30174 continue;
30175 }
30176 ast_data_add_int(enum_node, "value", peer->callingpres);
30177 ast_data_add_str(enum_node, "text", ast_describe_caller_presentation(peer->callingpres));
30178
30179
30180 ast_data_add_codecs(data_peer, "codecs", peer->capability);
30181
30182 if (!ast_data_search_match(search, data_peer)) {
30183 ast_data_remove_node(data_root, data_peer);
30184 }
30185
30186 ao2_unlock(peer);
30187 ao2_ref(peer, -1);
30188 }
30189 ao2_iterator_destroy(&i);
30190
30191 return 0;
30192 }
30193
30194 static const struct ast_data_handler peers_data_provider = {
30195 .version = AST_DATA_HANDLER_VERSION,
30196 .get = peers_data_provider_get
30197 };
30198
30199 static const struct ast_data_entry sip_data_providers[] = {
30200 AST_DATA_ENTRY("asterisk/channel/sip/peers", &peers_data_provider),
30201 };
30202
30203
30204 static int load_module(void)
30205 {
30206 ast_verbose("SIP channel loading...\n");
30207
30208
30209
30210 peers = ao2_t_container_alloc(HASH_PEER_SIZE, peer_hash_cb, peer_cmp_cb, "allocate peers");
30211 peers_by_ip = ao2_t_container_alloc(HASH_PEER_SIZE, peer_iphash_cb, peer_ipcmp_cb, "allocate peers_by_ip");
30212 dialogs = ao2_t_container_alloc(HASH_DIALOG_SIZE, dialog_hash_cb, dialog_cmp_cb, "allocate dialogs");
30213 dialogs_to_destroy = ao2_t_container_alloc(1, NULL, NULL, "allocate dialogs_to_destroy");
30214 threadt = ao2_t_container_alloc(HASH_DIALOG_SIZE, threadt_hash_cb, threadt_cmp_cb, "allocate threadt table");
30215 if (!peers || !peers_by_ip || !dialogs || !dialogs_to_destroy || !threadt) {
30216 ast_log(LOG_ERROR, "Unable to create primary SIP container(s)\n");
30217 return AST_MODULE_LOAD_FAILURE;
30218 }
30219
30220 ASTOBJ_CONTAINER_INIT(®l);
30221 ASTOBJ_CONTAINER_INIT(&submwil);
30222
30223 if (!(sched = sched_context_create())) {
30224 ast_log(LOG_ERROR, "Unable to create scheduler context\n");
30225 return AST_MODULE_LOAD_FAILURE;
30226 }
30227
30228 if (!(io = io_context_create())) {
30229 ast_log(LOG_ERROR, "Unable to create I/O context\n");
30230 sched_context_destroy(sched);
30231 return AST_MODULE_LOAD_FAILURE;
30232 }
30233
30234 sip_reloadreason = CHANNEL_MODULE_LOAD;
30235
30236 can_parse_xml = sip_is_xml_parsable();
30237 if (reload_config(sip_reloadreason)) {
30238 return AST_MODULE_LOAD_DECLINE;
30239 }
30240
30241
30242
30243
30244
30245 memcpy(&sip_tech_info, &sip_tech, sizeof(sip_tech));
30246 memset((void *) &sip_tech_info.send_digit_begin, 0, sizeof(sip_tech_info.send_digit_begin));
30247
30248
30249 if (ast_channel_register(&sip_tech)) {
30250 ast_log(LOG_ERROR, "Unable to register channel type 'SIP'\n");
30251 io_context_destroy(io);
30252 sched_context_destroy(sched);
30253 return AST_MODULE_LOAD_FAILURE;
30254 }
30255
30256 #ifdef TEST_FRAMEWORK
30257 AST_TEST_REGISTER(test_sip_peers_get);
30258 AST_TEST_REGISTER(test_sip_mwi_subscribe_parse);
30259 #endif
30260
30261
30262 ast_data_register_multiple(sip_data_providers, ARRAY_LEN(sip_data_providers));
30263
30264
30265 ast_cli_register_multiple(cli_sip, ARRAY_LEN(cli_sip));
30266
30267
30268 ast_udptl_proto_register(&sip_udptl);
30269
30270
30271 ast_rtp_glue_register(&sip_rtp_glue);
30272
30273
30274 ast_register_application_xml(app_dtmfmode, sip_dtmfmode);
30275 ast_register_application_xml(app_sipaddheader, sip_addheader);
30276 ast_register_application_xml(app_sipremoveheader, sip_removeheader);
30277
30278
30279 ast_custom_function_register(&sip_header_function);
30280 ast_custom_function_register(&sippeer_function);
30281 ast_custom_function_register(&sipchaninfo_function);
30282 ast_custom_function_register(&checksipdomain_function);
30283
30284
30285 ast_manager_register_xml("SIPpeers", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_sip_show_peers);
30286 ast_manager_register_xml("SIPshowpeer", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_sip_show_peer);
30287 ast_manager_register_xml("SIPqualifypeer", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_sip_qualify_peer);
30288 ast_manager_register_xml("SIPshowregistry", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, manager_show_registry);
30289 ast_manager_register_xml("SIPnotify", EVENT_FLAG_SYSTEM, manager_sipnotify);
30290 sip_poke_all_peers();
30291 sip_send_all_registers();
30292 sip_send_all_mwi_subscriptions();
30293 initialize_escs();
30294
30295 if (sip_epa_register(&cc_epa_static_data)) {
30296 return AST_MODULE_LOAD_DECLINE;
30297 }
30298
30299 if (sip_reqresp_parser_init() == -1) {
30300 ast_log(LOG_ERROR, "Unable to initialize the SIP request and response parser\n");
30301 return AST_MODULE_LOAD_DECLINE;
30302 }
30303
30304 if (can_parse_xml) {
30305
30306
30307
30308 if (ast_cc_agent_register(&sip_cc_agent_callbacks)) {
30309 return AST_MODULE_LOAD_DECLINE;
30310 }
30311 }
30312 if (ast_cc_monitor_register(&sip_cc_monitor_callbacks)) {
30313 return AST_MODULE_LOAD_DECLINE;
30314 }
30315 if (!(sip_monitor_instances = ao2_container_alloc(37, sip_monitor_instance_hash_fn, sip_monitor_instance_cmp_fn))) {
30316 return AST_MODULE_LOAD_DECLINE;
30317 }
30318
30319
30320 restart_monitor();
30321
30322 ast_realtime_require_field(ast_check_realtime("sipregs") ? "sipregs" : "sippeers",
30323 "name", RQ_CHAR, 10,
30324 "ipaddr", RQ_CHAR, INET6_ADDRSTRLEN - 1,
30325 "port", RQ_UINTEGER2, 5,
30326 "regseconds", RQ_INTEGER4, 11,
30327 "defaultuser", RQ_CHAR, 10,
30328 "fullcontact", RQ_CHAR, 35,
30329 "regserver", RQ_CHAR, 20,
30330 "useragent", RQ_CHAR, 20,
30331 "lastms", RQ_INTEGER4, 11,
30332 SENTINEL);
30333
30334
30335 sip_register_tests();
30336 network_change_event_subscribe();
30337
30338 return AST_MODULE_LOAD_SUCCESS;
30339 }
30340
30341
30342 static int unload_module(void)
30343 {
30344 struct sip_pvt *p;
30345 struct sip_threadinfo *th;
30346 struct ast_context *con;
30347 struct ao2_iterator i;
30348
30349 network_change_event_unsubscribe();
30350
30351 ast_sched_dump(sched);
30352
30353
30354 ast_channel_unregister(&sip_tech);
30355
30356
30357 ast_custom_function_unregister(&sipchaninfo_function);
30358 ast_custom_function_unregister(&sippeer_function);
30359 ast_custom_function_unregister(&sip_header_function);
30360 ast_custom_function_unregister(&checksipdomain_function);
30361
30362
30363 ast_unregister_application(app_dtmfmode);
30364 ast_unregister_application(app_sipaddheader);
30365 ast_unregister_application(app_sipremoveheader);
30366
30367 #ifdef TEST_FRAMEWORK
30368 AST_TEST_UNREGISTER(test_sip_peers_get);
30369 AST_TEST_UNREGISTER(test_sip_mwi_subscribe_parse);
30370 #endif
30371
30372 ast_data_unregister(NULL);
30373
30374
30375 ast_cli_unregister_multiple(cli_sip, ARRAY_LEN(cli_sip));
30376
30377
30378 ast_udptl_proto_unregister(&sip_udptl);
30379
30380
30381 ast_rtp_glue_unregister(&sip_rtp_glue);
30382
30383
30384 ast_manager_unregister("SIPpeers");
30385 ast_manager_unregister("SIPshowpeer");
30386 ast_manager_unregister("SIPqualifypeer");
30387 ast_manager_unregister("SIPshowregistry");
30388 ast_manager_unregister("SIPnotify");
30389
30390
30391 if (sip_tcp_desc.master) {
30392 ast_tcptls_server_stop(&sip_tcp_desc);
30393 }
30394 if (sip_tls_desc.master) {
30395 ast_tcptls_server_stop(&sip_tls_desc);
30396 }
30397
30398
30399 i = ao2_iterator_init(threadt, 0);
30400 while ((th = ao2_t_iterator_next(&i, "iterate through tcp threads for 'sip show tcp'"))) {
30401 pthread_t thread = th->threadid;
30402 th->stop = 1;
30403 pthread_kill(thread, SIGURG);
30404 pthread_join(thread, NULL);
30405 ao2_t_ref(th, -1, "decrement ref from iterator");
30406 }
30407 ao2_iterator_destroy(&i);
30408
30409
30410 i = ao2_iterator_init(dialogs, 0);
30411 while ((p = ao2_t_iterator_next(&i, "iterate thru dialogs"))) {
30412 if (p->owner)
30413 ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
30414 ao2_t_ref(p, -1, "toss dialog ptr from iterator_next");
30415 }
30416 ao2_iterator_destroy(&i);
30417
30418 unlink_all_peers_from_tables();
30419
30420 ast_mutex_lock(&monlock);
30421 if (monitor_thread && (monitor_thread != AST_PTHREADT_STOP) && (monitor_thread != AST_PTHREADT_NULL)) {
30422 pthread_cancel(monitor_thread);
30423 pthread_kill(monitor_thread, SIGURG);
30424 pthread_join(monitor_thread, NULL);
30425 }
30426 monitor_thread = AST_PTHREADT_STOP;
30427 ast_mutex_unlock(&monlock);
30428
30429
30430 i = ao2_iterator_init(dialogs, 0);
30431 while ((p = ao2_t_iterator_next(&i, "iterate thru dialogs"))) {
30432 dialog_unlink_all(p);
30433 ao2_t_ref(p, -1, "throw away iterator result");
30434 }
30435 ao2_iterator_destroy(&i);
30436
30437
30438 ast_free_ha(localaddr);
30439
30440 ast_mutex_lock(&authl_lock);
30441 if (authl) {
30442 ao2_t_ref(authl, -1, "Removing global authentication");
30443 authl = NULL;
30444 }
30445 ast_mutex_unlock(&authl_lock);
30446
30447 sip_epa_unregister_all();
30448 destroy_escs();
30449
30450 if (default_tls_cfg.certfile) {
30451 ast_free(default_tls_cfg.certfile);
30452 }
30453 if (default_tls_cfg.pvtfile) {
30454 ast_free(default_tls_cfg.pvtfile);
30455 }
30456 if (default_tls_cfg.cipher) {
30457 ast_free(default_tls_cfg.cipher);
30458 }
30459 if (default_tls_cfg.cafile) {
30460 ast_free(default_tls_cfg.cafile);
30461 }
30462 if (default_tls_cfg.capath) {
30463 ast_free(default_tls_cfg.capath);
30464 }
30465
30466 cleanup_all_regs();
30467 ASTOBJ_CONTAINER_DESTROYALL(®l, sip_registry_destroy);
30468 ASTOBJ_CONTAINER_DESTROY(®l);
30469
30470 ASTOBJ_CONTAINER_TRAVERSE(&submwil, 1, do {
30471 ASTOBJ_WRLOCK(iterator);
30472 if (iterator->dnsmgr) {
30473 ast_dnsmgr_release(iterator->dnsmgr);
30474 iterator->dnsmgr = NULL;
30475 ASTOBJ_UNREF(iterator, sip_subscribe_mwi_destroy);
30476 }
30477 ASTOBJ_UNLOCK(iterator);
30478 } while(0));
30479 ASTOBJ_CONTAINER_DESTROYALL(&submwil, sip_subscribe_mwi_destroy);
30480 ASTOBJ_CONTAINER_DESTROY(&submwil);
30481
30482 ao2_t_ref(peers, -1, "unref the peers table");
30483 ao2_t_ref(peers_by_ip, -1, "unref the peers_by_ip table");
30484 ao2_t_ref(dialogs, -1, "unref the dialogs table");
30485 ao2_t_ref(dialogs_to_destroy, -1, "unref dialogs_to_destroy");
30486 ao2_t_ref(threadt, -1, "unref the thread table");
30487 ao2_t_ref(sip_monitor_instances, -1, "unref the sip_monitor_instances table");
30488
30489 clear_sip_domains();
30490 ast_free_ha(sip_cfg.contact_ha);
30491 close(sipsock);
30492 sched_context_destroy(sched);
30493 con = ast_context_find(used_context);
30494 if (con) {
30495 ast_context_destroy(con, "SIP");
30496 }
30497 ast_unload_realtime("sipregs");
30498 ast_unload_realtime("sippeers");
30499 ast_cc_monitor_unregister(&sip_cc_monitor_callbacks);
30500 ast_cc_agent_unregister(&sip_cc_agent_callbacks);
30501
30502 sip_reqresp_parser_exit();
30503 sip_unregister_tests();
30504
30505 return 0;
30506 }
30507
30508 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Session Initiation Protocol (SIP)",
30509 .load = load_module,
30510 .unload = unload_module,
30511 .reload = reload,
30512 .load_pri = AST_MODPRI_CHANNEL_DRIVER,
30513 .nonoptreq = "res_crypto,chan_local",
30514 );